rayzee 8.8.1 → 9.0.0

package/src/Stages/NRD.js

@@ -6,7 +6,7 @@ import { DataTexture, HalfFloatType, FloatType, RGBAFormat, LinearFilter, Matrix
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { createStorageTexture } from '../Processor/StorageTexturePool.js';
 import { sanitizeRGB, sanitize1, FP16_MAX } from '../TSL/Common.js';
-import { cameraRayDirection } from '../TSL/CameraRay.js';
+import { cameraRayPoint, cameraRayUniforms, isOrthographic } from '../TSL/CameraRay.js';
 import {
 	ALBEDO_EPS, GBUFFER_MISS_THRESHOLD as MISS_THRESHOLD, NRD_DEFAULTS,
 	NRD_HIT_DIST_A, NRD_HIT_DIST_B,
@@ -168,10 +168,10 @@ export class NRD extends RenderStage {
 		this.prevCamView = uniform( new Matrix4(), 'mat4' );
 		this.camPos = uniform( new Vector3(), 'vec3' );
 		this.prevCamPos = uniform( new Vector3(), 'vec3' );
-		this.cameraProjection = uniform( 0, 'int' );
-		this.panoLonRange = uniform( new Vector2(), 'vec2' );
-		this.panoLatRange = uniform( new Vector2(), 'vec2' );
-		this.panoLevelHorizon = uniform( 1, 'int' );
+		// Surface to camera while orthographic, where it is the same for every pixel.
+		this.viewVector = uniform( new Vector3(), 'vec3' );
+		this.prevViewVector = uniform( new Vector3(), 'vec3' );
+		this.cameraRay = cameraRayUniforms();
 
 		// Declared here, valued by _syncUniforms below — which is the only place a setting becomes a
 		// uniform, so there is no second copy of the defaults to keep in step.
@@ -322,11 +322,20 @@ export class NRD extends RenderStage {
 	// Same ray the depth was measured along — NormalDepth generates it with this helper too.
 	_worldPosAt( uv, dist, cwm, cpi ) {
 
-		const dir = cameraRayDirection(
-			uv, cwm, cpi,
-			this.cameraProjection, this.panoLonRange, this.panoLatRange, this.panoLevelHorizon
-		);
-		return vec3( cwm[ 3 ] ).add( dir.mul( dist ) );
+		return cameraRayPoint( uv, dist, cwm, cpi, this.cameraRay );
+
+	}
+
+	// NRD's gOrthoMode: a constant view vector, and a pixel's footprint that no longer grows with depth.
+	_viewVector( X, camPos, orthoV ) {
+
+		return select( isOrthographic( this.cameraRay.cameraProjection ), orthoV, normalize( camPos.sub( X ) ) );
+
+	}
+
+	_frustumSize( viewZ ) {
+
+		return this.minRectDimMulUnproject.mul( select( isOrthographic( this.cameraRay.cameraProjection ), float( 1.0 ), viewZ ) );
 
 	}
 
@@ -547,9 +556,9 @@ export class NRD extends RenderStage {
 
 					If( maxRadiusU.greaterThan( 0.0 ), () => {
 
-						const V = normalize( camPos.sub( X ) );
+						const V = this._viewVector( X, camPos, this.viewVector );
 						const NoV = dot( N, V ).abs().toVar();
-						const frustumSize = this.minRectDimMulUnproject.mul( viewZ ).toVar();
+						const frustumSize = this._frustumSize( viewZ ).toVar();
 
 						const k = inputFrames.add( 1.0 );
 						const accumSpeedEff = isPre
@@ -701,9 +710,9 @@ export class NRD extends RenderStage {
 				const pixelUv = this._pixelUv( gx, gy );
 				const X = this._worldPosAt( pixelUv, dist, cwm, cpi ).toVar();
 				const viewZ = camView.mul( vec4( X, 1.0 ) ).z.abs().toVar();
-				const V = normalize( camPos.sub( X ) );
+				const V = this._viewVector( X, camPos, this.viewVector );
 				const NoV = dot( N, V ).abs().toVar();
-				const frustumSize = this.minRectDimMulUnproject.mul( viewZ ).toVar();
+				const frustumSize = this._frustumSize( viewZ ).toVar();
 
 				// Unnormalized, as NRD requires — its length carries the normal variance. A miss neighbour's
 				// shadingNormal is a literal (0,0,0), which decodes to a fixed fake direction, so substitute
@@ -753,7 +762,7 @@ export class NRD extends RenderStage {
 
 				const accumSpeed = this._applyCustomWeights( prevAccum, occW, float( 0.0 ) ).toVar();
 
-				const Vprev = normalize( prevCamPos.sub( X ) );
+				const Vprev = this._viewVector( X, prevCamPos, this.prevViewVector );
 				const NoVprev = dot( N, Vprev ).abs();
 				const sizeQuality = NoVprev.add( 1e-3 ).div( NoV.add( 1e-3 ) ).toVar();
 				sizeQuality.assign( mix( float( 0.1 ), float( 1.0 ), saturate( sizeQuality.mul( sizeQuality ) ) ) );
@@ -853,7 +862,7 @@ export class NRD extends RenderStage {
 				const pixelUv = this._pixelUv( gx, gy );
 				const X = this._worldPosAt( pixelUv, dist, cwm, cpi ).toVar();
 				const viewZ = camView.mul( vec4( X, 1.0 ) ).z.abs();
-				const frustumSize = this.minRectDimMulUnproject.mul( viewZ ).toVar();
+				const frustumSize = this._frustumSize( viewZ ).toVar();
 
 				const diff = textureLoad( inTex, coord ).toVar();
 				const nonLinear = float( 1.0 ).div( frameNumEff.add( 1.0 ) ).toVar();
@@ -1200,6 +1209,7 @@ export class NRD extends RenderStage {
 
 			this.prevCamView.value.copy( this.camView.value );
 			this.prevCamPos.value.copy( this.camPos.value );
+			this.prevViewVector.value.copy( this.viewVector.value );
 
 		}
 
@@ -1207,20 +1217,19 @@ export class NRD extends RenderStage {
 		this.camProjInv.value.copy( projInv );
 		this.camView.value.copy( view );
 		this.camPos.value.setFromMatrixPosition( world );
-		this.cameraProjection.value = pt.uniforms.get( 'cameraProjection' ).value;
-		this.panoLonRange.value.copy( pt.uniforms.get( 'panoLonRange' ).value );
-		this.panoLatRange.value.copy( pt.uniforms.get( 'panoLatRange' ).value );
-		this.panoLevelHorizon.value = pt.uniforms.get( 'panoLevelHorizon' ).value;
+		this.viewVector.value.setFromMatrixColumn( world, 2 ).normalize();
+		this.cameraRay.sync( pt.uniforms );
 
 		if ( ! this._camInitialized ) {
 
 			this.prevCamView.value.copy( view );
 			this.prevCamPos.value.copy( this.camPos.value );
+			this.prevViewVector.value.copy( this.viewVector.value );
 			this._camInitialized = true;
 
 		}
 
-		// NRD gUnproject; frustum size follows the shorter edge.
+		// NRD gUnproject; frustum size follows the shorter edge. Orthographic, it is world units per pixel.
 		const projY = proj.elements[ 5 ] || 1;
 		const unproject = 1 / ( 0.5 * this.resH.value * projY );
 		this.minRectDimMulUnproject.value = Math.min( this.resW.value, this.resH.value ) * unproject;

package/src/Stages/NormalDepth.js

@@ -1,4 +1,4 @@
-import { Fn, vec2, vec3, vec4, float, int, uint, uvec2, uvec4, uniform, min, storage, If,
+import { Fn, vec2, vec4, float, int, uint, uvec2, uvec4, uniform, min, storage, If,
 	textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, RGBAFormat, RedIntegerFormat, UnsignedIntType, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
@@ -6,7 +6,7 @@ import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 import { Ray, HitInfo, RayTracingMaterial, UVCache } from '../TSL/Struct.js';
 import { traverseBVH } from '../TSL/BVHTraversal.js';
-import { cameraRayDirection } from '../TSL/CameraRay.js';
+import { cameraRayOf, cameraRayUniforms } from '../TSL/CameraRay.js';
 import { getMaterial } from '../TSL/Common.js';
 import { computeUVCache, processNormal, processBump, processMetalnessRoughness, triangleUVTangent, buildBucketTextureNodes, refreshBucketTextureNodes, setMaterialBucketTextures } from '../TSL/TextureSampling.js';
 
@@ -53,10 +53,7 @@ export class NormalDepth extends RenderStage {
 		this.cameraProjectionMatrixInverse = uniform( new Matrix4(), 'mat4' );
 		// Mirrored from the path tracer each frame — these rays must use the same camera model
 		// as the colour buffer or the denoiser's normal/depth edge-stops fight the image.
-		this.cameraProjection = uniform( 0, 'int' );
-		this.panoLonRange = uniform( new Vector2(), 'vec2' );
-		this.panoLatRange = uniform( new Vector2(), 'vec2' );
-		this.panoLevelHorizon = uniform( 1, 'int' );
+		this.cameraRay = cameraRayUniforms();
 		this.resolutionWidth = uniform( options.width || 1 );
 		this.resolutionHeight = uniform( options.height || 1 );
 
@@ -236,13 +233,7 @@ export class NormalDepth extends RenderStage {
 				// No jitter — deterministic per-pixel ray so the temporal gate
 				// sees stable per-pixel normals across frames.
 				const uv = vec2( float( gx ).add( 0.5 ).div( resW ), float( gy ).add( 0.5 ).div( resH ) );
-				const rayDirWorld = cameraRayDirection(
-					uv, camWorldMat, camProjInvMat,
-					this.cameraProjection, this.panoLonRange, this.panoLatRange, this.panoLevelHorizon
-				);
-				const rayOrigin = vec3( camWorldMat[ 3 ] );
-
-				const ray = Ray( { origin: rayOrigin, direction: rayDirWorld } );
+				const ray = Ray( cameraRayOf( uv, camWorldMat, camProjInvMat, this.cameraRay ) );
 				const hit = HitInfo.wrap( traverseBVH( ray, bvhStorage, triStorage ) );
 
 				const encodedNormal = hit.normal.mul( 0.5 ).add( 0.5 );
@@ -339,10 +330,7 @@ export class NormalDepth extends RenderStage {
 
 			this.cameraWorldMatrix.value.copy( pt.uniforms.get( 'cameraWorldMatrix' ).value );
 			this.cameraProjectionMatrixInverse.value.copy( pt.uniforms.get( 'cameraProjectionMatrixInverse' ).value );
-			this.cameraProjection.value = pt.uniforms.get( 'cameraProjection' ).value;
-			this.panoLonRange.value.copy( pt.uniforms.get( 'panoLonRange' ).value );
-			this.panoLatRange.value.copy( pt.uniforms.get( 'panoLatRange' ).value );
-			this.panoLevelHorizon.value = pt.uniforms.get( 'panoLevelHorizon' ).value;
+			this.cameraRay.sync( pt.uniforms );
 
 		}
 

package/src/Stages/PathTracer.js

@@ -1163,9 +1163,11 @@ export class PathTracer extends PathTracerStage {
 			focalLength: this.focalLength,
 			aperture: this.aperture,
 			focusDistance: this.focusDistance,
-			sceneScale: this.sceneScale,
+			unitsPerMetre: this.unitsPerMetre,
 			apertureScale: this.apertureScale,
 			anamorphicRatio: this.anamorphicRatio,
+			dofMode: this.dofMode,
+			dofBlur: this.dofBlur,
 			renderWidth: this._wfRenderWidth,
 			renderHeight: this._wfRenderHeight,
 			chunkRowBase: this._wfChunkRowBase,
@@ -1643,9 +1645,11 @@ export class PathTracer extends PathTracerStage {
 			focalLength: this.focalLength,
 			aperture: this.aperture,
 			focusDistance: this.focusDistance,
-			sceneScale: this.sceneScale,
+			unitsPerMetre: this.unitsPerMetre,
 			apertureScale: this.apertureScale,
 			anamorphicRatio: this.anamorphicRatio,
+			dofMode: this.dofMode,
+			dofBlur: this.dofBlur,
 			bvhBuffer: freshBvh,
 			triangleBuffer: freshTri,
 			materialBuffer: freshMat,

package/src/Stages/PathTracerStage.js

@@ -1013,6 +1013,8 @@ export class PathTracerStage extends RenderStage {
 
 		if ( ! attr ) return;
 		attr.array.set( data );
+		// A pending update range would cut this full upload down to that range.
+		attr.clearUpdateRanges();
 		attr.needsUpdate = true;
 
 	}

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

@@ -40,7 +40,7 @@ export function buildGenerateKernel( params ) {
 		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 ) );

package/src/index.js

@@ -96,6 +96,10 @@ export { TransformManager } from './managers/TransformManager.js';
 // Video rendering
 export { VideoRenderManager } from './managers/VideoRenderManager.js';
 
+// Authored animation: keyframed tracks on one timeline (engine.timeline)
+export { TimelineManager } from './managers/timeline/TimelineManager.js';
+export { CameraTrack } from './managers/timeline/CameraTrack.js';
+
 // Interaction
 export { InteractionManager } from './managers/InteractionManager.js';