rayzee 11.5.0 → 11.7.0

package/src/TSL/FinalWriteKernel.js

@@ -48,7 +48,7 @@ export function buildFinalWriteKernel( params ) {
 		// on): when off, skip the G-buffer decode, the prev-frame aux mix, and the two aux stores.
 		auxGBufferEnabled, gBuffer = true, // compiled in only when requested (PathTracer.requestOutput( 'gBuffer' ))
 		// Clean-aux normal (1 = temporally accumulate + renormalize the aux normal). On only for clean-aux
-		// OIDN models (calb_cnrm/high, alb_nrm/balanced); off for fast/ASVGF which want the bump normal.
+		// OIDN models (calb_cnrm/high, alb_nrm/balanced); off otherwise, as the fast model wants the bump normal.
 		cleanAuxNormalEnabled,
 		// Tier-1 convergence early-stop: per-pixel Welford luminance second moment + converged bit (stamped
 		// into streak bit 31; counted with 3×3 erosion by countConvergedDilated at the next frame start).
@@ -126,7 +126,7 @@ export function buildFinalWriteKernel( params ) {
 					finalHitDist.assign( mix( prevAlbedoSample.w, finalHitDist, auxAccumulationAlpha ) );
 
 					// NORMAL: by default keep this frame's POINT-SAMPLED normal — it varies with the bump,
-					// which fast/ASVGF want to preserve edge detail. But a CLEAN-AUX OIDN model (calb_cnrm/high,
+					// which the fast model wants to preserve edge detail. But a CLEAN-AUX OIDN model (calb_cnrm/high,
 					// alb_nrm/balanced) trusts the aux and is fed per-frame point-sampled NOISE → leaked noise
 					// (high) / over-smoothing (balanced). When cleanAuxNormalOn, temporally accumulate it like
 					// the colour. Average the RAW unit normals (decode 0.5+0.5 → [-1,1]) and RENORMALIZE — a

package/src/TSL/ShadeKernel.js

@@ -125,7 +125,7 @@ export function buildShadeKernel( params ) {
 		emissiveBoost, enableEmissiveTriangleSampling,
 		lightBVHNodeCount, reverseMapVec4Offset,
 		maxRayCount,
-		// Aux G-buffer (normal/depth/albedo + surface ID) feeds only the denoiser/OIDN MRT. Compiled in only when
+		// Aux G-buffer (normal/depth/albedo) feeds only the denoiser/OIDN MRT. Compiled in only when
 		// requested (PathTracer.requestOutput( 'gBuffer' )); then a live uniform (1 = denoiser on) skips the writes
 		// while nothing consumes them.
 		auxGBufferEnabled, gBuffer = true,
@@ -289,7 +289,7 @@ export function buildShadeKernel( params ) {
 		// This bounce's block of sampler dimensions — see the budget table in Random.js.
 		const dimBase = int( currentBounce ).mul( int( SAMPLER_DIMS_PER_BOUNCE ) );
 
-		// DDFA see-through aux tint carried across smooth glass/mirror; committed into the OIDN/ASVGF
+		// DDFA see-through aux tint carried across smooth glass/mirror; committed into the OIDN/NRD
 		// albedo guide at the first diffuse-enough surface (or env). Mutated locally, persisted on every
 		// deferring continue (a missed persist = stale tint). 1 = untinted (direct hit → today's albedo).
 		const featCarry = aux ? readFeatureThroughput( rayBufferRW, rayID ).toVar() : null;
@@ -424,7 +424,7 @@ export function buildShadeKernel( params ) {
 
 					// The catcher is a real ground surface for the denoiser — write the plane's normal/depth
 					// + a neutral albedo (black albedo would break OIDN demodulation) and mark the pixel a
-					// valid surface, so OIDN/ASVGF don't smear the caught shadow as a background miss.
+					// valid surface, so OIDN/NRD don't smear the caught shadow as a background miss.
 					if ( aux ) If( aux, () => {
 
 						const planeDepth = computeNDCDepth( { worldPos: planePoint, cameraProjectionMatrix, cameraViewMatrix } );

package/src/index.js

@@ -63,7 +63,7 @@ export {
 } from './EngineDefaults.js';
 export { MAX_RESERVABLE_RENDER_SIZE } from './Processor/StorageTexturePool.js';
 export {
-	DENOISER_DEFAULTS, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS, NRD_HIT_DIST_A,
+	DENOISER_DEFAULTS, DENOISER_STRATEGIES, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS, NRD_HIT_DIST_A,
 	NRD_HIT_DIST_B,
 } from './Stages/DenoiserSettings.js';
 export { SKY_DEFAULTS, DEFAULT_SUN_PATH } from './managers/EnvironmentManager.js';

package/src/managers/DenoisingManager.js

@@ -11,7 +11,7 @@ import { createLogger } from '../utils/Logger.js';
 const neuralLog = createLogger( 'neural' );
 import { CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
 import {
-	DENOISER_DEFAULTS, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS,
+	DENOISER_DEFAULTS, DENOISER_STRATEGIES, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS,
 } from '../Stages/DenoiserSettings.js';
 
 // A refresh slower than this is a slideshow, not a live view, so the cadence swaps to a cheaper
@@ -85,7 +85,7 @@ const historyFade = ( samples ) => Math.max( 0, 1 - samples / HISTORY_HANDOFF_SA
 
 /**
  * Orchestrates all denoising, post-processing, and AI upscaling:
- *   - Real-time denoiser strategy switching (ASVGF / NRD / EdgeAware / None)
+ *   - Real-time denoiser strategy switching (OIDN / NRD / None)
  *   - OIDN (offline denoise on render completion)
  *   - AI Upscaler
  *   - Auto-exposure coordination
@@ -118,7 +118,7 @@ export class DenoisingManager extends EventDispatcher {
 		this.pipeline = pipeline;
 
 		// Stage references — only used internally for orchestration
-		this._stages = stages; // { pathTracer, asvgf, nrd, variance, bilateralFilter, edgeFilter, autoExposure, compositor }
+		this._stages = stages; // { pathTracer, normalDepth, motionVector, nrd, autoExposure, compositor }
 
 		this._getExposure = getExposure;
 		this._getSaturation = getSaturation;
@@ -197,6 +197,7 @@ export class DenoisingManager extends EventDispatcher {
 		this._denoiserEndHandler = null;
 		this._denoiserTileHandler = null;
 		this._denoiserErrorHandler = null;
+		this._denoiserLoadHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;
@@ -348,7 +349,9 @@ export class DenoisingManager extends EventDispatcher {
 			this.dispatchEvent( { type: EngineEvents.DENOISING_START, continuous: !! e.continuous } );
 		this._denoiserEndHandler = e => {
 
-			if ( this.denoiser?.hasOutput ) this._publishOutput();
+			// A refresh that lands after the live view stopped wanting one would cover what replaced it.
+			const current = ! e.continuous || ( this.continuousDenoise && ! this._cadenceSuspended );
+			if ( this.denoiser?.hasOutput && current ) this._publishOutput();
 			this.dispatchEvent( { type: EngineEvents.DENOISING_END, continuous: !! e.continuous } );
 
 		};
@@ -377,6 +380,12 @@ export class DenoisingManager extends EventDispatcher {
 		this.denoiser.addEventListener( 'tileProgress', this._denoiserTileHandler );
 		this.denoiser.addEventListener( 'error', this._denoiserErrorHandler );
 
+		// 'error' too: a failed load never sends 'loaded'. The first load starts inside the constructor, before these listen.
+		this._denoiserLoadHandler = e =>
+			this.dispatchEvent( { type: EngineEvents.DENOISER_LOADING, loading: e.type === 'loading' } );
+		for ( const type of [ 'loading', 'loaded', 'error' ] ) this.denoiser.addEventListener( type, this._denoiserLoadHandler );
+		if ( this.denoiser.state?.isLoading ) this.dispatchEvent( { type: EngineEvents.DENOISER_LOADING, loading: true } );
+
 	}
 
 	/**
@@ -440,9 +449,8 @@ export class DenoisingManager extends EventDispatcher {
 	// ── Denoiser Strategy ─────────────────────────────────────────
 
 	/**
-	 * Active real-time denoiser, derived from stage state so it can't drift from
-	 * setDenoiserStrategy / setASVGFEnabled.
-	 * @returns {'asvgf'|'nrd'|'edgeaware'|'none'}
+	 * Active real-time denoiser, derived from stage state so it can't drift from setDenoiserStrategy.
+	 * @returns {'none'|'nrd'|'oidn'}
 	 */
 	get denoiserStrategy() {
 
@@ -450,105 +458,55 @@ export class DenoisingManager extends EventDispatcher {
 		// belongs in the same one-of-N choice. Two of these running at once would mean paying for
 		// a per-frame denoise whose result the OIDN overlay then covers.
 		if ( this.continuousDenoise ) return 'oidn';
-		if ( this._stages.asvgf?.enabled ) return 'asvgf';
 		if ( this._stages.nrd?.enabled ) return 'nrd';
-		if ( this._stages.edgeFilter?.enabled ) return 'edgeaware';
 		return 'none';
 
 	}
 
 	/**
 	 * Switches the real-time denoiser strategy.
-	 * @param {string} strategy - 'none' | 'asvgf' | 'nrd' | 'edgeaware'
-	 * @param {string} [preset] - quality preset for 'asvgf' (ASVGF_QUALITY_PRESETS) or 'nrd' (NRD_QUALITY_PRESETS)
+	 * @param {string} strategy - one of DENOISER_STRATEGIES; any other name is recorded and runs 'none'
+	 * @param {string} [preset] - NRD quality preset (NRD_QUALITY_PRESETS)
 	 */
 	setDenoiserStrategy( strategy, preset ) {
 
 		const s = this._stages;
 
-		// Disable all real-time denoisers first
-		if ( s.asvgf ) s.asvgf.enabled = false;
-		if ( s.nrd ) s.nrd.enabled = false;
-		if ( s.variance ) s.variance.enabled = false;
-		if ( s.bilateralFilter ) s.bilateralFilter.enabled = false;
-		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( false );
-
-		this._clearDenoiserTextures();
-
-		// Which denoiser owns the live view. Deliberately says nothing about the finished image:
-		// wanting OIDN on the viewport is not the same as opting into a final pass.
-		this.setContinuousDenoise( strategy === 'oidn' );
-
-		switch ( strategy ) {
+		if ( ! DENOISER_STRATEGIES.includes( strategy ) ) {
 
-			case 'asvgf':
-				s.asvgf.enabled = true;
-				if ( s.variance ) s.variance.enabled = true;
-				if ( s.bilateralFilter ) s.bilateralFilter.enabled = true;
-				s.asvgf.setTemporalEnabled?.( true );
-				this._applyASVGFPreset( preset || 'medium' );
-				break;
+			this._issues?.record(
+				ISSUE_CODES.DENOISER_UNAVAILABLE,
+				`'${strategy}' is not a live denoiser (${DENOISER_STRATEGIES.join( ', ' )}) — none is used`,
+				{ strategy }
+			);
+			strategy = 'none';
 
-			case 'nrd':
-				if ( s.nrd ) {
-
-					s.nrd.enabled = true;
-					// Stale history from the last time it ran describes another view.
-					s.nrd.resetHistory?.();
-					this._applyNRDPreset( preset || 'medium' );
-
-				}
+		}
 
-				break;
+		// NRD reprojects through motion vectors, which mean nothing once every pixel is its own direction.
+		if ( strategy === 'nrd' && this._isPanorama() ) {
 
-			case 'edgeaware':
-				// EdgeAware is a spatial-only SVGF à-trous — it consumes the Variance
-				// stage's per-pixel variance to drive its luminance edge-stop.
-				if ( s.variance ) s.variance.enabled = true;
-				if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( true );
-				break;
+			this._issues?.record( ISSUE_CODES.DENOISER_UNAVAILABLE, 'NRD cannot run in a panorama — oidn is used', { strategy } );
+			strategy = 'oidn';
 
 		}
 
-		this._syncGBufferStages();
-
-	}
-
-	/**
-	 * Enables/disables ASVGF denoising with coordination of related stages.
-	 * @param {boolean} enabled
-	 * @param {string}  [qualityPreset]
-	 */
-	setASVGFEnabled( enabled, qualityPreset ) {
+		this._clearDenoiserTextures();
 
-		const s = this._stages;
-		if ( s.asvgf ) s.asvgf.enabled = enabled;
-		if ( s.variance ) s.variance.enabled = enabled;
-		if ( s.bilateralFilter ) s.bilateralFilter.enabled = enabled;
+		if ( s.nrd ) s.nrd.enabled = strategy === 'nrd';
 
-		if ( enabled ) {
+		if ( s.nrd?.enabled ) {
 
-			// One real-time denoiser at a time.
-			if ( s.nrd ) s.nrd.enabled = false;
-			s.asvgf?.setTemporalEnabled?.( true );
-			this._applyASVGFPreset( qualityPreset || 'medium' );
+			// Stale history from the last time it ran describes another view.
+			s.nrd.resetHistory?.();
+			this._applyNRDPreset( preset || 'medium' );
 
 		}
 
-		// Coordinate with EdgeAware filtering
-		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( ! enabled );
-
-		this._syncGBufferStages();
-
-	}
-
-	/**
-	 * Applies an ASVGF quality preset.
-	 * @param {string} presetName - 'low' | 'medium' | 'high'
-	 */
-	applyASVGFPreset( presetName ) {
-
-		this._applyASVGFPreset( presetName );
+		// Which denoiser owns the live view. Deliberately says nothing about the finished image:
+		// wanting OIDN on the viewport is not the same as opting into a final pass. Also re-syncs
+		// the G-buffer stages, so NRD must already be set.
+		this.setContinuousDenoise( strategy === 'oidn' );
 
 	}
 
@@ -562,6 +520,13 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
+	/** True while a strategy that reprojects through motion vectors is active. */
+	get requiresMotionVectors() {
+
+		return !! this._stages.nrd?.enabled;
+
+	}
+
 	/**
 	 * Gate the G-buffer stages (NormalDepth, MotionVector) on demand: they only
 	 * need to run when a real-time denoiser consumes their output. Idling them
@@ -569,17 +534,10 @@ export class DenoisingManager extends EventDispatcher {
 	 * navigation and frees their textures. Call after any consumer toggle.
 	 *
 	 * MotionVector requires NormalDepth (reads pathtracer:normalDepth) and its
-	 * consumers (ASVGF, NRD) are a subset of NormalDepth's, so NormalDepth is
-	 * always enabled whenever MotionVector is. Adaptive sampling / Variance / OIDN
-	 * do NOT read these signals, so they don't keep the G-buffer alive.
+	 * consumer (NRD) also reads NormalDepth, so NormalDepth is always enabled
+	 * whenever MotionVector is. Adaptive sampling and OIDN's own pass do NOT read
+	 * these signals; only OIDN's motion history keeps NormalDepth alive.
 	 */
-	/** True while a strategy that reprojects through motion vectors is active. */
-	get requiresMotionVectors() {
-
-		return !! ( this._stages.asvgf?.enabled || this._stages.nrd?.enabled );
-
-	}
-
 	_syncGBufferStages() {
 
 		const s = this._stages;
@@ -587,8 +545,8 @@ export class DenoisingManager extends EventDispatcher {
 		const mv = s.motionVector;
 
 		const motionNeeded = this.requiresMotionVectors;
-		// pathtracer:normalDepth consumed by ASVGF, NRD, EdgeFilter, BilateralFilter, the OIDN history
-		const normalNeeded = motionNeeded || this.historyWanted || !! ( s.edgeFilter?.enabled || s.bilateralFilter?.enabled );
+		// pathtracer:normalDepth consumed by NRD and the OIDN history
+		const normalNeeded = motionNeeded || this.historyWanted;
 		if ( ! this.historyWanted ) this._releaseHistory();
 
 		if ( nd ) {
@@ -605,21 +563,14 @@ export class DenoisingManager extends EventDispatcher {
 
 			// On re-enable, force a camera-history reseed (matricesInitialized survives
 			// normal resets) so the first frame reports zero motion, not a spike.
-			if ( motionNeeded && ! mv.enabled ) {
-
-				mv.matricesInitialized = false;
-				mv.isFirstFrame = true;
-				mv.frameCount = 0;
-
-			}
+			if ( motionNeeded && ! mv.enabled ) mv.matricesInitialized = false;
 
 			mv.enabled = motionNeeded;
 
 		}
 
-		// PathTracer's aux MRT (normalDepth + albedo) is consumed by the real-time denoisers (ASVGF/
-		// BilateralFilter read albedo; ASVGF/EdgeFilter read normalDepth) and by OIDN (reads the
-		// MRT read-targets directly). When none are active the wavefront skips those writes entirely.
+		// PathTracer's aux MRT (normalDepth + albedo) is consumed by NRD (albedo, hit distance) and by
+		// OIDN (reads the MRT read-targets directly). When neither is active the wavefront skips those writes.
 		s.pathTracer?.setAuxGBufferEnabled?.( normalNeeded || !! this.denoiser?.enabled );
 
 		// Clean-aux normal: temporally accumulate the aux normal only for OIDN clean-aux models
@@ -634,7 +585,7 @@ export class DenoisingManager extends EventDispatcher {
 		// disabled (lazily re-created on the next dispatch after re-enable). Every strategy/denoiser
 		// toggle funnels through here after the enabled flags above are settled, so this is the one
 		// choke point. dispose() is idempotent, so re-running it for an already-released stage is a no-op.
-		for ( const stage of [ s.asvgf, s.nrd, s.variance, s.bilateralFilter, s.edgeFilter, nd, mv ] ) {
+		for ( const stage of [ s.nrd, nd, mv ] ) {
 
 			if ( stage && ! stage.enabled ) stage.releaseGPUMemory?.();
 
@@ -842,21 +793,29 @@ export class DenoisingManager extends EventDispatcher {
 
 		this._cadenceSuspended = !! suspended;
 		this._historyDirty = true;
-		if ( ! this._cadenceSuspended ) return;
 
-		// The accumulation is what a final render shows; a held preview frame would otherwise sit
-		// over it until the render finished.
-		this.denoiser?.abort();
-		this._unpublishOutput();
+		if ( this._cadenceSuspended ) {
+
+			// The accumulation is what a final render shows; a held preview frame would otherwise sit
+			// over it until the render finished.
+			this.denoiser?.abort();
+			this._unpublishOutput();
+
+		}
+
+		this._syncGBufferStages();
 
 	}
 
 	setContinuousDenoise( enabled ) {
 
+		// Once nothing else uses OIDN it turns off, and a disabled denoiser can no longer be aborted.
+		if ( ! enabled && ! this.finalDenoise ) this.denoiser?.abort();
 		this.continuousDenoise = !! enabled;
 		this._syncOIDNInUse();
 		this._lastCadenceAt = - Infinity;
 		this._resetCadence();
+		this._syncGBufferStages();
 
 	}
 
@@ -888,19 +847,24 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	// Not at a size proven too slow to denoise while moving: the raw render owns the view there.
+	// Not at a size proven too slow to denoise while moving (the raw render owns the view there), nor
+	// through a final render or a panorama, which never reproject it.
 	get historyWanted() {
 
-		return this.temporalHistory && this.continuousDenoise && !! this.denoiser?.enabled && ! this._movingHopeless;
+		return this.temporalHistory && this.continuousDenoise && !! this.denoiser?.enabled && ! this._movingHopeless
+			&& ! this._cadenceSuspended && ! this._isPanorama();
 
 	}
 
 	get historyActive() {
 
-		const pt = this._stages.pathTracer;
-		return this.historyWanted && ! this._cadenceSuspended && !! this._stages.normalDepth?.enabled
-			&& pt?.uniforms?.get( 'cameraProjection' )?.value !== CAMERA_PROJECTION_IDS.equirectangular
-			&& ! ( pt?.visMode?.value > 0 );
+		return this.historyWanted && !! this._stages.normalDepth?.enabled && ! ( this._stages.pathTracer?.visMode?.value > 0 );
+
+	}
+
+	_isPanorama() {
+
+		return this._stages.pathTracer?.uniforms?.get( 'cameraProjection' )?.value === CAMERA_PROJECTION_IDS.equirectangular;
 
 	}
 
@@ -1436,7 +1400,9 @@ export class DenoisingManager extends EventDispatcher {
 		// What closes the render, if anything. A full pass at the chosen tier when that switch is
 		// on; otherwise, if OIDN owns the live view, one last cheap refresh — the cadence's last
 		// tick lands a few samples short, and the picture should match the render that finished.
-		const closing = this.finalDenoise ? 'final' : this.continuousDenoise ? 'refresh' : null;
+		// A final render has no live view to match, so with the switch off it stays undenoised.
+		const live = this.continuousDenoise && ! this._cadenceSuspended;
+		const closing = this.finalDenoise ? 'final' : live ? 'refresh' : null;
 
 		// Registered only once the closing denoise has been launched, so the next 'end' is
 		// unambiguously that one — a cadence run's end can look identical otherwise.
@@ -1584,6 +1550,13 @@ export class DenoisingManager extends EventDispatcher {
 			if ( this._denoiserEndHandler ) this.denoiser.removeEventListener( 'end', this._denoiserEndHandler );
 			if ( this._denoiserTileHandler ) this.denoiser.removeEventListener( 'tileProgress', this._denoiserTileHandler );
 			if ( this._denoiserErrorHandler ) this.denoiser.removeEventListener( 'error', this._denoiserErrorHandler );
+			if ( this._denoiserLoadHandler ) {
+
+				for ( const type of [ 'loading', 'loaded', 'error' ] ) this.denoiser.removeEventListener( type, this._denoiserLoadHandler );
+				if ( this.denoiser.state?.isLoading ) this.dispatchEvent( { type: EngineEvents.DENOISER_LOADING, loading: false } );
+
+			}
+
 			this.denoiser.dispose();
 			this.denoiser = null;
 
@@ -1608,6 +1581,7 @@ export class DenoisingManager extends EventDispatcher {
 		this._denoiserEndHandler = null;
 		this._denoiserTileHandler = null;
 		this._denoiserErrorHandler = null;
+		this._denoiserLoadHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;
@@ -1671,53 +1645,6 @@ export class DenoisingManager extends EventDispatcher {
 	// These methods match the DenoisingAPI surface so call sites need
 	// zero or minimal changes after facade removal.
 
-	/** Updates ASVGF stage parameters. */
-	setASVGFParams( params ) {
-
-		this._stages.asvgf?.updateParameters( params );
-
-	}
-
-	/**
-	 * Toggle the ASVGF heatmap compute pass. When enabled, the stage writes
-	 * the heatmap to its public `heatmapTarget` RenderTarget — the host is
-	 * responsible for rendering it.
-	 */
-	toggleASVGFHeatmap( enabled ) {
-
-		this._stages.asvgf?.setHeatmapEnabled?.( enabled );
-
-	}
-
-	/**
-	 * Configures ASVGF for a specific render mode (multi-stage coordination).
-	 * @param {Object} config - { enabled, temporalAlpha, atrousIterations, ... }
-	 */
-	configureASVGFForMode( config ) {
-
-		if ( ! this._stages.asvgf ) return;
-
-		this._stages.asvgf.enabled = config.enabled;
-		if ( this._stages.variance ) this._stages.variance.enabled = config.enabled;
-		if ( this._stages.bilateralFilter ) this._stages.bilateralFilter.enabled = config.enabled;
-
-		if ( config.enabled ) {
-
-			this._stages.asvgf.updateParameters( config );
-
-		}
-
-		this._syncGBufferStages();
-
-	}
-
-	/** Updates edge-aware filtering parameters. */
-	setEdgeAwareParams( params ) {
-
-		this._stages.edgeFilter?.updateUniforms( params );
-
-	}
-
 	/** Updates auto-exposure stage parameters. */
 	setAutoExposureParams( params ) {
 
@@ -1835,7 +1762,7 @@ export class DenoisingManager extends EventDispatcher {
 
 	/**
 	 * Switches strategy with automatic reset (convenience wrapper).
-	 * @param {'none'|'asvgf'|'nrd'|'edgeaware'} strategy
+	 * @param {'none'|'nrd'|'oidn'} strategy
 	 * @param {string} [preset]
 	 */
 	setStrategy( strategy, preset ) {
@@ -1904,12 +1831,8 @@ export class DenoisingManager extends EventDispatcher {
 		const ctx = this.pipeline?.context;
 		if ( ! ctx ) return;
 
-		const keys = [
-			'asvgf:output', 'asvgf:demodulated', 'asvgf:gradient',
-			'variance:output', 'bilateralFiltering:output',
-			'edgeFiltering:output', 'nrd:output', 'oidn:output',
-		];
-		keys.forEach( k => ctx.removeTexture( k ) );
+		ctx.removeTexture( 'nrd:output' );
+		ctx.removeTexture( 'oidn:output' );
 
 	}
 
@@ -1924,21 +1847,4 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	_applyASVGFPreset( presetName ) {
-
-		const preset = ASVGF_QUALITY_PRESETS[ presetName ];
-		if ( ! preset ) return;
-		// ASVGF consumes temporalAlpha / gradientStrength / maxAccumFrames.
-		// BilateralFilter consumes phi* edge-stopping params and atrousIterations.
-		// Variance consumes varianceBoost. Each stage cherry-picks what it needs.
-		this._stages.asvgf?.updateParameters( preset );
-		this._stages.bilateralFilter?.updateParameters( preset );
-		if ( this._stages.variance && preset.varianceBoost !== undefined ) {
-
-			this._stages.variance.varianceBoost.value = preset.varianceBoost;
-
-		}
-
-	}
-
 }