rayzee 7.20.2 → 7.21.0

package/src/TSL/ShadeKernel.js

@@ -27,7 +27,7 @@ import { sampleChromaticCollision, sampleHenyeyGreenstein, subsurfaceCoefficient
 import { calculateIndirectLighting } from './LightsIndirect.js';
 import { IndirectLightingResult, sampleCone } from './LightsCore.js';
 import { regularizePathContribution, generateSampledDirection, computeNDCDepth, handleRussianRoulette } from './PathTracerCore.js';
-import { getImportanceSamplingInfo, evaluateDFG } from './MaterialProperties.js';
+import { evaluateDFG } from './MaterialProperties.js';
 import { dielectricF0 } from './Fresnel.js';
 import { sampleClearcoat, ClearcoatResult } from './Clearcoat.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
@@ -40,20 +40,20 @@ import {
 	MaterialSamples,
 	ExtMapResult,
 	DirectionSample,
-	ImportanceSamplingInfo,
 	MaterialClassification,
 	BRDFWeights,
 	MaterialCache,
 	DirectLightingDual,
 	DFGResult,
 } from './Struct.js';
-import { RandomValue, getRandomSample } from './Random.js';
+import { getRandomSample, getRandomSample1D, getRandomSample2D, SAMPLER_DIMS_PER_BOUNCE, SAMPLER_DIM_AUX_BASE } from './Random.js';
 import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
 import {
 	readRayOrigin, readRayDirection, readRayBounceFlags, readRayThroughput, readRayPdf,
 	readMediumStack, writeMediumStack, readMediumSigmaA, writeMediumSigmaA,
 	readPathBounces, readSssSteps, readSSSMedium, writeSSSMedium,
 	readTransparentCount,
+	readMisRayT,
 	readHitDistance, readHitBarycentrics, readHitNormal,
 	readHitMaterialIndex, readHitTriangleIndex,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
@@ -80,7 +80,7 @@ export function buildShadeKernel( params ) {
 		counters,
 		activeIndicesRO,
 		envTexture, environmentIntensity, envMatrix,
-		enableEnvironmentLight, useEnvMapIS,
+		enableEnvironmentLight,
 		groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight, groundProjectionLevel,
 		enableGroundCatcher, groundCatcherHeight,
 		envTotalSum, envCompensationDelta, envResolution,
@@ -95,6 +95,10 @@ export function buildShadeKernel( params ) {
 		globalIlluminationIntensity,
 		cameraProjectionMatrix, cameraViewMatrix,
 		fireflyThreshold, frame, resolution,
+		// Accumulation index, NOT the free-running seed counter `frame` rides. The firefly clamp
+		// relaxes as sqrt(frame+1) so its bias decays as a render converges; keying that off the
+		// seed axis let it grow for the whole session and disabled suppression outright.
+		accumFrame,
 		chunkRowBase, // chunked path pool: global pixel = chunkRowBase·W + localSlot (rayID). See spec.
 		emissiveTriangleCount, emissiveVec4Offset, emissiveTotalPower,
 		emissiveBoost, totalTriangleCount, enableEmissiveTriangleSampling,
@@ -114,17 +118,17 @@ export function buildShadeKernel( params ) {
 	// miss branch and the shadow catcher so their blur stays in lockstep (no horizon seam). normalize() the
 	// center direction — ground projection can return a non-unit vector, which would skew sampleCone's basis.
 	// Clamp the tap count to ≥1 so a 0 forced via the engine API can't produce a 0/0 NaN backdrop.
-	const sampleEnvBlurred = ( centerDir, halfAngle, samples, rng ) => {
+	const sampleEnvBlurred = ( centerDir, halfAngle, samples, rng, pixelCoord ) => {
 
 		const axis = normalize( centerDir ).toVar();
 		const n = max( samples, int( 1 ) ).toVar();
 		const acc = vec3( 0.0 ).toVar();
-		Loop( { start: int( 0 ), end: n, type: 'int', condition: '<' }, () => {
+		Loop( { start: int( 0 ), end: n, type: 'int', condition: '<' }, ( { i } ) => {
 
-			// per-component .toVar(): vec2(RandomValue, RandomValue) would collapse to u==v (TSL pitfall)
-			const u1 = RandomValue( rng ).toVar();
-			const u2 = RandomValue( rng ).toVar();
-			const jDir = sampleCone( axis, halfAngle, vec2( u1, u2 ) ).toVar();
+			// Tap count varies per pixel, so these cannot sit in a per-bounce block without
+			// running over into the next bounce's dimensions — they get the AUX range instead.
+			const jXi = getRandomSample2D( pixelCoord, int( 0 ), int( SAMPLER_DIM_AUX_BASE ).add( i ), rng, resolution, frame ).toVar();
+			const jDir = sampleCone( axis, halfAngle, jXi ).toVar();
 			acc.addAssign( sampleEnvironment( {
 				tex: envTexture,
 				samp: sampler( envTexture ),
@@ -189,6 +193,19 @@ export function buildShadeKernel( params ) {
 		const pixelIndex = rayID;
 		const rngState = rngBufferRW.element( rayID ).toVar();
 
+		// STBN keyed on (GLOBAL pixel, dimension, frame). pixelIndex is the LOCAL path slot; the global pixel
+		// = chunkRowBase·W + localSlot, so the blue-noise pattern stays spatially aligned across row-band chunks
+		// (and matches Generate's per-pixel RNG seed). chunkRowBase is 0 in the single-chunk case.
+		// Hoisted here rather than at the BSDF draw because the ground catcher runs NEE far earlier.
+		const _resX = int( resolution.x ).toVar();
+		const _globalPixel = int( pixelIndex ).add( chunkRowBase.mul( _resX ) );
+		const _pixelCoord = vec2(
+			float( _globalPixel.mod( _resX ) ).add( 0.5 ),
+			float( _globalPixel.div( _resX ) ).add( 0.5 ),
+		);
+		// This bounce's block of sampler dimensions — see the budget table in Random.js.
+		const dimBase = int( currentBounce ).mul( int( SAMPLER_DIMS_PER_BOUNCE ) );
+
 		// DDFA see-through aux tint carried across smooth glass/mirror; committed into the OIDN/ASVGF
 		// albedo guide at the first diffuse-enough surface (or env). Mutated locally, persisted on every
 		// deferring continue (a missed persist = stale tint). 1 = untinted (direct hit → today's albedo).
@@ -229,11 +246,9 @@ export function buildShadeKernel( params ) {
 					const planeMat = RayTracingMaterial.wrap( diffuseGroundMaterial() ).toVar();
 
 					// Cosine-weighted hemisphere BRDF sample about the plane normal (0,1,0); the helper
-					// puts cosθ along N, so bDir.y == cosθ. Per-component .toVar() on the two randoms
-					// (vec2(RandomValue,RandomValue) would collapse to u==v — TSL pitfall).
-					const u1 = RandomValue( rngState ).toVar();
-					const u2 = RandomValue( rngState ).toVar();
-					const bDir = cosineWeightedSample( planeN, vec2( u1, u2 ) ).toVar();
+					// puts cosθ along N, so bDir.y == cosθ.
+					const bXi = getRandomSample2D( _pixelCoord, int( 0 ), dimBase.add( int( 7 ) ), rngState, resolution, frame ).toVar();
+					const bDir = cosineWeightedSample( planeN, bXi ).toVar();
 					const bPdf = bDir.y.mul( PI_INV ).toVar(); // cosθ / π
 					const bVal = vec3( PI_INV ); // albedo(1) / π
 
@@ -243,6 +258,7 @@ export function buildShadeKernel( params ) {
 						planePoint, planeN, planeMat, planeV,
 						bDir, bPdf, bVal,
 						bounceIndex, rngState,
+						_pixelCoord, resolution, frame, dimBase,
 						directionalLightsBuffer, numDirectionalLights,
 						areaLightsBuffer, numAreaLights,
 						pointLightsBuffer, numPointLights,
@@ -289,7 +305,7 @@ export function buildShadeKernel( params ) {
 
 						If( backgroundBlurriness.greaterThan( 0.0 ), () => {
 
-							envBehind.assign( sampleEnvBlurred( catcherEnvDir, backgroundBlurriness.mul( 1.3 ), backgroundBlurSamples, rngState ) );
+							envBehind.assign( sampleEnvBlurred( catcherEnvDir, backgroundBlurriness.mul( 1.3 ), backgroundBlurSamples, rngState, _pixelCoord ) );
 
 						} ).Else( () => {
 
@@ -373,7 +389,7 @@ export function buildShadeKernel( params ) {
 				const envColor = vec3( 0.0 ).toVar();
 				If( isBackdropView.and( backgroundBlurriness.greaterThan( 0.0 ) ), () => {
 
-					envColor.assign( sampleEnvBlurred( envDir, backgroundBlurriness.mul( 1.3 ), backgroundBlurSamples, rngState ) );
+					envColor.assign( sampleEnvBlurred( envDir, backgroundBlurriness.mul( 1.3 ), backgroundBlurSamples, rngState, _pixelCoord ) );
 
 				} ).Else( () => {
 
@@ -394,7 +410,7 @@ export function buildShadeKernel( params ) {
 
 				// MIS weight for implicit env hit — prevents double-counting with NEE
 				const envMisWeight = float( 1.0 ).toVar();
-				If( isBackdropView.not().and( useEnvMapIS ), () => {
+				If( isBackdropView.not(), () => {
 
 					const prevBouncePdf = readRayPdf( rayBufferRW, rayID );
 					If( prevBouncePdf.greaterThan( 0.0 ), () => {
@@ -429,7 +445,7 @@ export function buildShadeKernel( params ) {
 					currentRadiance.xyz.add(
 						regularizePathContribution(
 							throughput.mul( envColor ).mul( envScale ),
-							fireflyPathLen, fireflyThreshold, int( frame ),
+							fireflyPathLen, fireflyThreshold, int( accumFrame ),
 						),
 					),
 					currentRadiance.w
@@ -519,13 +535,14 @@ export function buildShadeKernel( params ) {
 				const mSigmaT = mSigmaA.add( mSigmaS );
 				const coll = CollisionSample.wrap( sampleChromaticCollision(
 					mSigmaT, mSigmaS, throughput, hitDist, rngState,
+					_pixelCoord, resolution, frame, dimBase,
 				) ).toVar();
 				throughput.mulAssign( coll.weight );
 
 				If( coll.didScatter, () => {
 
 					// scatter via Henyey-Greenstein, continue as a free bounce off the sssSteps budget
-					const xi2 = vec2( RandomValue( rngState ), RandomValue( rngState ) );
+					const xi2 = getRandomSample2D( _pixelCoord, int( 0 ), dimBase.add( int( 6 ) ), rngState, resolution, frame );
 					const scatterPoint = origin.add( direction.mul( coll.t ) );
 					const newDir = sampleHenyeyGreenstein( direction, mG, xi2 ).toVar();
 					sssSteps.addAssign( 1 );
@@ -533,7 +550,7 @@ export function buildShadeKernel( params ) {
 					// terminate walk: step cap or Russian roulette
 					const rrP = clamp( max( max( throughput.x, throughput.y ), throughput.z ), 0.02, 1.0 ).toVar();
 					const terminate = sssSteps.greaterThanEqual( maxSubsurfaceSteps )
-						.or( RandomValue( rngState ).greaterThan( rrP ) ).toVar();
+						.or( getRandomSample1D( _pixelCoord, int( 0 ), dimBase.add( int( 12 ) ), rngState, resolution, frame ).greaterThan( rrP ) ).toVar();
 
 					If( terminate, () => {
 
@@ -728,6 +745,7 @@ export function buildShadeKernel( params ) {
 		const currentRay = Ray( { origin, direction } );
 		const interaction = MaterialInteractionResult.wrap( handleMaterialTransparency(
 			currentRay, N, material, rngState,
+			_pixelCoord, resolution, frame, dimBase,
 			int( transTraversals ),
 			currentMediumIOR, previousMediumIOR,
 			pathWavelength,
@@ -914,7 +932,10 @@ export function buildShadeKernel( params ) {
 				} );
 
 			} );
-			writeRayOriginMeta( rayBufferRW, rayID, newOrigin, cameraDepth, sssSteps, transparentCount );
+			// Alpha skip keeps the direction, so the MIS origin is recoverable: accumulate the segment.
+			// Any redirection (refraction/reflection/SSS) breaks the line — reset.
+			const misRayT = select( interaction.isAlphaSkip, readMisRayT( rayBufferRW, rayID ).add( hitDist ), float( 0.0 ) );
+			writeRayOriginMeta( rayBufferRW, rayID, newOrigin, cameraDepth, sssSteps, transparentCount, misRayT );
 			writeRayDirFlags( rayBufferRW, rayID, interaction.direction, flags );
 			// Free bounce: preserve prevBouncePdf (megakernel keeps the last opaque-scatter pdf across
 			// transmission/alpha-skip/SSS-boundary). Writing 1.0 corrupts the next bounce's env/emissive MIS,
@@ -967,18 +988,24 @@ export function buildShadeKernel( params ) {
 						// MIS partner pdf MUST match the actual NEE sampler: re-walk the Light BVH descent
 						// when it is active, else use the flat-CDF pdf. Mismatching them breaks MIS
 						// partition-of-unity → a real bias (see calculateLightBVHPdf).
+						// Evaluate it at the scatter point that produced prevBouncePdf — alpha skips moved
+						// the ray origin, and the skip-point pdf under-counts dist² so full-Le BSDF hits
+						// pass nearly unweighted (fireflies on emitters inside alpha-blend shades).
+						const misT = readMisRayT( rayBufferRW, rayID ).toVar();
+						const misOrigin = origin.sub( direction.mul( misT ) ).toVar();
+						const misDist = hitDist.add( misT ).toVar();
 						const lightPdf = float( 0.0 ).toVar();
 						If( lightBVHNodeCount.greaterThan( int( 0 ) ), () => {
 
 							lightPdf.assign( calculateLightBVHPdf(
-								int( hitTriIdx ), hitDist, direction, origin,
+								int( hitTriIdx ), misDist, direction, misOrigin,
 								lightBuffer, emissiveVec4Offset, reverseMapVec4Offset, triangleBuffer,
 							) );
 
 						} ).Else( () => {
 
 							lightPdf.assign( calculateEmissiveLightPdf(
-								int( hitTriIdx ), hitDist, direction, origin,
+								int( hitTriIdx ), misDist, direction, misOrigin,
 								triangleBuffer, materialBuffer, emissiveTotalPower,
 							) );
 
@@ -995,7 +1022,7 @@ export function buildShadeKernel( params ) {
 				currentRadiance.xyz.add(
 					regularizePathContribution(
 						emissive.mul( throughput ).mul( emissiveGiScale ).mul( emissiveMISWeight ),
-						float( bounceIndex ), fireflyThreshold, int( frame ),
+						float( bounceIndex ), fireflyThreshold, int( accumFrame ),
 					),
 				),
 				currentRadiance.w
@@ -1047,32 +1074,24 @@ export function buildShadeKernel( params ) {
 			material.clearcoat, material.emissive, material.subsurface,
 		) ).toVar();
 
-		// STBN keyed on (GLOBAL pixel, bounceIndex, frame). pixelIndex is the LOCAL path slot; the global pixel
-		// = chunkRowBase·W + localSlot, so the blue-noise pattern stays spatially aligned across row-band chunks
-		// (and matches Generate's per-pixel RNG seed). chunkRowBase is 0 in the single-chunk case.
-		const _resX = int( resolution.x ).toVar();
-		const _globalPixel = int( pixelIndex ).add( chunkRowBase.mul( _resX ) );
-		const _pixelCoord = vec2(
-			float( _globalPixel.mod( _resX ) ).add( 0.5 ),
-			float( _globalPixel.div( _resX ) ).add( 0.5 ),
-		);
 		const xi = getRandomSample( _pixelCoord, int( 0 ), bounceIndex, rngState, int( - 1 ), resolution, frame ).toVar();
+		const lobeXi = getRandomSample1D( _pixelCoord, int( 0 ), dimBase.add( int( 2 ) ), rngState, resolution, frame ).toVar();
 		const emptyWeights = BRDFWeights( {
 			specular: float( 0.0 ), diffuse: float( 0.0 ), sheen: float( 0.0 ),
 			clearcoat: float( 0.0 ), transmission: float( 0.0 ), iridescence: float( 0.0 ),
 		} );
-		// unused (materialCacheCached=false), but must match the 11-field struct shape to construct
+
+		// Unused (weightsComputed / materialCacheCached are false) but must satisfy the signature.
 		const emptyCache = MaterialCache( {
-			F0: vec3( 0.04 ), NoV: float( 1.0 ),
-			diffuseColor: vec3( 0.0 ), isPurelyDiffuse: false,
-			alpha: float( 0.0 ), k: float( 0.0 ), alpha2: float( 0.0 ),
-			invRoughness: float( 0.5 ), metalFactor: float( 0.5 ),
+			invRoughness: float( 0.0 ), metalFactor: float( 0.5 ),
 			iorFactor: float( 0.67 ), maxSheenColor: float( 0.0 ),
 		} );
 
 		const brdfDir = vec3( 0.0 ).toVar();
 		const brdfValue = vec3( 0.0 ).toVar();
 		const brdfPdf = float( 0.0 ).toVar();
+		const brdfIsTransmission = tslBool( false ).toVar();
+		const brdfColorWeight = vec3( 1.0 ).toVar();
 
 		If( material.clearcoat.greaterThan( 0.0 ), () => {
 
@@ -1084,6 +1103,7 @@ export function buildShadeKernel( params ) {
 			} );
 			const ccResult = ClearcoatResult.wrap( sampleClearcoat(
 				ccRay, ccHit, material, xi, rngState,
+				_pixelCoord, resolution, frame, dimBase,
 			) );
 			brdfDir.assign( ccResult.L );
 			brdfValue.assign( ccResult.brdf );
@@ -1092,7 +1112,8 @@ export function buildShadeKernel( params ) {
 		} ).Else( () => {
 
 			const bs = DirectionSample.wrap( generateSampledDirection(
-				V, N, material, xi, rngState,
+				V, N, material, xi, lobeXi, rngState,
+				_pixelCoord, resolution, frame, dimBase,
 				mc,
 				false, emptyWeights,
 				false, emptyCache,
@@ -1100,6 +1121,8 @@ export function buildShadeKernel( params ) {
 			brdfDir.assign( bs.direction );
 			brdfValue.assign( bs.value );
 			brdfPdf.assign( bs.pdf );
+			brdfIsTransmission.assign( bs.isTransmission );
+			brdfColorWeight.assign( bs.colorWeight );
 
 		} );
 
@@ -1107,6 +1130,7 @@ export function buildShadeKernel( params ) {
 			hitPoint, N, material, V,
 			brdfDir, brdfPdf, brdfValue,
 			bounceIndex, rngState,
+			_pixelCoord, resolution, frame, dimBase,
 			directionalLightsBuffer, numDirectionalLights,
 			areaLightsBuffer, numAreaLights,
 			pointLightsBuffer, numPointLights,
@@ -1127,7 +1151,7 @@ export function buildShadeKernel( params ) {
 			currentRadiance.xyz.add(
 				regularizePathContribution(
 					throughput.mul( directLight ).mul( giScale ),
-					float( bounceIndex ), fireflyThreshold, int( frame ),
+					float( bounceIndex ), fireflyThreshold, int( accumFrame ),
 				),
 			),
 			currentRadiance.w
@@ -1156,18 +1180,16 @@ export function buildShadeKernel( params ) {
 						const emissiveSample = EmissiveSample.wrap( sampleLightBVHTriangle(
 							hitPoint, N,
 							rngState,
+							_pixelCoord, resolution, frame, dimBase,
 							lightBuffer,
 							lightBuffer,
 							emissiveVec4Offset,
 							triangleBuffer,
 						) );
 
-						// skip rough diffuse surfaces on secondary bounces
-						const skip = bounceIndex.greaterThan( int( 1 ) )
-							.and( material.roughness.greaterThan( 0.9 ) )
-							.and( material.metalness.lessThan( 0.1 ) );
-
-						If( skip.not().and( emissiveSample.valid ).and( emissiveSample.pdf.greaterThan( 0.0 ) ), () => {
+						// No rough-diffuse secondary-bounce skip here: dropping NEE while the emissive-hit
+						// MIS still down-weights BSDF hits deletes emitter energy from deep GI.
+						If( emissiveSample.valid.and( emissiveSample.pdf.greaterThan( 0.0 ) ), () => {
 
 							const NoL = max( float( 0.0 ), dot( N, emissiveSample.direction ) );
 
@@ -1199,7 +1221,7 @@ export function buildShadeKernel( params ) {
 										currentRadiance.xyz.add(
 											regularizePathContribution(
 												emissiveLight.mul( throughput ).mul( giScale ),
-												float( bounceIndex ), fireflyThreshold, int( frame ),
+												float( bounceIndex ), fireflyThreshold, int( accumFrame ),
 											),
 										),
 										currentRadiance.w,
@@ -1216,6 +1238,7 @@ export function buildShadeKernel( params ) {
 						const emissiveLight = calculateEmissiveTriangleContribution(
 							hitPoint, N, V, material,
 							bounceIndex, rngState,
+							_pixelCoord, resolution, frame, dimBase,
 							emissiveBoost,
 							lightBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 							triangleBuffer,
@@ -1227,7 +1250,7 @@ export function buildShadeKernel( params ) {
 							currentRadiance.xyz.add(
 								regularizePathContribution(
 									emissiveLight.mul( throughput ).mul( giScale ),
-									float( bounceIndex ), fireflyThreshold, int( frame ),
+									float( bounceIndex ), fireflyThreshold, int( accumFrame ),
 								),
 							),
 							currentRadiance.w,
@@ -1244,17 +1267,26 @@ export function buildShadeKernel( params ) {
 		// per-term (env / emissive-hit / direct-light / emissive-NEE), matching the megakernel which never
 		// re-suppresses the running radiance.
 
-		const samplingInfo = ImportanceSamplingInfo.wrap( getImportanceSamplingInfo(
-			material, bounceIndex, mc,
-		) ).toVar();
-
 		const indirectResult = IndirectLightingResult.wrap( calculateIndirectLighting(
-			V, N, material,
+			N, material,
 			brdfDir, brdfPdf, brdfValue,
-			rngState, samplingInfo,
+			brdfIsTransmission, brdfColorWeight,
+			rngState,
+			_pixelCoord, resolution, frame, dimBase,
 		) ).toVar();
 
 		const bounceDir = indirectResult.direction.toVar();
+
+		// Shading-normal leak guard: a normal-mapped lobe can sample below the geometric surface;
+		// tracing that ray tunnels through single-sided shells onto whatever sits behind them.
+		const NgeoFF = select( dot( hitNormal, V ).lessThan( 0.0 ), hitNormal.negate(), hitNormal );
+		If( brdfIsTransmission.not().and( dot( bounceDir, NgeoFF ).lessThanEqual( 0.0 ) ), () => {
+
+			commitDeferredAux( N );
+			terminatePath();
+			Return();
+
+		} );
 		// combinedPdf is stored as next bounce's prevBouncePdf for NEE↔implicit-env MIS
 		const bouncePdf = max( indirectResult.combinedPdf, 0.001 ).toVar();
 		throughput.mulAssign( indirectResult.throughput );
@@ -1265,7 +1297,8 @@ export function buildShadeKernel( params ) {
 		// terminate. Subsumes the old compensated low-throughput kill (#12). Unbiased; just terminates smarter.
 		const rrSurvival = handleRussianRoulette(
 			bounceIndex, throughput, mc, bounceDir, rngState,
-			enableEnvironmentLight, useEnvMapIS,
+			_pixelCoord, resolution, frame, dimBase,
+			enableEnvironmentLight,
 		).toVar();
 		If( rrSurvival.lessThanEqual( 0.0 ), () => {
 

package/src/TSL/Struct.js

@@ -151,6 +151,11 @@ export const DirectionSample = struct( {
 	direction: 'vec3',
 	value: 'vec3',
 	pdf: 'float',
+	// Refraction went below the surface, so `value` (a reflection-only BRDF eval) is not usable
+	// and the consumer must take the transmission throughput path instead.
+	isTransmission: 'bool',
+	// Spectral tint from the transmission sampler; vec3(1) for every reflection lobe.
+	colorWeight: 'vec3',
 } );
 
 export const BRDFWeights = struct( {
@@ -162,12 +167,6 @@ export const BRDFWeights = struct( {
 	iridescence: 'float',
 } );
 
-export const ImportanceSamplingInfo = struct( {
-	diffuseImportance: 'float',
-	specularImportance: 'float',
-	transmissionImportance: 'float',
-	clearcoatImportance: 'float',
-} );
 
 // Anisotropy tangent frame in world space (rotated ONB). Shared by the sampler and
 // the eval/PDF so both derive the identical frame — see anisoTangentFrame().
@@ -234,45 +233,14 @@ export const UVCache = struct( {
 // Fields are split into two groups:
 //   1. BRDF evaluation: F0, NoV, diffuseColor, isPurelyDiffuse, alpha, k, alpha2
 //   2. BRDF weight calc: invRoughness, metalFactor, iorFactor, maxSheenColor
+// Shared inputs to calculateBRDFWeights, which is the only reader.
 export const MaterialCache = struct( {
-	F0: 'vec3', // Base reflectance
-	NoV: 'float', // Normal dot View
-	diffuseColor: 'vec3', // Precomputed diffuse color (only for isPurelyDiffuse fast path)
-	isPurelyDiffuse: 'bool', // Optimized path flag
-	alpha: 'float', // roughness squared
-	k: 'float', // Geometry term constant
-	alpha2: 'float', // roughness to the fourth power
-	// BRDF weight calculation: precomputed shared values
 	invRoughness: 'float', // 1.0 - roughness
 	metalFactor: 'float', // 0.5 + 0.5 * metalness
 	iorFactor: 'float', // min(2.0 / ior, 1.0)
 	maxSheenColor: 'float', // max component of sheen color
 } );
 
-export const SamplingStrategyWeights = struct( {
-	envWeight: 'float',
-	specularWeight: 'float',
-	diffuseWeight: 'float',
-	transmissionWeight: 'float',
-	clearcoatWeight: 'float',
-	totalWeight: 'float',
-
-	useEnv: 'bool',
-	useSpecular: 'bool',
-	useDiffuse: 'bool',
-	useTransmission: 'bool',
-	useClearcoat: 'bool',
-} );
-
-// IMPROVEMENT: Dynamic MIS strategy based on material properties
-export const MISStrategy = struct( {
-	brdfWeight: 'float',
-	lightWeight: 'float',
-	envWeight: 'float',
-	useBRDFSampling: 'bool',
-	useLightSampling: 'bool',
-	useEnvSampling: 'bool',
-} );
 
 // General rendering state (used across all rendering paths)
 export const RenderState = struct( {

package/src/TSL/Subsurface.js

@@ -9,7 +9,7 @@
 import {
 	Fn,
 	float,
-	vec2,
+	int,
 	vec3,
 	If,
 	select,
@@ -29,7 +29,7 @@ import {
 
 import { struct } from './patches.js';
 import { TWO_PI, EPSILON, constructTBN } from './Common.js';
-import { RandomValue } from './Random.js';
+import { getRandomSample1D, getRandomSample2D } from './Random.js';
 import { iorToFresnel0, fresnelSchlickFloat } from './Fresnel.js';
 import { ImportanceSampleGGX } from './MaterialSampling.js';
 
@@ -95,13 +95,16 @@ export const sampleHenyeyGreenstein = Fn( ( [ wi, g, xi ] ) => {
 // Per-channel sigma_t can't be represented by one scalar distance. Pick a channel
 // ∝ throughput, sample t against it, and weight by the balance-heuristic combined pdf
 // p̄ = Σ pmf_c·p_c — the shared scalar p̄ is what suppresses color fireflies.
-export const sampleChromaticCollision = Fn( ( [ sigmaT, sigmaS, beta, surfaceDist, rngState ] ) => {
+export const sampleChromaticCollision = Fn( ( [
+	sigmaT, sigmaS, beta, surfaceDist, rngState,
+	pixelCoord, resolution, frame, dimBase,
+] ) => {
 
 	const w = max( beta, vec3( 1e-4 ) ); // floor so no channel goes unsampled
 	const pmf = w.div( w.x.add( w.y ).add( w.z ) ).toVar();
 
 	// .toVar() pins the single RNG draw (else it re-executes per comparison → state drift).
-	const u = RandomValue( rngState ).toVar();
+	const u = getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 10 ) ), rngState, resolution, frame ).toVar();
 	const cSigmaT = float( 0.0 ).toVar();
 	If( u.lessThan( pmf.x ), () => {
 
@@ -117,7 +120,7 @@ export const sampleChromaticCollision = Fn( ( [ sigmaT, sigmaS, beta, surfaceDis
 
 	} );
 
-	const xi = RandomValue( rngState ).toVar();
+	const xi = getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 9 ) ), rngState, resolution, frame ).toVar();
 	const t = log( max( float( 1.0 ).sub( xi ), 1e-6 ) ).negate().div( max( cSigmaT, 1e-6 ) ).toVar();
 
 	const didScatter = t.lessThan( surfaceDist ).toVar();
@@ -167,7 +170,9 @@ export const subsurfaceCoefficients = Fn( ( [ subsurfaceColor, subsurfaceRadius,
 // Dielectric interface driven by material.ior: reflect (Fresnel/TIR) or refract across
 // the boundary. No color tint — the scattering color lives in sigma_s.
 export const handleSubsurfaceEntry = Fn( ( [
-	rayDir, normal, material, entering, rngState, currentMediumIOR, previousMediumIOR,
+	rayDir, normal, material, entering, rngState,
+	pixelCoord, resolution, frame, dimBase,
+	currentMediumIOR, previousMediumIOR,
 ] ) => {
 
 	const result = SubsurfaceEntryResult( {
@@ -188,13 +193,13 @@ export const handleSubsurfaceEntry = Fn( ( [
 	const Fr = select( tir, float( 1.0 ), fresnelSchlickFloat( cosThetaI, F0 ) ).toVar();
 	const reflectProb = clamp( Fr, 0.02, 0.98 ).toVar();
 
-	const doReflect = tir.or( RandomValue( rngState ).lessThan( reflectProb ) ).toVar();
+	const doReflect = tir.or( getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 11 ) ), rngState, resolution, frame ).lessThan( reflectProb ) ).toVar();
 	result.didReflect.assign( doReflect );
 
 	If( doReflect, () => {
 
 		// GGX-sampled reflection: a perfect mirror here makes SSS surfaces read as polished ceramic.
-		const xiR = vec2( RandomValue( rngState ), RandomValue( rngState ) );
+		const xiR = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 5 ) ), rngState, resolution, frame );
 		const H = ImportanceSampleGGX( { N, roughness: material.roughness, Xi: xiR } );
 		const reflDir = reflect( rayDir, H ).toVar();
 		If( dot( reflDir, N ).lessThanEqual( 0.0 ), () => {

package/src/index.js

@@ -54,6 +54,11 @@ export { VRAMTracker, bufferBytes, textureBytes } from './Processor/VRAMTracker.
 export { RenderPipeline } from './Pipeline/RenderPipeline.js';
 export { RenderStage, StageExecutionMode } from './Pipeline/RenderStage.js';
 export { PipelineContext } from './Pipeline/PipelineContext.js';
+export {
+	setBindingAudit,
+	getBindingAuditFindings,
+	clearBindingAuditFindings,
+} from './Pipeline/BindingAudit.js';
 
 // Animation (for advanced consumers)
 export { AnimationManager } from './managers/AnimationManager.js';

package/src/managers/EnvironmentManager.js

@@ -274,7 +274,6 @@ export class EnvironmentManager {
 			this._updateCDFTexture();
 			this.uniforms.set( 'envTotalSum', 0.0 );
 			this.uniforms.set( 'envCompensationDelta', 0.0 );
-			this.uniforms.set( 'useEnvMapIS', 0 );
 			return;
 
 		}
@@ -289,7 +288,6 @@ export class EnvironmentManager {
 				this._updateCDFTexture();
 				this.uniforms.set( 'envTotalSum', 0.0 );
 				this.uniforms.set( 'envCompensationDelta', 0.0 );
-				this.uniforms.set( 'useEnvMapIS', 0 );
 				return;
 
 			}
@@ -309,7 +307,6 @@ export class EnvironmentManager {
 			this._updateCDFTexture();
 			this.uniforms.set( 'envTotalSum', this.equirectHdrInfo.totalSum );
 			this.uniforms.set( 'envCompensationDelta', this.equirectHdrInfo.compensationDelta );
-			this.uniforms.set( 'useEnvMapIS', 1 );
 
 			const { width, height } = this.equirectHdrInfo;
 			if ( width && height ) {
@@ -326,7 +323,6 @@ export class EnvironmentManager {
 		} catch ( error ) {
 
 			log.error( 'CDF build failed:', error );
-			this.uniforms.set( 'useEnvMapIS', 0 );
 			this.uniforms.set( 'envTotalSum', 0.0 );
 			this.uniforms.set( 'envCompensationDelta', 0.0 );
 
@@ -387,7 +383,6 @@ export class EnvironmentManager {
 			this._updateCDFTexture();
 			this.uniforms.set( 'envTotalSum', 0.0 );
 			this.uniforms.set( 'envCompensationDelta', 0.0 );
-			this.uniforms.set( 'useEnvMapIS', 0 );
 
 		}
 

package/src/managers/UniformManager.js

@@ -160,6 +160,10 @@ export class UniformManager {
 
 		// Frame and sampling
 		u( 'frame', 0, 'uint' );
+		// Sampler seed axis, separate from the accumulation index: `frame` is zeroed by every
+		// reset, and a camera move resets each frame of a drag, so the RNG redrew the identical
+		// sequence and temporal denoising had nothing to average.
+		u( 'seedFrame', 0, 'uint' );
 		u( 'maxBounces', DEFAULT_STATE.bounces, 'int' );
 		u( 'maxSamples', DEFAULT_STATE.maxSamples, 'int' );
 		u( 'transmissiveBounces', DEFAULT_STATE.transmissiveBounces, 'int' );
@@ -198,7 +202,6 @@ export class UniformManager {
 		ub( 'transparentBackground', DEFAULT_STATE.transparentBackground );
 		ub( 'enableEnvironment', DEFAULT_STATE.enableEnvironment );
 		u( 'environmentMatrix', new Matrix4(), 'mat4' );
-		ub( 'useEnvMapIS', DEFAULT_STATE.useImportanceSampledEnvironment );
 		u( 'envTotalSum', 0.0, 'float' );
 		u( 'envCompensationDelta', 0.0, 'float' );
 		u( 'envResolution', new Vector2( 1, 1 ), 'vec2' );