rayzee 8.8.2 → 9.1.0

package/src/SceneState/portable.js

@@ -0,0 +1,52 @@
+import { Color, Quaternion, Vector2, Vector3, Vector4 } from 'three';
+
+/**
+ * JSON-safe copies of setting and material values: colours, vectors and non-finite numbers are
+ * tagged so {@link fromPortable} gives back the same types. Anything else that is not plain data
+ * comes back undefined, so a caller can leave it out.
+ */
+export function toPortable( value ) {
+
+	if ( value === null || typeof value === 'boolean' || typeof value === 'string' ) return value;
+	if ( typeof value === 'number' ) return Number.isFinite( value ) ? value : { $num: String( value ) };
+	if ( typeof value !== 'object' ) return undefined;
+	if ( value.isColor ) return { $color: [ value.r, value.g, value.b ] };
+	if ( value.isQuaternion ) return { $quat: [ value.x, value.y, value.z, value.w ] };
+	if ( value.isVector2 || value.isVector3 || value.isVector4 ) return { $vec: value.toArray() };
+	if ( ArrayBuffer.isView( value ) ) return Array.from( value );
+	if ( Array.isArray( value ) ) return value.map( v => toPortable( v ) ?? null );
+
+	const proto = Object.getPrototypeOf( value );
+	if ( proto !== Object.prototype && proto !== null ) return undefined;
+
+	const out = {};
+	for ( const [ key, v ] of Object.entries( value ) ) {
+
+		const p = toPortable( v );
+		if ( p !== undefined ) out[ key ] = p;
+
+	}
+
+	return out;
+
+}
+
+export function fromPortable( value ) {
+
+	if ( value === null || typeof value !== 'object' ) return value;
+	if ( Array.isArray( value ) ) return value.map( fromPortable );
+	if ( '$num' in value ) return Number( value.$num );
+	if ( value.$color ) return new Color( ...value.$color );
+	if ( value.$quat ) return new Quaternion( ...value.$quat );
+	if ( value.$vec ) {
+
+		const Vector = [ null, null, Vector2, Vector3, Vector4 ][ value.$vec.length ];
+		return new Vector( ...value.$vec );
+
+	}
+
+	const out = {};
+	for ( const [ key, v ] of Object.entries( value ) ) out[ key ] = fromPortable( v );
+	return out;
+
+}

package/src/Stages/MotionVector.js

@@ -1,9 +1,10 @@
-import { Fn, vec2, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If, normalize, mat3,
+import { Fn, vec2, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If,
 	textureLoad, textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
+import { cameraRayPoint, cameraRayUniforms } from '../TSL/CameraRay.js';
 
 /**
  * WebGPU Motion Vector Stage (Compute Shader)
@@ -20,8 +21,8 @@ import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
  *
  * Algorithm:
  *   1. Read normalDepth from NormalDepth (linear depth in alpha)
- *   2. Reconstruct camera ray from pixel coords via inverse projection
- *   3. World position = cameraPos + normalize(rayDir) * linearDepth
+ *   2. Reconstruct the camera ray NormalDepth traced for the pixel
+ *   3. World position = rayOrigin + rayDir * linearDepth
  *   4. Project to previous frame:  prevVP * worldPos
  *   5. Motion = currentUV - prevUV
  *
@@ -78,6 +79,7 @@ export class MotionVector extends RenderStage {
 		// Synced from PathTracer each frame (same source as NormalDepth)
 		this.cameraWorldMatrix = uniform( new Matrix4(), 'mat4' );
 		this.cameraProjectionMatrixInverse = uniform( new Matrix4(), 'mat4' );
+		this.cameraRay = cameraRayUniforms();
 		this.prevVP = uniform( new Matrix4(), 'mat4' );
 		this.isFirstFrameU = uniform( 1.0 ); // 1.0 = true, 0.0 = false
 		this.deltaTime = uniform( 1.0 / 60.0 );
@@ -175,29 +177,7 @@ export class MotionVector extends RenderStage {
 				// Sky / background (depth >= 65504 sentinel) — no motion
 				If( linearDepth.lessThan( float( 6e4 ) ), () => {
 
-					// Pixel coordinate → NDC
-					// Negate Y to match PathTracer convention
-					const ndcX = float( gx ).add( 0.5 ).div( resW ).mul( 2.0 ).sub( 1.0 );
-					const ndcY = float( gy ).add( 0.5 ).div( resH ).mul( 2.0 ).sub( 1.0 ).negate();
-					const ndcPos = vec3( ndcX, ndcY, 1.0 );
-
-					// Camera-space ray direction via inverse projection
-					const rayDirCS = cpi.mul( vec4( ndcPos, 1.0 ) );
-
-					// Transform to world space (rotation only, via mat3 of world matrix)
-					const rayDirWorld = normalize(
-						mat3(
-							cwm[ 0 ].xyz,
-							cwm[ 1 ].xyz,
-							cwm[ 2 ].xyz
-						).mul( rayDirCS.xyz.div( rayDirCS.w ) )
-					);
-
-					// Camera position (translation column of world matrix)
-					const camPos = vec3( cwm[ 3 ] );
-
-					// World position = camera origin + ray direction * linear depth
-					const worldPos = camPos.add( rayDirWorld.mul( linearDepth ) );
+					const worldPos = cameraRayPoint( currentUV, linearDepth, cwm, cpi, this.cameraRay );
 
 					// Project to previous frame
 					const prevClip = prevVP.mul( vec4( worldPos, 1.0 ) );
@@ -278,27 +258,12 @@ export class MotionVector extends RenderStage {
 				// Skip first frame and sky (depth >= 65504 sentinel)
 				If( isFirstFrameU.lessThan( 0.5 ).and( linearDepth.lessThan( float( 6e4 ) ) ), () => {
 
-					// Pixel coordinate → NDC
-					// Negate Y to match PathTracer convention
-					const ndcX = float( gx ).add( 0.5 ).div( resW ).mul( 2.0 ).sub( 1.0 );
-					const ndcY = float( gy ).add( 0.5 ).div( resH ).mul( 2.0 ).sub( 1.0 ).negate();
-					const ndcPos = vec3( ndcX, ndcY, 1.0 );
-					const rayDirCS = cpi.mul( vec4( ndcPos, 1.0 ) );
-					const rayDirWorld = normalize(
-						mat3(
-							cwm[ 0 ].xyz,
-							cwm[ 1 ].xyz,
-							cwm[ 2 ].xyz
-						).mul( rayDirCS.xyz.div( rayDirCS.w ) )
-					);
-					const camPos = vec3( cwm[ 3 ] );
-					const worldPos = camPos.add( rayDirWorld.mul( linearDepth ) );
-
 					// Current pixel UV
 					const currentUV = vec2(
 						float( gx ).add( 0.5 ).div( resW ),
 						float( gy ).add( 0.5 ).div( resH )
 					);
+					const worldPos = cameraRayPoint( currentUV, linearDepth, cwm, cpi, this.cameraRay );
 
 					// Project to previous frame
 					const prevClip = prevVP.mul( vec4( worldPos, 1.0 ) );
@@ -370,6 +335,7 @@ export class MotionVector extends RenderStage {
 		if ( pt && pt.uniforms ) {
 
 			// Sync from PathTracer (same source as NormalDepth)
+			this.cameraRay.sync( pt.uniforms );
 			worldMatrix = pt.uniforms.get( 'cameraWorldMatrix' ).value;
 			viewMatrix = pt.uniforms.get( 'cameraViewMatrix' ).value;
 			projMatrix = pt.uniforms.get( 'cameraProjectionMatrix' ).value;

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 );
 
@@ -151,7 +148,7 @@ export class NormalDepth extends RenderStage {
 		if ( ! pt ) return false;
 
 		const matAttr = pt.materialData?.materialStorageAttr;
-		const triSwapped = pt.triangleStorageAttr && pt.triangleStorageAttr !== this._lastTriAttr;
+		const triSwapped = pt.triangleGeoAttr && pt.triangleGeoAttr !== this._lastTriAttr;
 		const bvhSwapped = pt.bvhStorageAttr && pt.bvhStorageAttr !== this._lastBvhAttr;
 		const matSwapped = matAttr && matAttr !== this._lastMatAttr;
 
@@ -170,12 +167,13 @@ export class NormalDepth extends RenderStage {
 
 		}
 
-		if ( pt.triangleStorageAttr && ! this._triStorageNode ) {
+		if ( pt.triangleGeoAttr && ! this._triStorageNode ) {
 
 			// uvec4, matching PathTracerStage: packed lanes must keep their exact bit pattern.
-			this._triStorageNode = storage(
-				pt.triangleStorageAttr, 'uvec4', pt.triangleStorageAttr.count
-			).toReadOnly();
+			this._triStorageNode = {
+				geo: storage( pt.triangleGeoAttr, 'uvec4', pt.triangleGeoAttr.count ).toReadOnly(),
+				shade: storage( pt.triangleShadeAttr, 'uvec4', pt.triangleShadeAttr.count ).toReadOnly(),
+			};
 
 		}
 
@@ -196,7 +194,7 @@ export class NormalDepth extends RenderStage {
 		// In-place bucket swaps (model change) — graph closes over the nodes, only .value changes.
 		if ( this._linearBuckets ) refreshBucketTextureNodes( this._linearBuckets, pt.materialData?.linearBuckets );
 
-		this._lastTriAttr = pt.triangleStorageAttr || this._lastTriAttr;
+		this._lastTriAttr = pt.triangleGeoAttr || this._lastTriAttr;
 		this._lastBvhAttr = pt.bvhStorageAttr || this._lastBvhAttr;
 		this._lastMatAttr = matAttr || this._lastMatAttr;
 
@@ -236,13 +234,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 +331,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

@@ -188,7 +188,7 @@ export class PathTracer extends PathTracerStage {
 		} );
 
 		// Scene geometry (triangle data, two-level BVH, light BVH + emissive)
-		t.register( 'geometry', () => [ this.triangleStorageAttr, this.bvhStorageAttr, this.lightStorageAttr ] );
+		t.register( 'geometry', () => [ this.triangleGeoAttr, this.triangleShadeAttr, this.bvhStorageAttr, this.lightStorageAttr ] );
 
 		// Material storage buffer + per-property texture arrays
 		t.register( 'materials', () => {
@@ -547,6 +547,107 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	/**
+	 * The accumulation as it stands, for a checkpoint: the three MRT attachments (aux only while it
+	 * holds samples), the per-pixel convergence buffers, and the counters that decide the next
+	 * sample — together what a later frame reads, so restoring them continues the same sequence.
+	 * @returns {Promise<Object>} typed arrays, tight rows, top row first as the textures hold them
+	 */
+	async captureAccumulation() {
+
+		const pool = this.storageTextures;
+		const width = pool.renderWidth;
+		const height = pool.renderHeight;
+		const pixels = width * height;
+
+		const readAttachment = async index => {
+
+			const padded = await this.renderer.readRenderTargetPixelsAsync( pool.readTarget, 0, 0, width, height, index );
+			const stride = Math.ceil( width * 16 / 256 ) * 64;
+			if ( stride === width * 4 ) return new Float32Array( padded.buffer, padded.byteOffset, pixels * 4 ).slice();
+			const tight = new Float32Array( pixels * 4 );
+			for ( let y = 0; y < height; y ++ ) tight.set( padded.subarray( y * stride, y * stride + width * 4 ), y * width * 4 );
+			return tight;
+
+		};
+
+		const readBuffer = async ( attr, Type ) => attr ? new Type( await this.renderer.getArrayBufferAsync( attr, null, 0, pixels * 4 ) ) : null;
+		const aux = this._auxGBufferEnabled && this._auxSamples > 0;
+
+		// Every copy is submitted here, in this task, before any await: a frame rendered between two of
+		// them would give a checkpoint whose parts disagree.
+		const state = {
+			frameCount: this.frameCount,
+			seedTick: this._seedTick,
+			auxSamples: aux ? this._auxSamples : 0,
+			convergedFraction: this._convergedFraction,
+			convergedGeometryFraction: this._convergedGeometryFraction,
+			isComplete: this.isComplete,
+		};
+		const reads = [
+			readAttachment( 0 ),
+			aux ? readAttachment( 1 ) : null,
+			aux ? readAttachment( 2 ) : null,
+			readBuffer( this._m2Attr, Float32Array ),
+			readBuffer( this._streakAttr, Uint32Array ),
+			readBuffer( this._frozenMaskAttr, Uint32Array ),
+		];
+		const [ color, normalDepth, albedo, m2, streak, frozenMask ] = await Promise.all( reads );
+
+		return { width, height, state, color, normalDepth, albedo, m2, streak, frozenMask };
+
+	}
+
+	/**
+	 * Writes a {@link captureAccumulation} back, so the next frame continues it. The render size must
+	 * match; nothing may reset accumulation after this.
+	 */
+	restoreAccumulation( checkpoint ) {
+
+		const pool = this.storageTextures;
+		const { width, height, state } = checkpoint;
+		if ( pool.renderWidth !== width || pool.renderHeight !== height ) {
+
+			throw new Error( `checkpoint is ${width}×${height}; the render is ${pool.renderWidth}×${pool.renderHeight}` );
+
+		}
+
+		const backend = this.renderer.backend;
+		const device = backend.device;
+		if ( ! backend.get( pool.readTarget.textures[ 0 ] ).texture ) this.renderer.initRenderTarget( pool.readTarget );
+
+		const writeAttachment = ( index, data ) => device.queue.writeTexture(
+			{ texture: backend.get( pool.readTarget.textures[ index ] ).texture },
+			data,
+			{ bytesPerRow: width * 16, rowsPerImage: height },
+			{ width, height },
+		);
+
+		const writeBuffer = ( attr, data ) => {
+
+			if ( attr && data ) device.queue.writeBuffer( backend.get( attr ).buffer, 0, data );
+
+		};
+
+		writeAttachment( 0, checkpoint.color );
+		if ( checkpoint.normalDepth ) writeAttachment( 1, checkpoint.normalDepth );
+		if ( checkpoint.albedo ) writeAttachment( 2, checkpoint.albedo );
+		writeBuffer( this._m2Attr, checkpoint.m2 );
+		writeBuffer( this._streakAttr, checkpoint.streak );
+		writeBuffer( this._frozenMaskAttr, checkpoint.frozenMask );
+
+		this.frameCount = state.frameCount;
+		this.frame.value = state.frameCount;
+		this._seedTick = state.seedTick;
+		this.hasPreviousAccumulated.value = state.frameCount > 0 ? 1 : 0;
+		this._auxSamples = checkpoint.normalDepth ? state.auxSamples : 0;
+		this._auxSeedPending = this._auxGBufferEnabled && ! checkpoint.normalDepth;
+		this._convergedFraction = state.convergedFraction ?? 0;
+		this._convergedGeometryFraction = state.convergedGeometryFraction ?? 0;
+		this.isComplete = false;
+
+	}
+
 	reset() {
 
 		super.reset();
@@ -1147,7 +1248,7 @@ export class PathTracer extends PathTracerStage {
 
 		const genParams = {
 			rayBufferRW: pb.rayBuffer.rw,
-			rngBufferRW: pb.rngBuffer.rw,
+			hitBufferRW: pb.hitBuffer.rw,
 			gBufferRW,
 			resolution: this.resolution,
 			// RNG axis only (baseSeed + stratified jitter) — takes the seed counter, not the
@@ -1163,9 +1264,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,
@@ -1456,8 +1559,7 @@ export class PathTracer extends PathTracerStage {
 			envCDFTexture: freshEnvCDF,
 			lightBuffer: freshLight,
 			rayBufferRW: pb.rayBuffer.rw,
-			rngBufferRW: pb.rngBuffer.rw,
-			hitBufferRO: pb.hitBuffer.ro,
+			hitBufferRW: pb.hitBuffer.rw,
 			counters,
 			activeIndicesRO: this._sortMaterials ? qm.getSortedRO() : qm.getActiveReadRO(),
 			envTexture: freshEnvTex,
@@ -1510,6 +1612,10 @@ export class PathTracer extends PathTracerStage {
 			maxRayCount: this._wfMaxRayCount,
 			chunkRowBase: this._wfChunkRowBase,
 			auxGBufferEnabled: this._auxGBufferUniform,
+			hasSun: this.hasSun,
+			sunDirection: this.sunDirection,
+			sunRadiance: this.sunRadiance,
+			sunParams: this.sunParams,
 		} );
 		this._kernelManager.register( 'shade',
 			shadeFn().compute(
@@ -1643,9 +1749,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,