rayzee 11.3.0 → 11.4.0

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 );
 
 	}
 
@@ -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/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;