rayzee 11.2.1 → 11.4.0

package/src/TSL/patches.js

@@ -147,6 +147,90 @@ export function uploadStorageChunks( renderer, attr, chunks ) {
 
 }
 
+/**
+ * GPU-only storage attributes standing for one array too large for a single binding: lane l lives in part
+ * ⌊l / lanesPerPart⌋, and a part holds whole records, so no record straddles two. Read through `splitStorage`
+ * (TSL/Common.js).
+ */
+export class StorageParts {
+
+	/**
+	 * @param {number} totalLanes
+	 * @param {number} lanesPerRecord
+	 * @param {number} maxPartBytes - at most maxStorageBufferBindingSize
+	 * @param {Function} [LaneType]
+	 * @param {number} [itemSize] - lanes an element: 4 for vec4 storage, 2 for vec2
+	 */
+	constructor( totalLanes, lanesPerRecord, maxPartBytes, LaneType = Float32Array, itemSize = 4 ) {
+
+		this.LaneType = LaneType;
+		this.itemSize = itemSize;
+		this.lanesPerPart = Math.max( 1, Math.floor( maxPartBytes / ( lanesPerRecord * LaneType.BYTES_PER_ELEMENT ) ) ) * lanesPerRecord;
+		this.totalLanes = totalLanes;
+		this.attrs = [];
+		for ( let at = 0; at < totalLanes || this.attrs.length === 0; at += this.lanesPerPart ) {
+
+			const lanes = Math.max( lanesPerRecord, Math.min( this.lanesPerPart, totalLanes - at ) );
+			this.attrs.push( gpuOnlyStorageAttribute( lanes / itemSize, itemSize, LaneType ) );
+
+		}
+
+	}
+
+	/** Elements a full part holds. */
+	get elementsPerPart() {
+
+		return this.lanesPerPart / this.itemSize;
+
+	}
+
+	/** Creates every part's GPU buffer now. */
+	create( backend ) {
+
+		for ( const attr of this.attrs ) backend.createStorageAttribute( attr );
+
+	}
+
+	/** Writes `count` lanes of `src` from `srcOffset` to lane `lane`, across a part boundary if need be. */
+	write( backend, lane, src, srcOffset, count ) {
+
+		const bytes = this.LaneType.BYTES_PER_ELEMENT;
+		while ( count > 0 ) {
+
+			const p = Math.floor( lane / this.lanesPerPart );
+			const local = lane - p * this.lanesPerPart;
+			const n = Math.min( count, this.lanesPerPart - local );
+			const attr = this.attrs[ p ];
+			backend.createStorageAttribute( attr );
+			backend.device.queue.writeBuffer( backend.get( attr ).buffer, local * bytes, src, srcOffset, n );
+			lane += n;
+			srcOffset += n;
+			count -= n;
+
+		}
+
+	}
+
+	/** Writes lanes [startLane, startLane + laneCount) of chunked `records`. */
+	writeRecords( backend, records, startLane, laneCount ) {
+
+		const lanesPerChunk = records.recordsPerChunk * records.lanesPerRecord;
+		for ( let lane = startLane, end = startLane + laneCount; lane < end; ) {
+
+			const ci = Math.floor( lane / lanesPerChunk );
+			const chunk = records.chunks[ ci ];
+			if ( ! chunk ) throw new Error( `chunk ${ci} is on disk and was never uploaded` );
+			const local = lane - ci * lanesPerChunk;
+			const n = Math.min( chunk.length - local, end - lane );
+			this.write( backend, lane, chunk, local, n );
+			lane += n;
+
+		}
+
+	}
+
+}
+
 /**
  * Re-upload one lane range of a chunked storage attribute, spanning chunks as needed.
  *

package/src/index.js

@@ -68,6 +68,7 @@ export {
 } from './Stages/DenoiserSettings.js';
 export { SKY_DEFAULTS, DEFAULT_SUN_PATH } from './managers/EnvironmentManager.js';
 export { AUTO_EXPOSURE_DEFAULTS } from './Stages/AutoExposure.js';
+export { LOCAL_EXPOSURE_DEFAULTS } from './Stages/LocalExposure.js';
 export { AUTO_FOCUS_DEFAULTS } from './managers/CameraManager.js';
 export { TRIANGLE_DATA_LAYOUT, BVH_LEAF_MARKERS } from './Processor/BufferLayout.js';
 export { sunPosition, timeForSunElevation, dayOfYearForMonth } from './Processor/SunPosition.js';

package/src/integrators/BidirectionalIntegrator.js

@@ -13,7 +13,7 @@ import { LIGHT_FLOATS } from '../managers/UniformManager.js';
 import { HIT_STRIDE_BIDIRECTIONAL, LIGHT_VERTEX_STRIDE, freeStorageAttribute } from '../Processor/PackedRayBuffer.js';
 import { COUNTER, ENERGY_SCALE } from '../Processor/QueueManager.js';
 import { CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
-import { BVH_MAX_INDEX } from '../Processor/BufferLayout.js';
+import { BVH_MAX_INDEX, BVH_LEAF_MARKERS, CLUSTER_COUNT_SHIFT, CLUSTER_COPY_HIDDEN } from '../Processor/BufferLayout.js';
 import { BOUNCE_KERNELS, LIST_WG_SIZE } from '../Stages/PathTracer.js';
 import { buildLightGenerateKernel, LIGHT_GENERATE_WG_SIZE } from '../TSL/LightGenerateKernel.js';
 import { buildGuideKernel, buildGuideClearKernel, guidedDiscPdf, recordEscape, GUIDE_BINS, GUIDE_ROW_STRIDE, GUIDE_TEXTURE_WIDTH } from '../TSL/LightGuide.js';
@@ -652,6 +652,14 @@ export class BidirectionalIntegrator {
 		const records = this.pt._bvhRecords;
 		const flat = records ? null : this.pt.bvhStorageAttr?.array;
 		if ( ! records && ! ( flat?.length >= 16 ) ) return null;
+		// A spilled TLAS comes back for the next frame's disc.
+		const blasBase = this.pt._instanceTable?.blasBase ?? 1;
+		if ( records && ! records.isResident( 0, blasBase ) ) {
+
+			this.pt._whenTLASResident( () => {} );
+			return null;
+
+		}
 
 		const view = ( f ) => {
 
@@ -668,6 +676,16 @@ export class BidirectionalIntegrator {
 
 		};
 
+		// A copy cluster is visible while any of its copies is (BufferLayout CLUSTER_LEAF).
+		const leafVisible = ( n ) => {
+
+			if ( n.u[ n.o + 3 ] !== BVH_LEAF_MARKERS.CLUSTER_LEAF ) return n.f[ n.o + 2 ] !== 0;
+			const count = ( ( n.u[ n.o ] >>> CLUSTER_COUNT_SHIFT ) & 3 ) + 1;
+			for ( let k = 0; k < count; k ++ ) if ( ! ( n.u[ n.o + 12 + k ] & CLUSTER_COPY_HIDDEN ) ) return true;
+			return false;
+
+		};
+
 		const root = node( 0 );
 		if ( root.u[ root.o + 3 ] >= BVH_MAX_INDEX ) return null;
 		// A tree that reaches a node twice is malformed; no search visits more nodes than the tree holds.
@@ -699,7 +717,7 @@ export class BidirectionalIntegrator {
 				const n = node( index );
 				if ( n.u[ n.o + 3 ] >= BVH_MAX_INDEX ) {
 
-					if ( n.f[ n.o + 2 ] !== 0 ) best = s;
+					if ( leafVisible( n ) ) best = s;
 
 				} else push( n );
 

package/src/managers/DenoisingManager.js

@@ -104,9 +104,10 @@ export class DenoisingManager extends EventDispatcher {
 	 * @param {import('../Pipeline/RenderPipeline.js').RenderPipeline} params.pipeline
 	 * @param {Function}                               params.getExposure       - () => current exposure value
 	 * @param {Function}                               params.getSaturation     - () => current saturation value
+	 * @param {Function}                               [params.getDisplayGain]  - () => the shown picture's per-pixel gain (PackedToneMapper `gain`)
 	 * @param {import('../EngineIssues.js').IssueLog}  [params.issues]
 	 */
-	constructor( { renderer, mainCanvas, stages, pipeline, getExposure, getSaturation, issues = null } ) {
+	constructor( { renderer, mainCanvas, stages, pipeline, getExposure, getSaturation, getDisplayGain = null, issues = null } ) {
 
 		super();
 
@@ -121,6 +122,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		this._getExposure = getExposure;
 		this._getSaturation = getSaturation;
+		this._getDisplayGain = getDisplayGain;
 
 		this.denoiser = null;
 		this.upscaler = null;
@@ -409,6 +411,7 @@ export class DenoisingManager extends EventDispatcher {
 			getExposure: () => this._getEffectiveExposure(),
 			getToneMapping: () => this._getToneMapping(),
 			getSaturation: () => this._getSaturation(),
+			getDisplayGain: () => this._getDisplayGain?.() ?? null,
 		} );
 
 		this.upscaler.enabled = DENOISER_DEFAULTS.enableUpscaler || false;
@@ -546,21 +549,11 @@ export class DenoisingManager extends EventDispatcher {
 
 	/**
 	 * @param {boolean} enabled
-	 * @param {number}  manualExposure - Restored to renderer.toneMappingExposure when disabling.
+	 * @param {number}  manualExposure - the compensation while on, the exposure again once off
 	 */
 	setAutoExposureEnabled( enabled, manualExposure ) {
 
-		const s = this._stages;
-		if ( ! s.autoExposure ) return;
-
-		s.autoExposure.enabled = enabled;
-
-		// AutoExposure overwrites renderer.toneMappingExposure each frame; restore manual on disable.
-		if ( ! enabled && this.renderer ) {
-
-			this.renderer.toneMappingExposure = manualExposure;
-
-		}
+		this._stages.autoExposure?.setEnabled( enabled, manualExposure );
 
 	}
 
@@ -988,10 +981,10 @@ export class DenoisingManager extends EventDispatcher {
 	 * @param {Float32Array} world - the placement matrix pool
 	 * @param {number} offset - where this placement's matrix starts in it
 	 */
-	notePlacementMoving( leaf, world, offset ) {
+	notePlacementMoving( leaf, matrixOf ) {
 
 		if ( leaf < 0 || ! this.historyActive || this._movedPlacements.has( leaf ) ) return;
-		this._movedPlacements.set( leaf, { world, offset, prev: world.slice( offset, offset + 16 ) } );
+		this._movedPlacements.set( leaf, { matrixOf, prev: matrixOf().slice() } );
 
 	}
 
@@ -1013,8 +1006,8 @@ export class DenoisingManager extends EventDispatcher {
 		const leaves = [ ...moved.keys() ].sort( ( a, b ) => a - b );
 		for ( let i = 0; i < leaves.length; i ++ ) {
 
-			const { world, offset, prev } = moved.get( leaves[ i ] );
-			this._matB.fromArray( world, offset ).invert();
+			const { matrixOf, prev } = moved.get( leaves[ i ] );
+			this._matB.fromArray( matrixOf() ).invert();
 			this._matA.fromArray( prev ).multiply( this._matB ).toArray( upload.toPrev, i * 16 );
 			upload.leaves[ i ] = leaves[ i ];
 
@@ -1246,6 +1239,7 @@ export class DenoisingManager extends EventDispatcher {
 				exposure: this._getEffectiveExposure(),
 				toneMapping: this._getToneMapping(),
 				saturation: this._getSaturation?.() ?? 1,
+				gain: this._getDisplayGain?.() ?? null,
 			};
 
 			// Scene-referred throughout. Exposure reaches the detail pass through its own `paper_white`
@@ -1561,6 +1555,9 @@ export class DenoisingManager extends EventDispatcher {
 		this._onReset = null;
 		this._onPostProcessRefresh = null;
 		this._onDisplayRefresh = null;
+		this._getExposure = null;
+		this._getSaturation = null;
+		this._getDisplayGain = null;
 		this._issues = null;
 
 		if ( this.upscalerCanvas?.parentNode ) {
@@ -1764,13 +1761,12 @@ export class DenoisingManager extends EventDispatcher {
 	// ── Convenience (match DenoisingAPI names with reset) ────────
 
 	/**
-	 * Enables or disables auto-exposure (convenience wrapper).
+	 * Enables or disables auto-exposure. A finished render is metered as it stands, not restarted.
 	 * @param {boolean} enabled
 	 */
 	setAutoExposure( enabled ) {
 
 		this.setAutoExposureEnabled( enabled, this._getExposure() );
-		this._onReset?.();
 
 	}
 

package/src/managers/InteractionManager.js

@@ -38,12 +38,13 @@ export function focusDistanceOfHit( hit, camera, panorama = false ) {
  */
 export class InteractionManager extends EventDispatcher {
 
-	constructor( { scene, camera, canvas, assetLoader, pathTracer, floorPlane } ) {
+	constructor( { scene, camera, canvas, assetLoader, pathTracer, floorPlane, isGeometryOnDisk = null } ) {
 
 		super();
 
 		// Core dependencies
 		this.scene = scene;
+		this.isGeometryOnDisk = isGeometryOnDisk;
 		this.camera = camera;
 		this.canvas = canvas;
 		this.assetLoader = assetLoader;
@@ -125,7 +126,8 @@ export class InteractionManager extends EventDispatcher {
 	select( object ) {
 
 		const outline = this._overlayManager?.getHelper( 'outline' );
-		if ( outline ) outline.setSelectedObjects( object ? [ object ] : [] );
+		// A spilled model's geometry is on disk: there is nothing to draw the outline from.
+		if ( outline ) outline.setSelectedObjects( object && ! this.isGeometryOnDisk?.() ? [ object ] : [] );
 
 		this.selectedObject = object || null;
 
@@ -221,7 +223,7 @@ export class InteractionManager extends EventDispatcher {
 		const mouseCoords = this.getMouseCoordinates( event );
 		this.raycaster.setFromCamera( mouseCoords, this.camera );
 
-		const intersects = this.raycaster.intersectObjects( this.scene.children, true );
+		const intersects = this._intersectScene();
 
 		if ( intersects.length > 0 ) {
 
@@ -490,7 +492,7 @@ export class InteractionManager extends EventDispatcher {
 			const mouseCoords = this.getMouseCoordinates( event );
 			this.raycaster.setFromCamera( mouseCoords, this.camera );
 
-			const intersects = this.raycaster.intersectObjects( this.scene.children, true );
+			const intersects = this._intersectScene();
 			const validIntersects = this.filterValidIntersects( intersects );
 			const lightHit = this._pickLightHelper();
 
@@ -576,7 +578,7 @@ export class InteractionManager extends EventDispatcher {
 		const mouseCoords = this.getMouseCoordinates( event );
 		this.raycaster.setFromCamera( mouseCoords, this.camera );
 
-		const intersects = this.raycaster.intersectObjects( this.scene.children, true );
+		const intersects = this._intersectScene();
 		const validIntersects = this.filterValidIntersects( intersects );
 
 		if ( validIntersects.length > 0 ) {
@@ -695,11 +697,22 @@ export class InteractionManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * The scene under the raycaster. Nothing while a spilled model's geometry is on disk: its arrays are empty, and
+	 * testing tens of millions of empty copies held the page for seconds a pick.
+	 * @private
+	 */
+	_intersectScene() {
+
+		return this.isGeometryOnDisk?.() ? [] : this.raycaster.intersectObjects( this.scene.children, true );
+
+	}
+
 	/** The nearest scene surface under an NDC point, skipping the floor and helpers. */
 	pickSurface( ndcX, ndcY ) {
 
 		this.raycaster.setFromCamera( { x: ndcX, y: ndcY }, this.camera );
-		return this.filterValidIntersects( this.raycaster.intersectObjects( this.scene.children, true ) )[ 0 ] ?? null;
+		return this.filterValidIntersects( this._intersectScene() )[ 0 ] ?? null;
 
 	}
 

package/src/managers/MaterialDataManager.js

@@ -173,8 +173,17 @@ export class MaterialDataManager {
 		this._convertColorsToWorkingSpace( matImageData );
 
 		const vec4Count = matImageData.length / 4;
+		this.materialCount = Math.floor( vec4Count / PIXELS_PER_MATERIAL );
+
+		// The owning stage keeps materials at the front of its scene data buffer, the light data behind them: one
+		// binding for both, which the shading kernel's ten could not spare.
+		const shared = this.callbacks.adoptMaterials?.( matImageData );
+		if ( shared ) {
 
-		if ( this.materialStorageNode ) {
+			this.materialStorageAttr = shared.attr;
+			this.materialStorageNode = shared.node;
+
+		} else if ( this.materialStorageNode ) {
 
 			this.materialStorageAttr = new StorageInstancedBufferAttribute( matImageData, 4 );
 			this.materialStorageNode.value = this.materialStorageAttr;
@@ -187,7 +196,6 @@ export class MaterialDataManager {
 
 		}
 
-		this.materialCount = Math.floor( vec4Count / PIXELS_PER_MATERIAL );
 		this._sources = [ ...sources ];
 		this._hostSet = [];
 		this.callbacks.onMaterialFeaturesChanged?.();
@@ -195,6 +203,15 @@ export class MaterialDataManager {
 
 	}
 
+	/** Sends the materials to the GPU: only their region when the buffer carries the light data too. @private */
+	_uploadMaterials() {
+
+		const attr = this.materialStorageAttr;
+		if ( this.callbacks.adoptMaterials ) attr.addUpdateRange( 0, this.materialCount * PIXELS_PER_MATERIAL * 4 );
+		attr.needsUpdate = true;
+
+	}
+
 	/**
 	 * Get the material storage attribute (for dependent stages).
 	 * @returns {StorageInstancedBufferAttribute|null}
@@ -538,7 +555,7 @@ export class MaterialDataManager {
 
 		}
 
-		this.materialStorageAttr.needsUpdate = true;
+		this._uploadMaterials();
 		( this._hostSet[ materialIndex ] ??= new Map() ).set( property, toPortable( value ) );
 
 		// Recompute triangle-data opaque-blocker flag when any input to it changes.
@@ -588,7 +605,7 @@ export class MaterialDataManager {
 		this._recomputeOpaqueBlockerForMaterial( materialIndex );
 		this.callbacks.onMaterialFeaturesChanged?.();
 
-		this.materialStorageAttr.needsUpdate = true;
+		this._uploadMaterials();
 		this._notifyReset();
 
 	}
@@ -668,7 +685,7 @@ export class MaterialDataManager {
 
 		}
 
-		this.materialStorageAttr.needsUpdate = true;
+		this._uploadMaterials();
 		this._notifyReset();
 
 	}

package/src/managers/UniformManager.js

@@ -333,6 +333,9 @@ export class UniformManager {
 		u( 'emissiveTriangleCount', 0, 'int' );
 		u( 'emissiveTotalPower', 0.0, 'float' );
 		u( 'lightBVHNodeCount', 0, 'int' );
+		// Where the light data starts in the scene data buffer, after the materials (vec4 elements). Every light read
+		// adds it; the offsets below are within the light data.
+		u( 'lightVec4Offset', 0, 'int' );
 		// Offset (in vec4 elements) within the packed light buffer where emissive
 		// triangle data starts. Equals lightBVHNodeCount * LBVH_STRIDE; computed on upload.
 		u( 'emissiveVec4Offset', 0, 'int' );

package/src/managers/VideoRenderManager.js

@@ -87,8 +87,13 @@ export class VideoRenderManager {
 		// Configure for high-quality offline rendering
 		app.configureForMode( 'production' );
 
-		// Override samples per frame
-		app.settings.setMany( { maxSamples: samplesPerFrame }, { silent: true } );
+		// Auto exposure adapts in video time, once a frame, not to each pass's wall clock.
+		const autoExposure = app.stages.autoExposure?.enabled ? app.stages.autoExposure : null;
+		if ( autoExposure ) autoExposure.instant = false;
+
+		// Override samples per frame. 'frames': this loop never checks the deadline, so a 'timeOnly'
+		// ceiling of Infinity would never finish a frame.
+		app.settings.setMany( { maxSamples: samplesPerFrame, renderLimitMode: 'frames' }, { silent: true, reset: false } );
 		app.stages.pathTracer?.updateCompletionThreshold?.();
 
 		// Disable camera controls during render
@@ -131,11 +136,23 @@ export class VideoRenderManager {
 				// kill it immediately so it doesn't race with our manual render loop
 				app.stopAnimation();
 
+				// Before accumulating: the stage meters as it goes, and a reading of this frame's view filed under the last
+				// one read as a scene change, moving the room the whole way each frame.
+				if ( autoExposure ) app._noteExposureView();
+
 				// 3. Accumulate samples until convergence
 				await this._accumulateFrame( app );
 
 				if ( this._cancelled ) break;
 
+				if ( autoExposure ) {
+
+					await autoExposure.meter( app.pipeline.context );
+					autoExposure.advance( i === Math.max( 0, startFrame ) ? Infinity : frameDuration );
+					app._presentDisplay();
+
+				}
+
 				// 4. Denoise if enabled
 				if ( enableOIDN && app.denoisingManager?.finalDenoise ) {
 
@@ -298,17 +315,19 @@ export class VideoRenderManager {
 
 		const app = this._app;
 		const effective = app.settings.getEffective();
-		const keys = Object.keys( modePresetSettings( PRODUCTION_RENDER_CONFIG ) );
+		const keys = [ ...Object.keys( modePresetSettings( PRODUCTION_RENDER_CONFIG ) ), 'renderLimitMode' ];
 		if ( view ) keys.push( 'focusDistance' );
 
 		return {
 			view: view ? app.cameraManager.captureView() : null,
-			// Everything configureForMode( 'production' ) overwrites, with who set it.
+			// Everything configureForMode( 'production' ) and the export overwrite, with who set it.
 			settings: keys.map( key => [ key, effective[ key ] ] ),
 			renderMode: app.stages.pathTracer?.renderMode?.value,
 			controlsEnabled: app.cameraManager.controls?.enabled,
 			oidnEnabled: app.denoisingManager?.finalDenoise,
 			oidnQuality: app.denoisingManager?.oidnQuality,
+			instantExposure: app.stages.autoExposure?.instant,
+			holdExposureSamples: app.stages.autoExposure?.holdSamples,
 			wasPlaying: app.animationManager?.isPlaying,
 			pauseRendering: app.pauseRendering,
 		};
@@ -347,6 +366,13 @@ export class VideoRenderManager {
 		}
 
 		app.pauseRendering = state.pauseRendering ?? false;
+		if ( app.stages.autoExposure ) {
+
+			app.stages.autoExposure.instant = state.instantExposure ?? false;
+			// configureForMode( 'production' ) set it, and nothing switches the mode back: left on, it froze the exposure while orbiting.
+			app.stages.autoExposure.holdSamples = state.holdExposureSamples ?? 0;
+
+		}
 
 		if ( state.view ) app.cameraManager.applyPose( state.view );
 

package/src/neural/NeuralRetouch.js

@@ -389,6 +389,7 @@ export class NeuralRetouch {
 			exposure: tone.exposure ?? 1,
 			toneMapping: tone.toneMapping ?? 0,
 			saturation: tone.saturation ?? 1,
+			gain: tone.gain,
 		} );
 
 		return { rgba8, width: w, height: h };

package/src/neural/NeuralSuperRes.js

@@ -373,6 +373,7 @@ export class NeuralSuperRes {
 			exposure: tone.exposure ?? 1,
 			toneMapping: tone.toneMapping ?? 0,
 			saturation: tone.saturation ?? 1,
+			gain: tone.gain,
 			// The network emits its picture vertically flipped.
 			flipY: true,
 		} );
@@ -482,6 +483,7 @@ export async function renderUpscaled( app, {
 		width: pathTracer?.width,
 		height: pathTracer?.height,
 		maxSamples: app.settings?.get?.( 'maxSamples' ),
+		renderLimitMode: app.settings?.get?.( 'renderLimitMode' ),
 		finalDenoise: app.denoisingManager?.finalDenoise,
 		paused: app.pauseRendering,
 	};
@@ -512,7 +514,8 @@ export async function renderUpscaled( app, {
 		await new Promise( r => setTimeout( r, 300 ) );
 
 		app.denoisingManager.applyOIDNEnabled( true );
-		app.settings.set( 'maxSamples', samples );
+		// 'frames': under 'timeOnly' the deadline, not `samples`, would end the render.
+		app.settings.setMany( { maxSamples: samples, renderLimitMode: 'frames' }, { reset: false } );
 		const done = waitForDenoise( app, samples, timeoutMs );
 		app.reset();
 		await done;
@@ -529,6 +532,7 @@ export async function renderUpscaled( app, {
 			exposure: app.renderer.toneMappingExposure,
 			toneMapping: app.renderer.toneMapping,
 			saturation: app.settings.get( 'saturation' ) ?? 1,
+			gain: app._displayGain?.() ?? null,
 		};
 
 		const { rgba8, width, height, ms, toneMs } = await sr.upscaleToRGBA8( source, tone );
@@ -550,6 +554,7 @@ export async function renderUpscaled( app, {
 
 		if ( restore.width && restore.height ) app.setCanvasSize( restore.width, restore.height );
 		if ( restore.maxSamples !== undefined ) app.settings?.set?.( 'maxSamples', restore.maxSamples );
+		if ( restore.renderLimitMode !== undefined ) app.settings?.set?.( 'renderLimitMode', restore.renderLimitMode, { reset: false } );
 		if ( restore.finalDenoise !== undefined ) app.denoisingManager?.applyOIDNEnabled( restore.finalDenoise );
 		app.pauseRendering = restore.paused;