rayzee 5.4.3 → 5.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "5.4.3",
+  "version": "5.5.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/Stages/PathTracer.js

@@ -2,9 +2,9 @@ import { storage } from 'three/tsl';
 import { StorageInstancedBufferAttribute } from 'three/webgpu';
 import {
 	NearestFilter, Vector2, Matrix4,
-	TextureLoader, RepeatWrapping, FloatType
+	TextureLoader, RepeatWrapping
 } from 'three';
-import { blueNoiseTextureNode } from '../TSL/Random.js';
+import { stbnScalarTextureNode, stbnVec2TextureNode } from '../TSL/Random.js';
 
 // Pipeline system
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
@@ -26,8 +26,9 @@ import { LightSerializer } from '../Processor/LightSerializer';
 // Constants
 import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.js';
 
-// Blue noise (loaded at runtime from CDN — not inlined to keep bundle small)
-const blueNoiseImage = 'https://assets.rayzee.atulmourya.com/noise/simple_bluenoise.png';
+// STBN atlases - original source: https://github.com/NVIDIA-RTX/STBN/blob/main/Assets/STBN.zip
+const stbnScalarAtlas = 'https://assets.rayzee.atulmourya.com/noise/stbn_scalar_atlas.png';
+const stbnVec2Atlas = 'https://assets.rayzee.atulmourya.com/noise/stbn_vec2_atlas.png';
 
 /**
  * Data layout constants
@@ -190,8 +191,9 @@ export class PathTracer extends RenderStage {
 		this.spotLightsData = null;
 		this.areaLightsData = null;
 
-		// Blue noise
-		this.blueNoiseTexture = null;
+		// STBN noise textures
+		this.stbnScalarTexture = null;
+		this.stbnVec2Texture = null;
 
 		// Packed light buffer — [lightBVH nodes (4 vec4s each) | emissive triangles (2 vec4s each)]
 		// emissiveVec4Offset uniform tracks the vec4-count offset where emissive data starts.
@@ -376,25 +378,38 @@ export class PathTracer extends RenderStage {
 	}
 
 	/**
-	 * Setup blue noise texture
+	 * Load STBN (Spatiotemporal Blue Noise) atlas textures.
+	 * Each atlas is 1024×1024: 8×8 grid of 128×128 tiles, 64 temporal slices.
 	 */
 	setupBlueNoise() {
 
 		const loader = new TextureLoader();
 		loader.setCrossOrigin( 'anonymous' );
-		loader.load( blueNoiseImage, ( texture ) => {
 
-			texture.minFilter = NearestFilter;
-			texture.magFilter = NearestFilter;
-			texture.wrapS = RepeatWrapping;
-			texture.wrapT = RepeatWrapping;
-			texture.type = FloatType;
-			texture.generateMipmaps = false;
+		const configure = ( tex ) => {
 
-			this.blueNoiseTexture = texture;
-			blueNoiseTextureNode.value = texture;
+			tex.minFilter = NearestFilter;
+			tex.magFilter = NearestFilter;
+			tex.wrapS = RepeatWrapping;
+			tex.wrapT = RepeatWrapping;
+			tex.generateMipmaps = false;
+			return tex;
 
-			console.log( `PathTracer: Blue noise loaded ${texture.image.width}x${texture.image.height}` );
+		};
+
+		loader.load( stbnScalarAtlas, ( tex ) => {
+
+			this.stbnScalarTexture = configure( tex );
+			stbnScalarTextureNode.value = tex;
+			console.log( `PathTracer: STBN scalar atlas loaded ${tex.image.width}x${tex.image.height}` );
+
+		} );
+
+		loader.load( stbnVec2Atlas, ( tex ) => {
+
+			this.stbnVec2Texture = configure( tex );
+			stbnVec2TextureNode.value = tex;
+			console.log( `PathTracer: STBN vec2 atlas loaded ${tex.image.width}x${tex.image.height}` );
 
 		} );
 
@@ -1521,9 +1536,9 @@ export class PathTracer extends RenderStage {
 
 	setBlueNoiseTexture( tex ) {
 
-		this.blueNoiseTexture = tex;
-		// Update the shared Random.js texture node so TSL shader graph uses the real texture
-		if ( tex ) blueNoiseTextureNode.value = tex;
+		// Legacy API — sets the scalar STBN atlas texture
+		this.stbnScalarTexture = tex;
+		if ( tex ) stbnScalarTextureNode.value = tex;
 
 	}
 
@@ -1676,7 +1691,8 @@ export class PathTracer extends RenderStage {
 		this.storageTextures?.dispose();
 
 		// Dispose textures
-		this.blueNoiseTexture?.dispose();
+		this.stbnScalarTexture?.dispose();
+		this.stbnVec2Texture?.dispose();
 		this.placeholderTexture?.dispose();
 
 		// Clear data references

package/src/TSL/LightsDirect.js

@@ -28,12 +28,11 @@ import {
 	texture,
 } from 'three/tsl';
 
-import { Ray, ShadowMaterial, HitInfo, DirectionSample, MaterialCache } from './Struct.js';
+import { Ray, ShadowMaterial, HitInfo } from './Struct.js';
 import { PI, TWO_PI, EPSILON, REC709_LUMINANCE_COEFFICIENTS, powerHeuristic, getShadowMaterial, getDatafromStorageBuffer } from './Common.js';
 import { fresnelSchlickFloat } from './Fresnel.js';
 import { iorToFresnel0 } from './Fresnel.js';
 import {
-	DirectionalLight, AreaLight, PointLight, SpotLight,
 	sampleCone, intersectAreaLight,
 } from './LightsCore.js';
 import { calculateBeerLawAbsorption, calculateShadowTransmittance } from './MaterialTransmission.js';

package/src/TSL/MaterialProperties.js

@@ -5,7 +5,7 @@ import {
 	MaterialClassification,
 	MaterialCache,
 	ImportanceSamplingInfo,
-	MaterialSamples,
+
 } from './Struct.js';
 
 import {
@@ -394,22 +394,13 @@ export const getImportanceSamplingInfo = Fn( ( [
 	const tempMaxSheenColor = max( material.sheenColor.r, max( material.sheenColor.g, material.sheenColor.b ) );
 
 	const tempCache = MaterialCache( {
+		F0: dielectricF0( material.ior ),
 		NoV: float( 0.5 ),
+		diffuseColor: material.color.rgb,
 		isPurelyDiffuse: false,
-		isMetallic: mc.isMetallic,
-		hasSpecialFeatures: false,
 		alpha: material.roughness.mul( material.roughness ),
-		alpha2: material.roughness.mul( material.roughness ).mul( material.roughness ).mul( material.roughness ),
 		k: material.roughness.add( 1.0 ).mul( material.roughness.add( 1.0 ) ).div( 8.0 ),
-		F0: dielectricF0( material.ior ),
-		diffuseColor: material.color.rgb,
-		specularColor: material.color.rgb,
-		tsAlbedo: material.color,
-		tsEmissive: material.emissive,
-		tsMetalness: material.metalness,
-		tsRoughness: material.roughness,
-		tsNormal: vec3( 0.0, 1.0, 0.0 ),
-		tsHasTextures: false,
+		alpha2: material.roughness.mul( material.roughness ).mul( material.roughness ).mul( material.roughness ),
 		invRoughness: tempInvRoughness,
 		metalFactor: tempMetalFactor,
 		iorFactor: tempIorFactor,
@@ -500,13 +491,6 @@ export const createMaterialCache = Fn( ( [ N, V, material, samples, mc ] ) => {
 		.and( material.clearcoat.equal( 0.0 ) )
 		.toVar();
 
-	const isMetallic = mc.isMetallic.toVar();
-
-	const hasSpecialFeatures = mc.isTransmissive.or( mc.hasClearcoat )
-		.or( material.sheen.greaterThan( 0.0 ) )
-		.or( material.iridescence.greaterThan( 0.0 ) )
-		.toVar();
-
 	const alpha = samples.roughness.mul( samples.roughness ).toVar();
 	const alpha2 = alpha.mul( alpha ).toVar();
 	const r = samples.roughness.add( 1.0 );
@@ -515,7 +499,6 @@ export const createMaterialCache = Fn( ( [ N, V, material, samples, mc ] ) => {
 	const baseF0 = dielectricF0( material.ior ).mul( material.specularColor );
 	const F0 = mix( baseF0, samples.albedo.rgb, samples.metalness ).mul( material.specularIntensity ).toVar();
 	const diffuseColor = samples.albedo.rgb.mul( float( 1.0 ).sub( samples.metalness ) ).toVar();
-	const specularColor = samples.albedo.rgb.toVar();
 
 	const invRoughness = float( 1.0 ).sub( samples.roughness ).toVar();
 	const metalFactor = float( 0.5 ).add( float( 0.5 ).mul( samples.metalness ) ).toVar();
@@ -523,89 +506,13 @@ export const createMaterialCache = Fn( ( [ N, V, material, samples, mc ] ) => {
 	const maxSheenColor = max( material.sheenColor.r, max( material.sheenColor.g, material.sheenColor.b ) ).toVar();
 
 	return MaterialCache( {
-		NoV,
-		isPurelyDiffuse,
-		isMetallic,
-		hasSpecialFeatures,
-		alpha,
-		alpha2,
-		k,
 		F0,
-		diffuseColor,
-		specularColor,
-		tsAlbedo: samples.albedo,
-		tsEmissive: samples.emissive,
-		tsMetalness: samples.metalness,
-		tsRoughness: samples.roughness,
-		tsNormal: samples.normal,
-		tsHasTextures: samples.hasTextures,
-		invRoughness,
-		metalFactor,
-		iorFactor,
-		maxSheenColor,
-	} );
-
-} );
-
-export const createMaterialCacheLegacy = Fn( ( [ N, V, material ] ) => {
-
-	const NoV = max( dot( N, V ), 0.001 ).toVar();
-
-	const isPurelyDiffuse = material.roughness.greaterThan( 0.98 )
-		.and( material.metalness.lessThan( 0.02 ) )
-		.and( material.transmission.equal( 0.0 ) )
-		.and( material.clearcoat.equal( 0.0 ) )
-		.toVar();
-
-	const isMetallic = material.metalness.greaterThan( 0.7 ).toVar();
-
-	const hasSpecialFeatures = material.transmission.greaterThan( 0.0 )
-		.or( material.clearcoat.greaterThan( 0.0 ) )
-		.or( material.sheen.greaterThan( 0.0 ) )
-		.or( material.iridescence.greaterThan( 0.0 ) )
-		.toVar();
-
-	const alpha = material.roughness.mul( material.roughness ).toVar();
-	const alpha2 = alpha.mul( alpha ).toVar();
-	const r = material.roughness.add( 1.0 );
-	const k = r.mul( r ).div( 8.0 ).toVar();
-
-	const baseF0 = dielectricF0( material.ior ).mul( material.specularColor );
-	const F0 = mix( baseF0, material.color.rgb, material.metalness ).mul( material.specularIntensity ).toVar();
-	const diffuseColor = material.color.rgb.mul( float( 1.0 ).sub( material.metalness ) ).toVar();
-	const specularColor = material.color.rgb.toVar();
-
-	const dummySamples = MaterialSamples( {
-		albedo: material.color,
-		emissive: material.emissive.mul( material.emissiveIntensity ),
-		metalness: material.metalness,
-		roughness: material.roughness,
-		normal: N,
-		hasTextures: false,
-	} );
-
-	const invRoughness = float( 1.0 ).sub( material.roughness ).toVar();
-	const metalFactor = float( 0.5 ).add( float( 0.5 ).mul( material.metalness ) ).toVar();
-	const iorFactor = min( float( 2.0 ).div( material.ior ), 1.0 ).toVar();
-	const maxSheenColor = max( material.sheenColor.r, max( material.sheenColor.g, material.sheenColor.b ) ).toVar();
-
-	return MaterialCache( {
 		NoV,
+		diffuseColor,
 		isPurelyDiffuse,
-		isMetallic,
-		hasSpecialFeatures,
 		alpha,
-		alpha2,
 		k,
-		F0,
-		diffuseColor,
-		specularColor,
-		tsAlbedo: dummySamples.albedo,
-		tsEmissive: dummySamples.emissive,
-		tsMetalness: dummySamples.metalness,
-		tsRoughness: dummySamples.roughness,
-		tsNormal: dummySamples.normal,
-		tsHasTextures: dummySamples.hasTextures,
+		alpha2,
 		invRoughness,
 		metalFactor,
 		iorFactor,
@@ -613,3 +520,4 @@ export const createMaterialCacheLegacy = Fn( ( [ N, V, material ] ) => {
 	} );
 
 } );
+

package/src/TSL/MaterialSampling.js

@@ -1,6 +1,5 @@
 import {
-	Fn, wgslFn, float, vec3, vec2, int, uint,
-	If, max, min, abs, normalize, reflect, refract, dot, pow
+	Fn, wgslFn, float, vec3, If, max, min, abs, normalize, reflect, refract, dot, pow
 } from 'three/tsl';
 
 import {
@@ -8,8 +7,7 @@ import {
 } from './Struct.js';
 
 import {
-	PI, PI_INV, MIN_PDF, EPSILON,
-	classifyMaterial, square,
+	PI, PI_INV, MIN_PDF, classifyMaterial,
 } from './Common.js';
 import { dielectricF0 } from './Fresnel.js';
 
@@ -116,22 +114,13 @@ export const calculateSamplingWeights = Fn( ( [ V, N, material ] ) => {
 
 	// Create temporary cache for calculations
 	const tempCache = MaterialCache( {
+		F0: dielectricF0( material.ior ),
 		NoV: float( 0.5 ),
+		diffuseColor: material.color.rgb,
 		isPurelyDiffuse: false,
-		isMetallic: mc.isMetallic,
-		hasSpecialFeatures: false,
 		alpha: material.roughness.mul( material.roughness ),
-		alpha2: material.roughness.mul( material.roughness ).mul( material.roughness ).mul( material.roughness ),
 		k: material.roughness.add( 1.0 ).mul( material.roughness.add( 1.0 ) ).div( 8.0 ),
-		F0: dielectricF0( material.ior ),
-		diffuseColor: material.color.rgb,
-		specularColor: material.color.rgb,
-		tsAlbedo: material.color, // placeholder
-		tsEmissive: vec3( 0.0 ),
-		tsMetalness: float( 0.0 ),
-		tsRoughness: material.roughness,
-		tsNormal: vec3( 0.0, 1.0, 0.0 ),
-		tsHasTextures: false,
+		alpha2: material.roughness.mul( material.roughness ).mul( material.roughness ).mul( material.roughness ),
 		invRoughness: tempInvRoughness,
 		metalFactor: tempMetalFactor,
 		iorFactor: tempIorFactor,

package/src/TSL/PathTracerCore.js

@@ -184,19 +184,10 @@ export const generateSampledDirection = Fn( ( [
 				F0: dielectricF0( material.ior ),
 				NoV: float( 1.0 ),
 				diffuseColor: vec3( 0.0 ),
-				specularColor: vec3( 0.0 ),
-				isMetallic: false,
 				isPurelyDiffuse: false,
-				hasSpecialFeatures: false,
 				alpha: float( 0.0 ),
 				k: float( 0.0 ),
 				alpha2: float( 0.0 ),
-				tsAlbedo: vec4( 0.0 ),
-				tsEmissive: vec3( 0.0 ),
-				tsMetalness: float( 0.0 ),
-				tsRoughness: float( 0.0 ),
-				tsNormal: vec3( 0.0 ),
-				tsHasTextures: false,
 				invRoughness: float( 1.0 ).sub( material.roughness ),
 				metalFactor: float( 0.5 ).add( float( 0.5 ).mul( material.metalness ) ),
 				iorFactor: min( float( 2.0 ).div( material.ior ), 1.0 ),
@@ -655,12 +646,8 @@ export const Trace = Fn( ( [
 	// Cached material cache
 	const psCachedMaterialCache = MaterialCache( {
 		F0: vec3( 0.04 ), NoV: float( 1.0 ),
-		diffuseColor: vec3( 0.0 ), specularColor: vec3( 0.0 ),
-		isMetallic: false, isPurelyDiffuse: false, hasSpecialFeatures: false,
+		diffuseColor: vec3( 0.0 ), isPurelyDiffuse: false,
 		alpha: float( 0.0 ), k: float( 0.0 ), alpha2: float( 0.0 ),
-		tsAlbedo: vec4( 0.0 ), tsEmissive: vec3( 0.0 ),
-		tsMetalness: float( 0.0 ), tsRoughness: float( 0.0 ),
-		tsNormal: vec3( 0.0 ), tsHasTextures: false,
 		invRoughness: float( 1.0 ), metalFactor: float( 0.5 ),
 		iorFactor: float( 1.0 ), maxSheenColor: float( 0.0 ),
 	} ).toVar();

package/src/TSL/Random.js

@@ -1,6 +1,6 @@
 // Three.js Transpiler r182
 
-import { uniform, texture, textureSize, float, If, Fn, wgslFn, uint, TWO_PI, cos, sin, vec2, sqrt, fract, mod, floor, ivec2, select, Switch, max, int, vec4, mix } from 'three/tsl';
+import { uniform, texture, float, If, wgslFn, uint, TWO_PI, cos, sin, vec2, sqrt, fract, mod, ivec2, select, int, vec4, mix } from 'three/tsl';
 import { DataTexture, FloatType } from 'three';
 
 // -----------------------------------------------------------------------------
@@ -12,20 +12,30 @@ const samplingTechnique = samplingTechniqueUniform;
 
 // 0: PCG, 1: Halton, 2: Sobol, 3: Blue Noise
 
-// 1x1 placeholder — real texture assigned later via blueNoiseTextureNode.value = ...
+// 1x1 placeholder — real texture assigned later via .value = ...
 const _placeholderData = new Float32Array( [ 0.5, 0.5, 0.5, 1.0 ] );
-const _placeholderTex = new DataTexture( _placeholderData, 1, 1 );
-_placeholderTex.type = FloatType;
-_placeholderTex.needsUpdate = true;
 
-export const blueNoiseTextureNode = texture( _placeholderTex );
-blueNoiseTextureNode.setUpdateMatrix( false ); // No UV transform — we provide our own integer coords
-const blueNoiseTextureSize = vec2( textureSize( blueNoiseTextureNode ) );
+const _placeholderScalar = new DataTexture( _placeholderData, 1, 1 );
+_placeholderScalar.type = FloatType;
+_placeholderScalar.needsUpdate = true;
 
-// Golden ratio constants for dimension decorrelation
+const _placeholderVec2 = new DataTexture( new Float32Array( [ 0.5, 0.5, 0.0, 1.0 ] ), 1, 1 );
+_placeholderVec2.type = FloatType;
+_placeholderVec2.needsUpdate = true;
 
-const INV_PHI = float( 0.61803398875 );
-const INV_PHI2 = float( 0.38196601125 );
+// STBN (Spatiotemporal Blue Noise) atlas textures — Heitz 2019
+// Each atlas: 1024×1024, 8×8 grid of 128×128 tiles, 64 temporal slices
+// Scalar atlas: single-channel (R) — optimal for 1D decisions (RR, lobe selection)
+// Vec2 atlas: two-channel (R,G) — decorrelated 2D pairs (direction sampling Xi)
+export const stbnScalarTextureNode = texture( _placeholderScalar );
+stbnScalarTextureNode.setUpdateMatrix( false );
+
+export const stbnVec2TextureNode = texture( _placeholderVec2 );
+stbnVec2TextureNode.setUpdateMatrix( false );
+
+// R2 quasi-random sequence constants (Roberts 2018) — optimal 2D additive offsets
+const R2_A1 = float( 0.7548776662466927 );
+const R2_A2 = float( 0.5698402909980532 );
 
 // Sobol sequence direction vectors using function lookup for compatibility
 
@@ -160,126 +170,49 @@ export const RandomPointInCircle = ( rngState ) => {
 };
 
 // -----------------------------------------------------------------------------
-// Blue noise sampling with proper multi-dimensional support
+// STBN atlas sampling — proper spatiotemporal blue noise
 // -----------------------------------------------------------------------------
-// Cranley-Patterson rotation for decorrelation
-
-export const cranleyPatterson2D = /*@__PURE__*/ wgslFn( `
-	fn cranleyPatterson2D( p: vec2f, offset: vec2f ) -> vec2f {
-
-		return fract( p + offset );
-
-	}
-` );
-
-// Improved blue noise sampling that properly uses all parameters
-
-export const sampleBlueNoiseRaw = /*@__PURE__*/ Fn( ( [ pixelCoords, sampleIndex, bounceIndex, frame ] ) => {
-
-	// Create dimension-specific offsets using golden ratio
-
-	const dimensionOffset = vec2( fract( float( sampleIndex ).mul( INV_PHI ) ), fract( float( bounceIndex ).mul( INV_PHI2 ) ) );
-
-	// Frame-based decorrelation with better hash
-
-	const frameHash = wang_hash( { seed: pcgHash( { state: uint( frame ) } ) } );
-	const frameOffset = vec2( float( frameHash.bitAnd( 0xFFFF ) ).div( 65536.0 ), float( frameHash.shiftRight( 16 ).bitAnd( 0xFFFF ) ).div( 65536.0 ) );
-
-	// Scale offsets to texture size
-
-	const scaledDimOffset = dimensionOffset.mul( vec2( blueNoiseTextureSize ) );
-	const scaledFrameOffset = frameOffset.mul( vec2( blueNoiseTextureSize ) );
-
-	// Combine all offsets with proper toroidal wrapping
-
-	const coords = mod( pixelCoords.add( scaledDimOffset ).add( scaledFrameOffset ), vec2( blueNoiseTextureSize ) );
-
-	// Ensure positive coordinates and fetch
-	// .load() → textureLoad() in WGSL: exact integer texel fetch, no filtering (≡ GLSL texelFetch)
-
-	const texCoord = ivec2( floor( coords ) );
-
-	return blueNoiseTextureNode.load( texCoord );
-
-}, { pixelCoords: 'vec2', sampleIndex: 'int', bounceIndex: 'int', frame: 'int', return: 'vec4' } );
-
-// Get 2D blue noise sample with dimension offset
-
-export const sampleBlueNoise2D = /*@__PURE__*/ Fn( ( [ pixelCoords, sampleIndex, dimensionBase, frame ] ) => {
-
-	// For 2D sampling, we need to carefully select components to maintain blue noise properties
-
-	const noise = sampleBlueNoiseRaw( pixelCoords, sampleIndex, dimensionBase.div( int( 2 ) ), frame );
-
-	// Use different component pairs based on dimension
-
-	const pairIndex = mod( dimensionBase.div( int( 2 ) ), int( 6 ) );
+// Atlas layout: 8×8 grid of 128×128 tiles = 1024×1024 texture.
+// Temporal axis: frame % 64 selects tile (true STBN temporal decorrelation).
+// Spatial decorrelation: R2 quasi-random offset keyed on dimension + sample index.
 
-	const result = vec2( 0.0 ).toVar();
-
-	Switch( pairIndex )
-		.Case( 0, () => {
-
-			result.assign( noise.xy );
-
-		} ).Case( 1, () => {
-
-			result.assign( noise.zw );
-
-		} ).Case( 2, () => {
-
-			result.assign( noise.xz );
+const computeSTBNAtlasCoord = ( pixelCoords, sampleIndex, dimensionIndex, frame ) => {
 
-		} ).Case( 3, () => {
+	// Temporal slice — true STBN temporal axis
+	const slice = uint( frame ).bitAnd( uint( 63 ) ); // frame % 64
 
-			result.assign( noise.yw );
+	// R2 quasi-random spatial offset for per-dimension/per-sample decorrelation
+	const n = float( dimensionIndex ).add( float( sampleIndex ).mul( 7.0 ) );
+	const offsetX = int( fract( n.mul( R2_A1 ).add( 0.5 ) ).mul( 128.0 ) );
+	const offsetY = int( fract( n.mul( R2_A2 ).add( 0.5 ) ).mul( 128.0 ) );
 
-		} ).Case( 4, () => {
+	// Pixel within 128×128 tile (toroidal wrap via bitmask)
+	const px = int( pixelCoords.x ).add( offsetX ).bitAnd( int( 127 ) );
+	const py = int( pixelCoords.y ).add( offsetY ).bitAnd( int( 127 ) );
 
-			result.assign( noise.xw );
+	// Atlas tile position from slice index
+	const tileCol = int( slice ).bitAnd( int( 7 ) ); // slice % 8
+	const tileRow = int( slice ).shiftRight( int( 3 ) ); // slice / 8
 
-		} ).Case( 5, () => {
-
-			result.assign( noise.yz );
-
-		} ).Default( () => {
-
-			result.assign( noise.xy );
-
-		} );
-
-	return result;
+	return ivec2( tileCol.mul( int( 128 ) ).add( px ), tileRow.mul( int( 128 ) ).add( py ) );
 
-}, { pixelCoords: 'vec2', sampleIndex: 'int', dimensionBase: 'int', return: 'vec2', frame: 'int' } );
-
-// Progressive blue noise sampling for temporal accumulation
-
-export const sampleProgressiveBlueNoise = /*@__PURE__*/ Fn( ( [ pixelCoords, currentSample, maxSamples, frame ] ) => {
-
-	// Determine which "slice" of the blue noise we're in
-
-	const progress = float( currentSample ).div( max( 1.0, float( maxSamples ) ) );
-	const temporalSlice = int( progress.mul( 16.0 ) );
-
-	// 16 temporal slices
-	// Use different regions of blue noise for different sample counts
-
-	const sliceOffset = vec2( float( mod( temporalSlice, int( 4 ) ) ).mul( 0.25 ), float( temporalSlice.div( int( 4 ) ) ).mul( 0.25 ) );
+};
 
-	// Scale to texture space and add pixel-specific offset
+// Sample 1D scalar STBN value in [0,1]
+export const sampleSTBNScalar = ( pixelCoords, sampleIndex, dimensionIndex, frame ) => {
 
-	const scaledOffset = sliceOffset.mul( vec2( blueNoiseTextureSize ) );
-	const coords = mod( pixelCoords.add( scaledOffset ), vec2( blueNoiseTextureSize ) );
-	const noise = sampleBlueNoiseRaw( coords, currentSample, int( 0 ), frame );
+	const coord = computeSTBNAtlasCoord( pixelCoords, sampleIndex, dimensionIndex, frame );
+	return stbnScalarTextureNode.load( coord ).x;
 
-	// Apply additional Cranley-Patterson rotation for better distribution
+};
 
-	const seed = pcgHash( { state: uint( currentSample ).bitXor( wang_hash( { seed: uint( maxSamples ) } ) ) } );
-	const rotation = vec2( float( seed.bitAnd( 0xFFFF ) ).div( 65536.0 ), float( seed.shiftRight( 16 ).bitAnd( 0xFFFF ) ).div( 65536.0 ) );
+// Sample decorrelated 2D STBN pair in [0,1]²
+export const sampleSTBN2D = ( pixelCoords, sampleIndex, dimensionPairIndex, frame ) => {
 
-	return cranleyPatterson2D( { p: noise.xy, offset: rotation } );
+	const coord = computeSTBNAtlasCoord( pixelCoords, sampleIndex, dimensionPairIndex, frame );
+	return stbnVec2TextureNode.load( coord ).xy;
 
-}, { pixelCoords: 'vec2', currentSample: 'int', maxSamples: 'int', return: 'vec2', frame: 'int' } );
+};
 
 // -----------------------------------------------------------------------------
 // Low-discrepancy sequence generators
@@ -490,19 +423,20 @@ export const getRandomSampleND = ( pixelCoord, sampleIndex, bounceIndex, rngStat
 
 	} ).Else( () => {
 
-		// Blue Noise (technique 3)
-		const dimensionOffset = bounceIndex.mul( 4 );
+		// STBN — Spatiotemporal Blue Noise (technique 3)
+		// Each bounce uses a block of 4 dimension indices for decorrelation
+		const dimBase = bounceIndex.mul( int( 4 ) );
 
 		If( dimensions.lessThanEqual( int( 2 ) ), () => {
 
-			const _sample = sampleBlueNoise2D( pixelCoord, sampleIndex, dimensionOffset, frame );
+			const _sample = sampleSTBN2D( pixelCoord, sampleIndex, dimBase, frame );
 			result.x.assign( _sample.x );
 			result.y.assign( _sample.y );
 
 		} ).Else( () => {
 
-			const _sample1 = sampleBlueNoise2D( pixelCoord, sampleIndex, dimensionOffset, frame );
-			const _sample2 = sampleBlueNoise2D( pixelCoord, sampleIndex, dimensionOffset.add( 2 ), frame );
+			const _sample1 = sampleSTBN2D( pixelCoord, sampleIndex, dimBase, frame );
+			const _sample2 = sampleSTBN2D( pixelCoord, sampleIndex, dimBase.add( int( 1 ) ), frame );
 			result.assign( vec4( _sample1, _sample2 ) );
 
 		} );
@@ -551,33 +485,26 @@ export const getStratifiedSample = ( pixelCoord, rayIndex, totalRays, rngState,
 
 		const strataPos = vec2( float( sx ), float( sy ) ).div( vec2( float( strataX ), float( strataY ) ) );
 
-		// Enhanced jitter based on sampling technique with blue noise fallback for better convergence
+		// Jitter via STBN or fast RNG fallback
 
 		const jitter = vec2( 0.0 ).toVar();
 
 		If( samplingTechnique.greaterThanEqual( int( 3 ) ), () => {
 
-			// Blue noise - improved progressive sampling
-
-			jitter.assign( sampleProgressiveBlueNoise( pixelCoord, rayIndex, totalRays, frame ) );
+			// STBN — true spatiotemporal blue noise jitter
+			jitter.assign( sampleSTBN2D( pixelCoord, rayIndex, int( 0 ), frame ) );
 
 		} ).Else( () => {
 
-			// Enhanced fallback: use fast sampling with slight blue noise influence for better convergence
-			// .toVar() on each call to capture value before next state advance
-
+			// Fast RNG with subtle STBN influence for better convergence
 			const j1 = RandomValueFast( rngState ).toVar();
 			const j2 = RandomValueFast( rngState ).toVar();
 			jitter.assign( vec2( j1, j2 ) );
 
-			// Add subtle blue noise influence even for non-blue-noise techniques
-
 			If( totalRays.greaterThan( int( 4 ) ), () => {
 
-				// Only for multi-sample scenarios
-
-				const blueNoiseInfluence = sampleBlueNoise2D( pixelCoord, rayIndex, int( 0 ), frame ).mul( 0.1 );
-				jitter.assign( mix( jitter, blueNoiseInfluence, 0.2 ) );
+				const stbnInfluence = sampleSTBN2D( pixelCoord, rayIndex, int( 0 ), frame ).mul( 0.1 );
+				jitter.assign( mix( jitter, stbnInfluence, 0.2 ) );
 
 			} );