rayzee 8.8.2 → 9.1.0

package/src/TSL/CameraRay.js

@@ -1,9 +1,10 @@
 /**
  * CameraRay.js — primary camera ray generation.
  *
- * Two projections behind one `cameraProjection` uniform: 0 = pinhole (NDC through
- * cameraProjectionMatrixInverse), 1 = equirectangular 360 panorama. Both branches live in the same
- * kernel, so switching modes writes a uniform and resets accumulation — it never recompiles WGSL.
+ * Three projections behind one `cameraProjection` uniform (CAMERA_PROJECTION_IDS): pinhole (NDC through
+ * cameraProjectionMatrixInverse), equirectangular 360 panorama, and orthographic (parallel rays from the
+ * camera's image plane). All live in the same kernel, so switching modes writes a uniform and resets
+ * accumulation — it never recompiles WGSL.
  *
  * Equirect mapping, for uv ∈ [0,1] with v = 0 at the top row:
  *   lon = mix( lonMin, lonMax, u ),  lat = mix( latMax, latMin, v )
@@ -12,15 +13,81 @@
  */
 
 import {
-	Fn, vec3, vec4, float, int,
-	If, normalize, mat3, mix, sin, cos, cross, dot,
+	Fn, vec3, vec4, float, int, uniform,
+	If, normalize, mat3, mix, sin, cos, cross, dot, select,
 } from 'three/tsl';
+import { Vector2 } from 'three';
 
 import { Ray } from './Struct.js';
 import { constructTBN } from './Common.js';
 import { RandomPointInCircle } from './Random.js';
+import { CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
 
-/** World-space primary ray direction for pixel uv. Origin is always cameraWorldMatrix[3]. */
+const PANORAMA = int( CAMERA_PROJECTION_IDS.equirectangular );
+const ORTHOGRAPHIC = int( CAMERA_PROJECTION_IDS.orthographic );
+
+export const isOrthographic = cameraProjection => cameraProjection.equal( ORTHOGRAPHIC );
+
+/**
+ * The projection uniforms a stage re-tracing the path tracer's primary rays needs. `sync` copies the path
+ * tracer's, once a frame.
+ */
+export function cameraRayUniforms() {
+
+	const u = {
+		cameraProjection: uniform( 0, 'int' ),
+		panoLonRange: uniform( new Vector2(), 'vec2' ),
+		panoLatRange: uniform( new Vector2(), 'vec2' ),
+		panoLevelHorizon: uniform( 1, 'int' ),
+		/** @param {import('../managers/UniformManager.js').UniformManager} source */
+		sync( source ) {
+
+			u.cameraProjection.value = source.get( 'cameraProjection' ).value;
+			u.panoLonRange.value.copy( source.get( 'panoLonRange' ).value );
+			u.panoLatRange.value.copy( source.get( 'panoLatRange' ).value );
+			u.panoLevelHorizon.value = source.get( 'panoLevelHorizon' ).value;
+
+		},
+	};
+	return u;
+
+}
+
+/** Pixel uv's primary ray, for a stage holding {@link cameraRayUniforms}. */
+export const cameraRayOf = ( uv01, cameraWorldMatrix, cameraProjectionMatrixInverse, u ) => ( {
+	origin: cameraRayOrigin( uv01, cameraWorldMatrix, cameraProjectionMatrixInverse, u.cameraProjection ),
+	direction: cameraRayDirection(
+		uv01, cameraWorldMatrix, cameraProjectionMatrixInverse,
+		u.cameraProjection, u.panoLonRange, u.panoLatRange, u.panoLevelHorizon
+	),
+} );
+
+/** The point `distance` along pixel uv's primary ray — where a depth the path tracer measured lies. */
+export const cameraRayPoint = ( uv01, distance, cameraWorldMatrix, cameraProjectionMatrixInverse, u ) => {
+
+	const { origin, direction } = cameraRayOf( uv01, cameraWorldMatrix, cameraProjectionMatrixInverse, u );
+	return origin.add( direction.mul( distance ) );
+
+};
+
+/** World-space primary ray origin for pixel uv: the camera, or its image plane when orthographic. */
+export const cameraRayOrigin = Fn( ( [ uv01, cameraWorldMatrix, cameraProjectionMatrixInverse, cameraProjection ] ) => {
+
+	const origin = vec3( cameraWorldMatrix[ 3 ] ).toVar();
+
+	If( isOrthographic( cameraProjection ), () => {
+
+		// An orthographic inverse maps x and y alone, whatever the depth.
+		const onPlane = cameraProjectionMatrixInverse.mul( vec4( uv01.x.mul( 2.0 ).sub( 1.0 ), float( 1.0 ).sub( uv01.y.mul( 2.0 ) ), 0.0, 1.0 ) );
+		origin.assign( cameraWorldMatrix.mul( vec4( onPlane.xy, 0.0, 1.0 ) ).xyz );
+
+	} );
+
+	return origin;
+
+} );
+
+/** World-space primary ray direction for pixel uv, from {@link cameraRayOrigin}. */
 export const cameraRayDirection = Fn( ( [
 	uv01, cameraWorldMatrix, cameraProjectionMatrixInverse,
 	cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon
@@ -28,7 +95,7 @@ export const cameraRayDirection = Fn( ( [
 
 	const direction = vec3( 0.0 ).toVar();
 
-	If( cameraProjection.equal( int( 1 ) ), () => {
+	If( cameraProjection.equal( PANORAMA ), () => {
 
 		const lon = mix( panoLonRange.x, panoLonRange.y, uv01.x ).toVar();
 		const lat = mix( panoLatRange.y, panoLatRange.x, uv01.y ).toVar();
@@ -68,6 +135,10 @@ export const cameraRayDirection = Fn( ( [
 				.sub( back.mul( cos( lon ).mul( cosLat ) ) )
 		) );
 
+	} ).ElseIf( isOrthographic( cameraProjection ), () => {
+
+		direction.assign( normalize( vec3( cameraWorldMatrix[ 2 ] ) ).negate() );
+
 	} ).Else( () => {
 
 		const ndcPos = vec3( uv01.x.mul( 2.0 ).sub( 1.0 ), float( 1.0 ).sub( uv01.y.mul( 2.0 ) ), 1.0 );
@@ -89,10 +160,10 @@ export const generateRayFromCamera = Fn( ( [
 	uv01, rngState,
 	cameraWorldMatrix, cameraProjectionMatrixInverse,
 	cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
-	enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio
+	enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur
 ] ) => {
 
-	const rayOriginWorld = vec3( cameraWorldMatrix[ 3 ] ).toVar();
+	const rayOriginWorld = cameraRayOrigin( uv01, cameraWorldMatrix, cameraProjectionMatrixInverse, cameraProjection ).toVar();
 	// .toVar() so the two reads below don't inline the whole projection graph twice.
 	const rayDirectionWorld = cameraRayDirection(
 		uv01, cameraWorldMatrix, cameraProjectionMatrixInverse,
@@ -102,10 +173,20 @@ export const generateRayFromCamera = Fn( ( [
 	const resultOrigin = rayOriginWorld.toVar();
 	const resultDirection = rayDirectionWorld.toVar();
 
-	If( enableDOF.and( focalLength.greaterThan( 0.0 ) ).and( aperture.lessThan( 64.0 ) ).and( focusDistance.greaterThan( 0.001 ) ), () => {
+	const lookMode = dofMode.equal( int( 1 ) );
+	const lensOpen = lookMode.and( dofBlur.greaterThan( 0.0 ) ).or( lookMode.not().and( focalLength.greaterThan( 0.0 ) ).and( aperture.lessThan( 64.0 ) ) );
 
-		const effectiveAperture = focalLength.div( aperture );
-		const apertureRadius = effectiveAperture.mul( 0.001 ).mul( sceneScale ).mul( apertureScale );
+	If( enableDOF.and( lensOpen ).and( focusDistance.greaterThan( 0.001 ) ), () => {
+
+		// Orthographic 1: the blur then does not change with where the camera stands.
+		const halfViewHeight = select( cameraProjection.equal( PANORAMA ), panoLatRange.y.sub( panoLatRange.x ).mul( 0.5 ),
+			select( isOrthographic( cameraProjection ), float( 1.0 ), cameraProjectionMatrixInverse[ 1 ].y ) );
+		const apertureRadius = select( lookMode,
+			// A far background blurs by dofBlur of the image height, whatever the scene's scale.
+			dofBlur.mul( focusDistance ).mul( halfViewHeight ),
+			// f/N is the aperture's diameter, not its radius.
+			focalLength.div( aperture.mul( 2.0 ) ).mul( 0.001 ).mul( unitsPerMetre ).mul( apertureScale )
+		);
 
 		const randomPoint = RandomPointInCircle( rngState );
 		// Anamorphic squeeze — stretch horizontally for oval bokeh
@@ -113,8 +194,9 @@ export const generateRayFromCamera = Fn( ( [
 		const lensY = randomPoint.y;
 
 		const lensOffset = vec3( 0.0 ).toVar();
+		const focusAlongRay = focusDistance.toVar();
 
-		If( cameraProjection.equal( int( 1 ) ), () => {
+		If( cameraProjection.equal( PANORAMA ), () => {
 
 			// Every pixel points a different way, so the lens plane is built around the ray. The
 			// camera's right/up would skew bokeh into a slit away from the image centre.
@@ -126,10 +208,13 @@ export const generateRayFromCamera = Fn( ( [
 			const camUp = normalize( vec3( cameraWorldMatrix[ 1 ] ) );
 			lensOffset.assign( camRight.mul( lensX ).add( camUp.mul( lensY ) ) );
 
+			// A flat focal plane: focusDistance is depth along the view axis, not distance along the ray.
+			focusAlongRay.assign( focusDistance.div( dot( rayDirectionWorld, normalize( vec3( cameraWorldMatrix[ 2 ] ) ) ).negate() ) );
+
 		} );
 
 		resultOrigin.assign( rayOriginWorld.add( lensOffset.mul( apertureRadius ) ) );
-		resultDirection.assign( normalize( rayOriginWorld.add( rayDirectionWorld.mul( focusDistance ) ).sub( resultOrigin ) ) );
+		resultDirection.assign( normalize( rayOriginWorld.add( rayDirectionWorld.mul( focusAlongRay ) ).sub( resultOrigin ) ) );
 
 	} );
 

package/src/TSL/Common.js

@@ -329,8 +329,17 @@ export const getDatafromStorageBuffer = Fn( ( [ buffer, stride, sampleIndex, dat
 
 } );
 
-/** uvec4 lanes per triangle record — see TRIANGLE_DATA_LAYOUT. */
-export const TRI_STRIDE = 5;
+/**
+ * The five uvec4 rows of a triangle record (TRIANGLE_DATA_LAYOUT) live in two GPU buffers: rows
+ * 0–2, positions with their packed normals, in `tris.geo`; rows 3–4, UVs, flags and mesh index,
+ * in `tris.shade`. One buffer of 80 B a triangle hit the 4 GB storage-buffer limit at 53.6M.
+ */
+export const TRI_GEO_ROWS = 3;
+export const TRI_SHADE_ROWS = 2;
+
+export const triangleRow = ( tris, triIndex, row ) => row < TRI_GEO_ROWS
+	? getDatafromStorageBuffer( tris.geo, triIndex, int( row ), int( TRI_GEO_ROWS ) )
+	: getDatafromStorageBuffer( tris.shade, triIndex, int( row - TRI_GEO_ROWS ), int( TRI_SHADE_ROWS ) );
 
 // Unit normal to an octahedral snorm16 pair; GPU twin of packNormalOct in EngineDefaults.
 export const packNormalOct = /*@__PURE__*/ wgslFn( `

package/src/TSL/DebugKernel.js

@@ -27,7 +27,7 @@ export function buildDebugKernel( params ) {
 		resolution, renderWidth, renderHeight,
 		cameraWorldMatrix, cameraProjectionMatrixInverse, cameraProjectionMatrix, cameraViewMatrix,
 		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
-		enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
+		enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur,
 		bvhBuffer, triangleBuffer, materialBuffer,
 		envTexture, environmentMatrix, environmentIntensity, enableEnvironmentLight,
 		visMode, debugVisScale,
@@ -50,7 +50,7 @@ export function buildDebugKernel( params ) {
 				pixelCoord.div( resolution ), seed,
 				cameraWorldMatrix, cameraProjectionMatrixInverse,
 				cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
-				enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
+				enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur,
 			) );
 
 			const color = vec4( 1.0, 0.0, 1.0, 1.0 ).toVar();

package/src/TSL/Displacement.js

@@ -1,7 +1,7 @@
 import { Fn, float, vec2, int, If, Loop, abs, normalize, dot, max, uintBitsToFloat } from 'three/tsl';
 
 import { struct } from './patches.js';
-import { getDatafromStorageBuffer, TRI_STRIDE, instanceRows, instanceDirToWorld } from './Common.js';
+import { triangleRow, instanceRows, instanceDirToWorld } from './Common.js';
 import { sampleDisplacementMap, bucketTexelSize, getLinearBucketTextures } from './TextureSampling.js';
 
 // Ray-displacement intersection configuration
@@ -42,12 +42,12 @@ export const refineDisplacedIntersection = Fn( ( [
 	// Fetch triangle vertex data
 	const triIdx = hitInfo.triangleIndex;
 
-	const pA = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 0 ), int( TRI_STRIDE ) ).xyz ).toVar();
-	const pB = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 1 ), int( TRI_STRIDE ) ).xyz );
-	const pC = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 2 ), int( TRI_STRIDE ) ).xyz );
+	const pA = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 0 ).xyz ).toVar();
+	const pB = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 1 ).xyz );
+	const pC = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 2 ).xyz );
 
-	const uvData1 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 3 ), int( TRI_STRIDE ) ) ).toVar();
-	const uvData2 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, triIdx, int( 4 ), int( TRI_STRIDE ) ).xy );
+	const uvData1 = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 3 ) ).toVar();
+	const uvData2 = uintBitsToFloat( triangleRow( triangleBuffer, triIdx, 4 ).xy );
 
 	const uvA = uvData1.xy.toVar();
 	const uvB = uvData1.zw;

package/src/TSL/EmissiveSampling.js

@@ -30,7 +30,7 @@ import { struct } from './patches.js';
 import {
 	MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT,
 	computeDotProductsAniso, instanceRows, instanceNormalToWorld, instancePointToWorld,
-	unpackTriangleNormal, TRI_STRIDE, SHADOW_END
+	unpackTriangleNormal, triangleRow, SHADOW_END
 } from './Common.js';
 import { TRI_MATERIAL_MASK } from '../EngineDefaults.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
@@ -298,11 +298,11 @@ export const TriangleData = struct( {
 export const fetchTriangleData = Fn( ( [ triangleIndex, triangleBuffer, bvhBuffer, instanceLeaf ] ) => {
 
 	// Positions carry their packed normal in .w
-	const pos0 = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 0 ), int( TRI_STRIDE ) ).toVar();
-	const pos1 = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 1 ), int( TRI_STRIDE ) ).toVar();
-	const pos2 = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 2 ), int( TRI_STRIDE ) ).toVar();
+	const pos0 = triangleRow( triangleBuffer, triangleIndex, 0 ).toVar();
+	const pos1 = triangleRow( triangleBuffer, triangleIndex, 1 ).toVar();
+	const pos2 = triangleRow( triangleBuffer, triangleIndex, 2 ).toVar();
 
-	const uvMat = getDatafromStorageBuffer( triangleBuffer, triangleIndex, int( 4 ), int( TRI_STRIDE ) );
+	const uvMat = triangleRow( triangleBuffer, triangleIndex, 4 );
 
 	const v0 = uintBitsToFloat( pos0.xyz ).toVar(), v1 = uintBitsToFloat( pos1.xyz ).toVar(), v2 = uintBitsToFloat( pos2.xyz ).toVar();
 	const n0 = unpackTriangleNormal( pos0.w ).toVar(), n1 = unpackTriangleNormal( pos1.w ).toVar(), n2 = unpackTriangleNormal( pos2.w ).toVar();

package/src/TSL/EnvironmentCDF.js

@@ -0,0 +1,176 @@
+import { Fn, float, int, uint, vec2, vec4, If, Loop, Return, instanceIndex, max, sin, dot, select } from 'three/tsl';
+
+import { REC709_LUMINANCE_COEFFICIENTS } from './Common.js';
+
+/** Floats per row of the packed table: width + 1 texels, padded to the 256 bytes a buffer→texture copy needs. */
+export const cdfRowStride = width => Math.ceil( ( width + 1 ) * 4 / 256 ) * 64;
+
+// First index in [0, n) whose value is ≥ target, n − 1 when none is — as the CPU builder's search.
+function lowerBound( n, valueAt, target ) {
+
+	const lo = int( 0 ).toVar();
+	const hi = int( n - 1 ).toVar();
+	Loop( { start: int( 0 ), end: int( Math.ceil( Math.log2( n ) ) + 1 ), type: 'int', condition: '<', name: 'step' }, () => {
+
+		If( lo.lessThan( hi ), () => {
+
+			const mid = lo.add( hi ).div( 2 ).toVar();
+			If( valueAt( mid ).lessThan( target ), () => {
+
+				lo.assign( mid.add( 1 ) );
+
+			} ).Else( () => {
+
+				hi.assign( mid );
+
+			} );
+
+		} );
+
+	} );
+	return lo;
+
+}
+
+// select(), never mix(): a + t·(b − a) is not b at t = 1, and the search compares a prefix sum
+// against the row total it ends on.
+
+/**
+ * The GPU twin of `EquirectHDRInfo.computeCDF`, into the packed (width + 1) × height table the
+ * sampler reads. `stats[ 1 ]` ends as ( totalSum, compensationDelta, compensated, 0 ).
+ * @returns {Array} kernels, dispatched in order
+ */
+export function buildEnvironmentCDFKernels( { pixels, rows, prefix, stats, cdf, width, height } ) {
+
+	const stride = cdfRowStride( width );
+	const sinTheta = y => sin( float( y ).add( 0.5 ).mul( Math.PI / height ) );
+	const weight = ( y, x, sinT ) => dot( pixels.element( y.mul( width ).add( x ) ).xyz, REC709_LUMINANCE_COEFFICIENTS ).mul( sinT );
+	const firstThreadOnly = () => If( instanceIndex.greaterThan( uint( 0 ) ), () => {
+
+		Return();
+
+	} );
+
+	const rowTotals = Fn( () => {
+
+		const y = instanceIndex;
+		If( y.greaterThanEqual( uint( height ) ), () => {
+
+			Return();
+
+		} );
+
+		const sinT = sinTheta( y ).toVar();
+		const total = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( width ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			total.addAssign( weight( y, uint( i ), sinT ) );
+
+		} );
+		rows.element( y ).assign( vec4( total, 0, 0, 0 ) );
+
+	} )().compute( height, [ 64 ] );
+
+	const mean = Fn( () => {
+
+		firstThreadOnly();
+		const total = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			total.addAssign( rows.element( i ).x );
+
+		} );
+		stats.element( 0 ).assign( vec4( total, total.div( width * height ), 0, 0 ) );
+
+	} )().compute( 1, [ 1 ] );
+
+	const prefixSums = Fn( () => {
+
+		const y = instanceIndex;
+		If( y.greaterThanEqual( uint( height ) ), () => {
+
+			Return();
+
+		} );
+
+		const sinT = sinTheta( y ).toVar();
+		const delta = stats.element( 0 ).y.toVar();
+		const raw = float( 0 ).toVar();
+		const compensated = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( width ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const w = weight( y, uint( i ), sinT ).toVar();
+			raw.addAssign( w );
+			compensated.addAssign( max( w.sub( delta ), 0 ) );
+			prefix.element( y.mul( width ).add( uint( i ) ) ).assign( vec2( raw, compensated ) );
+
+		} );
+		rows.element( y ).assign( vec4( raw, compensated, 0, 0 ) );
+
+	} )().compute( height, [ 64 ] );
+
+	const marginal = Fn( () => {
+
+		firstThreadOnly();
+		const compensatedTotal = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			compensatedTotal.addAssign( rows.element( i ).y );
+
+		} );
+		const useCompensated = compensatedTotal.greaterThan( 0 ).toVar();
+
+		const cumulative = float( 0 ).toVar();
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<' }, ( { i } ) => {
+
+			const r = rows.element( i ).toVar();
+			cumulative.addAssign( select( useCompensated, r.y, r.x ) );
+			rows.element( i ).assign( vec4( r.x, r.y, cumulative, 0 ) );
+
+		} );
+
+		const s = stats.element( 0 ).toVar();
+		stats.element( 1 ).assign( select( useCompensated, vec4( compensatedTotal, s.y, 1, 0 ), vec4( s.x, 0, 0, 0 ) ) );
+
+		Loop( { start: int( 0 ), end: int( height ), type: 'int', condition: '<', name: 'row' }, ( { row } ) => {
+
+			const k = select(
+				cumulative.greaterThan( 0 ),
+				float( lowerBound( height, j => rows.element( j ).z, float( row ).add( 1 ).div( height ).mul( cumulative ) ) ),
+				float( height - 1 ),
+			);
+			cdf.element( uint( row ).mul( stride ).add( width ) ).assign( k.add( 0.5 ).div( height ) );
+
+		} );
+
+	} )().compute( 1, [ 1 ] );
+
+	const conditional = Fn( () => {
+
+		const idx = instanceIndex;
+		If( idx.greaterThanEqual( uint( width * height ) ), () => {
+
+			Return();
+
+		} );
+
+		const x = idx.mod( width );
+		const y = idx.div( width );
+		const useCompensated = stats.element( 1 ).z.greaterThan( 0 ).toVar();
+		const r = rows.element( y ).toVar();
+		const rowTotal = select( useCompensated, r.y, r.x ).toVar();
+		const base = y.mul( width ).toVar();
+		const k = lowerBound( width, j => {
+
+			const p = prefix.element( base.add( uint( j ) ) );
+			return select( useCompensated, p.y, p.x );
+
+		}, float( x ).add( 1 ).div( width ).mul( rowTotal ) );
+		const column = select( rowTotal.greaterThan( 0 ), float( k ), float( width - 1 ) );
+		cdf.element( y.mul( stride ).add( x ) ).assign( column.add( 0.5 ).div( width ) );
+
+	} )().compute( width * height, [ 64 ] );
+
+	return [ rowTotals, mean, prefixSums, marginal, conditional ];
+
+}

package/src/TSL/GenerateKernel.js

@@ -28,7 +28,7 @@ import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
 import {
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf,
 	writeRayRadiance, writeGBuffer,
-	writeMediumStack, writeFeatureThroughput,
+	writeMediumStack, writeFeatureThroughput, writeRngState,
 } from '../Processor/PackedRayBuffer.js';
 
 const WG_SIZE = 16;
@@ -36,11 +36,11 @@ const WG_SIZE = 16;
 export function buildGenerateKernel( params ) {
 
 	const {
-		rayBufferRW, rngBufferRW, gBufferRW,
+		rayBufferRW, hitBufferRW, gBufferRW,
 		resolution, frame,
 		cameraWorldMatrix, cameraProjectionMatrixInverse,
 		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
-		enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
+		enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur,
 		renderWidth,
 		chunkRowBase, chunkRows, // row band offset (global first row) + row count for this chunk
 		transmissiveBounces, // per-ray refraction budget (megakernel parity: PathTracerCore.js:606)
@@ -78,7 +78,7 @@ export function buildGenerateKernel( params ) {
 			jitteredUV, seed,
 			cameraWorldMatrix, cameraProjectionMatrixInverse,
 			cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
-			enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
+			enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur,
 		) );
 
 		writeRayOriginMeta( rayBufferRW, rayID, ray.origin, int( 0 ), int( 0 ) );
@@ -104,7 +104,7 @@ export function buildGenerateKernel( params ) {
 
 		writeMediumStack( rayBufferRW, rayID, uint( 0 ), uint( transmissiveBounces ), float( 1.0 ), float( 1.0 ), float( 1.0 ) );
 
-		rngBufferRW.element( rayID ).assign( seed );
+		writeRngState( hitBufferRW, rayID, seed );
 
 	};
 

package/src/TSL/HitFacet.js

@@ -15,7 +15,7 @@ import {
 	packHalf2x16, unpackHalf2x16,
 } from 'three/tsl';
 import {
-	getDatafromStorageBuffer, unpackTriangleNormal, TRI_STRIDE, instanceRows, instanceFaceNormalToWorld,
+	unpackTriangleNormal, triangleRow, instanceRows, instanceFaceNormalToWorld,
 } from './Common.js';
 import { shadowTerminatorLift } from './ShadowTerminator.js';
 
@@ -30,9 +30,9 @@ export function hitFacet( { triangleBuffer, bvhBuffer, triIdx, instanceLeaf, hit
 
 	If( didHit, () => {
 
-		const recA = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 0 ), int( TRI_STRIDE ) ).toVar();
-		const recB = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 1 ), int( TRI_STRIDE ) ).toVar();
-		const recC = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 2 ), int( TRI_STRIDE ) ).toVar();
+		const recA = triangleRow( triangleBuffer, triIdx, 0 ).toVar();
+		const recB = triangleRow( triangleBuffer, triIdx, 1 ).toVar();
+		const recC = triangleRow( triangleBuffer, triIdx, 2 ).toVar();
 		const V0 = uintBitsToFloat( recA.xyz ).toVar();
 		const V1 = uintBitsToFloat( recB.xyz ).toVar();
 		const V2 = uintBitsToFloat( recC.xyz ).toVar();

package/src/TSL/LightsDirect.js

@@ -27,8 +27,8 @@ import {
 
 import { Ray, ShadowMaterial, HitInfo } from './Struct.js';
 import {
-	REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, getDatafromStorageBuffer, instanceRows,
-	instanceFaceNormalToWorld, TRI_STRIDE, getAlphaShadowsUniform, shadowFlagsSettle, offsetRayOrigin,
+	REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, instanceRows,
+	instanceFaceNormalToWorld, triangleRow, getAlphaShadowsUniform, shadowFlagsSettle, offsetRayOrigin,
 } from './Common.js';
 import { fresnelDielectric } from './Fresnel.js';
 import { calculateBeerLawAbsorption } from './MaterialTransmission.js';
@@ -92,7 +92,7 @@ export const traceShadowRay = Fn( ( [
 		// Opaque fast-path: check the per-triangle blocker bit, set at extraction time when
 		// alphaMode/transparent/transmission/opacity all indicate a fully opaque surface.
 		// Short-circuits the 7-slot getShadowMaterial fetch and the whole alpha decision tree.
-		const flags = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 4 ), int( TRI_STRIDE ) ).z;
+		const flags = triangleRow( triangleBuffer, shadowHit.triangleIndex, 4 ).z;
 		If( shadowFlagsSettle( flags ), () => {
 
 			transmittance.assign( 0.0 );
@@ -125,8 +125,8 @@ export const traceShadowRay = Fn( ( [
 					const baryU = shadowHit.uv.x;
 					const baryV = shadowHit.uv.y;
 					const baryW = float( 1.0 ).sub( baryU ).sub( baryV );
-					const uvData1 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 3 ), int( TRI_STRIDE ) ) );
-					const uvData2 = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 4 ), int( TRI_STRIDE ) ).xy );
+					const uvData1 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 3 ) );
+					const uvData2 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 4 ).xy );
 					const hitUV = uvData1.xy.mul( baryW ).add( uvData1.zw.mul( baryU ) ).add( uvData2.mul( baryV ) );
 					const albedoUV = getTransformedUV( { uv: hitUV, transform: shadowMaterial.albedoTransform } );
 					texAlpha.assign( sampleBucket( _shadowAlbedoMaps, shadowMaterial.albedoMapIndex, albedoUV ).a );
@@ -181,9 +181,9 @@ export const traceShadowRay = Fn( ( [
 			// Deferred geometric-normal compute — refetch triangle positions and
 			// derive the normal here so opaque/alpha-cutout shadow hits don't pay
 			// the cross+normalize cost in BVH traversal.
-			const pA = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 0 ), int( TRI_STRIDE ) ).xyz );
-			const pB = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 1 ), int( TRI_STRIDE ) ).xyz );
-			const pC = uintBitsToFloat( getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 2 ), int( TRI_STRIDE ) ).xyz );
+			const pA = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 0 ).xyz );
+			const pB = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 1 ).xyz );
+			const pC = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 2 ).xyz );
 			// Positions are in the blocker's object space; the cross product is a normal, so
 			// it rides the inverse-transpose back out rather than the forward matrix.
 			const objNormal = normalize( cross( pB.sub( pA ), pC.sub( pA ) ) ).toVar();