rayzee 7.20.3 → 7.22.0

package/src/TSL/Random.js

@@ -132,7 +132,7 @@ export const RandomPointInCircle = ( rngState ) => {
 //       +6  subsurface HG scatter dir    (ShadeKernel)
 //       +7  ground-catcher cosine BSDF   (ShadeKernel)
 //       +8  indirect-strategy direction  (LightsIndirect)
-//   1D  +0  {lights,BRDF} strategy       (LightsSampling)
+//   1D  +0  (free — was the {lights,BRDF} stochastic strategy pick)
 //       +1  emissive-triangle pick       (EmissiveSampling / LightBVHSampling)
 //       +2  BSDF lobe selection          (ShadeKernel)
 //       +3  Russian roulette             (PathTracerCore)
@@ -155,7 +155,7 @@ export const RandomPointInCircle = ( rngState ) => {
 // Draws whose COUNT varies per pixel cannot sit in a per-bounce block without overflowing into
 // the next bounce's dimensions, so they live above AUX_BASE:
 //   AUX_BASE +  0..63   env-backdrop blur taps      (ShadeKernel)
-//   AUX_BASE + 64..127  light reservoir, 4 types×16 (LightsSampling)
+//   AUX_BASE + 64..    light reservoir, one dimension per scene light (LightsSampling)
 export const SAMPLER_DIMS_PER_BOUNCE = 32;
 export const SAMPLER_DIM_AUX_BASE = 4096;
 

package/src/TSL/ShadeKernel.js

@@ -53,6 +53,7 @@ import {
 	readMediumStack, writeMediumStack, readMediumSigmaA, writeMediumSigmaA,
 	readPathBounces, readSssSteps, readSSSMedium, writeSSSMedium,
 	readTransparentCount,
+	readMisRayT,
 	readHitDistance, readHitBarycentrics, readHitNormal,
 	readHitMaterialIndex, readHitTriangleIndex,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
@@ -79,7 +80,7 @@ export function buildShadeKernel( params ) {
 		counters,
 		activeIndicesRO,
 		envTexture, environmentIntensity, envMatrix,
-		enableEnvironmentLight, useEnvMapIS,
+		enableEnvironmentLight,
 		groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight, groundProjectionLevel,
 		enableGroundCatcher, groundCatcherHeight,
 		envTotalSum, envCompensationDelta, envResolution,
@@ -94,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,
@@ -405,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 ), () => {
@@ -440,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
@@ -927,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,
@@ -980,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,
 							) );
 
@@ -1008,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
@@ -1137,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
@@ -1173,12 +1187,9 @@ export function buildShadeKernel( params ) {
 							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 ) );
 
@@ -1210,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,
@@ -1239,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,
@@ -1265,6 +1276,17 @@ export function buildShadeKernel( params ) {
 		) ).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 );
@@ -1276,7 +1298,7 @@ export function buildShadeKernel( params ) {
 		const rrSurvival = handleRussianRoulette(
 			bounceIndex, throughput, mc, bounceDir, rngState,
 			_pixelCoord, resolution, frame, dimBase,
-			enableEnvironmentLight, useEnvMapIS,
+			enableEnvironmentLight,
 		).toVar();
 		If( rrSurvival.lessThanEqual( 0.0 ), () => {
 

package/src/TSL/SortGlobalKernels.js

@@ -111,20 +111,65 @@ export function buildGlobalPrefixKernel( { sortGlobalHistogram, bins = SORT_GLOB
 
 }
 
-// Pass 4 — scatter: atomicAdd on the prefix-summed histogram gives each ray its global slot
-// within its material's contiguous region.
+// Pass 4 — scatter: each ray lands in a unique slot inside its material's contiguous region.
+//
+// Global atomics are reduced from O(rays) to O(workgroups × bins touched) by reserving one block
+// per bin per workgroup, the same aggregation Pass 2 already applies to the histogram. `local`
+// changes meaning across the barriers: first a per-workgroup count, then the workgroup's global
+// base cursor for that bin, which the lanes then bump to claim their own slot.
+//
+// Slot order WITHIN a bin changes versus the per-ray version, but it was never deterministic —
+// the old path raced on the same global atomicAdd. The output is still an exact permutation of the
+// entering set, and Shade reads each ray independently.
 export function buildGlobalScatterKernel( { hitBufferRO, activeIndicesReadRO, sortedIndicesRW, sortGlobalHistogram, counters, bins = SORT_GLOBAL_MAX_BINS } ) {
 
 	return Fn( () => {
 
 		const tid = instanceIndex;
+		const lid = localId.x;
+		const local = workgroupAtomicArray( 'uint', bins );
+
+		If( lid.lessThan( uint( bins ) ), () => {
+
+			atomicStore( local.element( lid ), uint( 0 ) );
+
+		} );
+		workgroupBarrier();
+
+		// Read once and reuse: recomputing the bin after the barriers would re-fetch the hit buffer.
 		const entering = atomicLoad( counters.element( uint( COUNTER.ENTERING_COUNT ) ) );
-		If( tid.lessThan( entering ), () => {
+		const inRange = tid.lessThan( entering );
+		const rayID = uint( 0 ).toVar();
+		const bin = uint( 0 ).toVar();
 
-			const rayID = activeIndicesReadRO.element( tid );
-			const bin = uint( readHitMaterialIndex( hitBufferRO, rayID ) ).clamp( uint( 0 ), uint( bins - 1 ) );
-			const pos = atomicAdd( sortGlobalHistogram.element( bin ), uint( 1 ) );
-			sortedIndicesRW.element( pos ).assign( rayID );
+		If( inRange, () => {
+
+			rayID.assign( activeIndicesReadRO.element( tid ) );
+			bin.assign( uint( readHitMaterialIndex( hitBufferRO, rayID ) ).clamp( uint( 0 ), uint( bins - 1 ) ) );
+			atomicAdd( local.element( bin ), uint( 1 ) );
+
+		} );
+		workgroupBarrier();
+
+		// One global atomic per bin per workgroup reserves that block; the returned base replaces the
+		// count in place. Bins this workgroup never touched are skipped — no lane will read them.
+		If( lid.lessThan( uint( bins ) ), () => {
+
+			const slot = local.element( lid );
+			const c = atomicLoad( slot );
+			If( c.greaterThan( uint( 0 ) ), () => {
+
+				atomicStore( slot, atomicAdd( sortGlobalHistogram.element( lid ), c ) );
+
+			} );
+
+		} );
+		workgroupBarrier();
+
+		If( inRange, () => {
+
+			// Workgroup-local atomic: gives this lane its rank inside the block reserved above.
+			sortedIndicesRW.element( atomicAdd( local.element( bin ), uint( 1 ) ) ).assign( rayID );
 
 		} );
 

package/src/TSL/Struct.js

@@ -242,16 +242,6 @@ export const MaterialCache = struct( {
 } );
 
 
-// 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( {
 	traversals: 'int', // Remaining general bounces

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/DenoisingManager.js

@@ -225,6 +225,19 @@ export class DenoisingManager extends EventDispatcher {
 	 * @param {string} strategy   - 'none' | 'asvgf' | 'edgeaware'
 	 * @param {string} [asvgfPreset] - ASVGF quality preset when strategy is 'asvgf'
 	 */
+	/**
+	 * Active real-time denoiser, derived from stage state so it can't drift from
+	 * setDenoiserStrategy / setASVGFEnabled.
+	 * @returns {'asvgf'|'edgeaware'|'none'}
+	 */
+	get denoiserStrategy() {
+
+		if ( this._stages.asvgf?.enabled ) return 'asvgf';
+		if ( this._stages.edgeFilter?.enabled ) return 'edgeaware';
+		return 'none';
+
+	}
+
 	setDenoiserStrategy( strategy, asvgfPreset ) {
 
 		const s = this._stages;

package/src/managers/EnvironmentManager.js

@@ -8,7 +8,7 @@
  */
 
 import {
-	RGBAFormat, RedFormat, FloatType, Vector2, Vector3, Color, Matrix4, DataTexture,
+	RGBAFormat, RedFormat, FloatType, LinearFilter, Vector2, Vector3, Color, Matrix4, DataTexture,
 } from 'three';
 import { EquirectHDRInfo } from '../Processor/EquirectHDRInfo.js';
 import { ProceduralSky } from '../Processor/ProceduralSky.js';
@@ -36,9 +36,12 @@ export class EnvironmentManager {
 		this.proceduralSkyRenderer = null;
 		this.simpleSkyRenderer = null;
 
-		// Environment texture — 1×1 black placeholder for shader compilation
+		// Environment texture — 1×1 black placeholder for shader compilation. Filters must be
+		// Linear: DataTexture defaults to Nearest, which is unfilterable, and WGSLNodeBuilder then
+		// omits the `_sampler` binding that sampleEnvironment() takes as an explicit wgslFn arg.
 		this._envPlaceholder = new DataTexture(
-			new Float32Array( [ 0, 0, 0, 1 ] ), 1, 1, RGBAFormat, FloatType
+			new Float32Array( [ 0, 0, 0, 1 ] ), 1, 1, RGBAFormat, FloatType,
+			undefined, undefined, undefined, LinearFilter, LinearFilter
 		);
 		this._envPlaceholder.needsUpdate = true;
 		this.environmentTexture = this._envPlaceholder;
@@ -274,7 +277,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 +291,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 +310,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 +326,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 +386,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

@@ -6,7 +6,7 @@
  */
 
 import { uniform, uniformArray } from 'three/tsl';
-import { Vector2, Matrix4, Vector3, Color } from 'three';
+import { Vector2, Matrix4, Vector3, Color, MathUtils } from 'three';
 import { samplingTechniqueUniform } from '../TSL/Random.js';
 import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.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' );
@@ -238,6 +241,13 @@ export class UniformManager {
 		u( 'cameraViewMatrix', new Matrix4(), 'mat4' );
 		u( 'cameraProjectionMatrix', new Matrix4(), 'mat4' );
 
+		// Projection: 0 = pinhole, 1 = equirectangular panorama. Ranges are radians (UI carries degrees).
+		const radRange = ( [ min, max ] ) => new Vector2( min, max ).multiplyScalar( MathUtils.DEG2RAD );
+		u( 'cameraProjection', DEFAULT_STATE.cameraProjection === 'equirectangular' ? 1 : 0, 'int' );
+		u( 'panoLonRange', radRange( DEFAULT_STATE.panoramaLonRange ), 'vec2' );
+		u( 'panoLatRange', radRange( DEFAULT_STATE.panoramaLatRange ), 'vec2' );
+		ub( 'panoLevelHorizon', DEFAULT_STATE.panoramaLevelHorizon );
+
 		// DOF
 		ub( 'enableDOF', DEFAULT_STATE.enableDOF );
 		u( 'focusDistance', DEFAULT_STATE.focusDistance, 'float' );