rayzee 6.4.0 → 7.0.0

package/src/TSL/Struct.js

@@ -50,6 +50,11 @@ export const RayTracingMaterial = struct( {
 	iridescence: 'float',
 	iridescenceIOR: 'float',
 	iridescenceThicknessRange: 'vec2',
+	subsurface: 'float', // 0 = off, blends opaque BRDF → random-walk SSS
+	subsurfaceColor: 'vec3', // single-scatter albedo (tint light picks up inside)
+	subsurfaceRadius: 'vec3', // per-channel mean free path
+	subsurfaceRadiusScale: 'float', // scalar multiplier on radius
+	subsurfaceAnisotropy: 'float', // Henyey-Greenstein g (-1..1)
 } );
 
 // Lightweight material for shadow ray evaluation — only the fields needed

package/src/TSL/Subsurface.js

@@ -0,0 +1,232 @@
+/**
+ * Subsurface.js - Random-walk subsurface scattering.
+ *
+ * Reuses the refraction interface + medium stack (PathTracerCore.js). The new physics
+ * is inside the medium: a ray collides mid-flight (sigma_s > 0) and scatters via a
+ * Henyey-Greenstein phase function instead of flying straight + absorbing (glass).
+ */
+
+import {
+	Fn,
+	float,
+	vec2,
+	vec3,
+	If,
+	select,
+	abs,
+	dot,
+	clamp,
+	max,
+	exp,
+	log,
+	sqrt,
+	cos,
+	sin,
+	normalize,
+	reflect,
+	refract,
+} from 'three/tsl';
+
+import { struct } from './patches.js';
+import { TWO_PI, EPSILON, constructTBN } from './Common.js';
+import { RandomValue } from './Random.js';
+import { iorToFresnel0, fresnelSchlickFloat } from './Fresnel.js';
+import { ImportanceSampleGGX } from './MaterialSampling.js';
+
+// ================================================================================
+// STRUCTS
+// ================================================================================
+
+export const CollisionSample = struct( {
+	didScatter: 'bool',
+	t: 'float', // collision distance (clamped to surfaceDist when no scatter)
+	weight: 'vec3', // throughput multiplier for the segment (chromatic-MIS)
+} );
+
+export const MediumCoeffs = struct( {
+	sigmaT: 'vec3',
+	sigmaS: 'vec3',
+	sigmaA: 'vec3',
+} );
+
+export const SubsurfaceEntryResult = struct( {
+	direction: 'vec3',
+	throughput: 'vec3',
+	didReflect: 'bool',
+} );
+
+// ================================================================================
+// HENYEY-GREENSTEIN PHASE SAMPLING
+// ================================================================================
+
+// Returns a scattered direction (unit). cosTheta is relative to the propagation dir
+// `wi`, so g > 0 is forward scattering. Inverse-CDF sampling is exact, so the brute-force
+// walk needs no extra weight at the vertex (hence no pdf is returned).
+export const sampleHenyeyGreenstein = Fn( ( [ wi, g, xi ] ) => {
+
+	const cosTheta = float( 0.0 ).toVar();
+
+	If( abs( g ).lessThan( 0.001 ), () => {
+
+		cosTheta.assign( float( 1.0 ).sub( xi.x.mul( 2.0 ) ) ); // isotropic; avoids 1/(2g)
+
+	} ).Else( () => {
+
+		const denom = max( float( 1.0 ).sub( g ).add( g.mul( 2.0 ).mul( xi.x ) ), 1e-4 );
+		const sqrTerm = float( 1.0 ).sub( g.mul( g ) ).div( denom );
+		cosTheta.assign( float( 1.0 ).add( g.mul( g ) ).sub( sqrTerm.mul( sqrTerm ) ).div( g.mul( 2.0 ) ) );
+
+	} );
+
+	cosTheta.assign( clamp( cosTheta, - 1.0, 1.0 ) );
+	const sinTheta = sqrt( max( float( 0.0 ), float( 1.0 ).sub( cosTheta.mul( cosTheta ) ) ) );
+	const phi = float( TWO_PI ).mul( xi.y );
+
+	// Basis with wi as 3rd column → result is already unit length.
+	const TBN = constructTBN( { N: wi } );
+	return TBN.mul( vec3( sinTheta.mul( cos( phi ) ), sinTheta.mul( sin( phi ) ), cosTheta ) );
+
+} );
+
+// ================================================================================
+// CHROMATIC COLLISION-DISTANCE SAMPLING (hero-channel spectral MIS)
+// ================================================================================
+
+// Per-channel sigma_t can't be represented by one scalar distance. Pick a channel
+// ∝ throughput, sample t against it, and weight by the balance-heuristic combined pdf
+// p̄ = Σ pmf_c·p_c — the shared scalar p̄ is what suppresses color fireflies.
+export const sampleChromaticCollision = Fn( ( [ sigmaT, sigmaS, beta, surfaceDist, rngState ] ) => {
+
+	const w = max( beta, vec3( 1e-4 ) ); // floor so no channel goes unsampled
+	const pmf = w.div( w.x.add( w.y ).add( w.z ) ).toVar();
+
+	// .toVar() pins the single RNG draw (else it re-executes per comparison → state drift).
+	const u = RandomValue( rngState ).toVar();
+	const cSigmaT = float( 0.0 ).toVar();
+	If( u.lessThan( pmf.x ), () => {
+
+		cSigmaT.assign( sigmaT.x );
+
+	} ).ElseIf( u.lessThan( pmf.x.add( pmf.y ) ), () => {
+
+		cSigmaT.assign( sigmaT.y );
+
+	} ).Else( () => {
+
+		cSigmaT.assign( sigmaT.z );
+
+	} );
+
+	const xi = RandomValue( rngState ).toVar();
+	const t = log( max( float( 1.0 ).sub( xi ), 1e-6 ) ).negate().div( max( cSigmaT, 1e-6 ) ).toVar();
+
+	const didScatter = t.lessThan( surfaceDist ).toVar();
+	const tOut = t.toVar();
+	const weight = vec3( 0.0 ).toVar();
+
+	If( didScatter, () => {
+
+		const Tr = exp( sigmaT.mul( t ).negate() ).toVar();
+		const pBar = dot( pmf, sigmaT.mul( Tr ) );
+		weight.assign( sigmaS.mul( Tr ).div( max( pBar, 1e-6 ) ) );
+
+	} ).Else( () => {
+
+		const Tr = exp( sigmaT.mul( surfaceDist ).negate() ).toVar();
+		const pBar = dot( pmf, Tr );
+		weight.assign( Tr.div( max( pBar, 1e-6 ) ) );
+		tOut.assign( surfaceDist );
+
+	} );
+
+	return CollisionSample( { didScatter, t: tOut, weight } );
+
+} );
+
+// ================================================================================
+// PARAMETER → COEFFICIENT MAPPING (Cycles-style)
+// ================================================================================
+
+// sigma_t = 1/(radius·scale), sigma_s = albedo·sigma_t, sigma_a = sigma_t - sigma_s.
+// subsurfaceColor is the single-scatter albedo, so the per-event weight carries the tint.
+export const subsurfaceCoefficients = Fn( ( [ subsurfaceColor, subsurfaceRadius, radiusScale ] ) => {
+
+	const r = max( subsurfaceRadius.mul( radiusScale ), vec3( 1e-4 ) );
+	const sigmaT = vec3( 1.0 ).div( r );
+	const sigmaS = subsurfaceColor.mul( sigmaT );
+	const sigmaA = max( sigmaT.sub( sigmaS ), vec3( 0.0 ) );
+
+	return MediumCoeffs( { sigmaT, sigmaS, sigmaA } );
+
+} );
+
+// ================================================================================
+// DIELECTRIC BOUNDARY (enter / exit the SSS medium)
+// ================================================================================
+
+// Dielectric interface driven by material.ior: reflect (Fresnel/TIR) or refract across
+// the boundary. No color tint — the scattering color lives in sigma_s.
+export const handleSubsurfaceEntry = Fn( ( [
+	rayDir, normal, material, entering, rngState, currentMediumIOR, previousMediumIOR,
+] ) => {
+
+	const result = SubsurfaceEntryResult( {
+		direction: vec3( 0.0 ),
+		throughput: vec3( 1.0 ),
+		didReflect: false,
+	} ).toVar();
+
+	const N = select( entering, normal, normal.negate() ).toVar();
+	const n1 = select( entering, currentMediumIOR, material.ior ).toVar();
+	const n2 = select( entering, material.ior, previousMediumIOR ).toVar();
+
+	const cosThetaI = abs( dot( N, rayDir ) );
+	const sinThetaT2 = n1.mul( n1 ).div( max( n2.mul( n2 ), EPSILON ) ).mul( float( 1.0 ).sub( cosThetaI.mul( cosThetaI ) ) );
+	const tir = sinThetaT2.greaterThan( 1.0 ).toVar();
+
+	const F0 = iorToFresnel0( n2, n1 );
+	const Fr = select( tir, float( 1.0 ), fresnelSchlickFloat( cosThetaI, F0 ) ).toVar();
+	const reflectProb = clamp( Fr, 0.02, 0.98 ).toVar();
+
+	const doReflect = tir.or( RandomValue( rngState ).lessThan( reflectProb ) ).toVar();
+	result.didReflect.assign( doReflect );
+
+	If( doReflect, () => {
+
+		// GGX-sampled reflection: a perfect mirror here makes SSS surfaces read as polished ceramic.
+		const xiR = vec2( RandomValue( rngState ), RandomValue( rngState ) );
+		const H = ImportanceSampleGGX( { N, roughness: material.roughness, Xi: xiR } );
+		const reflDir = reflect( rayDir, H ).toVar();
+		If( dot( reflDir, N ).lessThanEqual( 0.0 ), () => {
+
+			reflDir.assign( reflect( rayDir, N ) ); // rough sample dipped below surface
+
+		} );
+		result.direction.assign( reflDir );
+		result.throughput.assign( vec3( Fr.div( max( reflectProb, 0.02 ) ) ) );
+
+	} ).Else( () => {
+
+		const refrDir = refract( rayDir, N, n1.div( max( n2, EPSILON ) ) ).toVar();
+
+		If( dot( refrDir, refrDir ).lessThan( 0.0001 ), () => {
+
+			result.direction.assign( reflect( rayDir, N ) );
+			result.didReflect.assign( true );
+
+		} ).Else( () => {
+
+			result.direction.assign( normalize( refrDir ) );
+			// (1-Fr) transmission + (n1/n2)² radiance scale (cancels round-trip).
+			const radianceScale = n1.mul( n1 ).div( max( n2.mul( n2 ), EPSILON ) );
+			result.throughput.assign( vec3(
+				float( 1.0 ).sub( Fr ).div( max( float( 1.0 ).sub( reflectProb ), 0.02 ) ).mul( radianceScale )
+			) );
+
+		} );
+
+	} );
+
+	return result;
+
+} );

package/src/TSL/patches.js

@@ -1,9 +1,11 @@
 /**
  * Rayzee patches for Three.js / TSL.
  *
- * Side-effect on import: installs `WebGPUBackend.createNodeBuilder` override
- * (restores r183 function-scoped `var` emission for compute shaders — prevents
- * a register-allocation regression in the path tracer's hot loop).
+ * Side-effect on import: installs two `WebGPUBackend.prototype` overrides —
+ * `createNodeBuilder` (restores r183 function-scoped `var` emission for compute
+ * shaders, preventing a register-allocation regression in the path tracer's hot
+ * loop) and `initTimestampQuery` (enlarges the stats-gl timestamp query pool so
+ * the wavefront tracer's high per-frame compute-pass count doesn't overflow it).
  *
  * Export: `struct()` — drop-in replacement for TSL's `struct()` returning
  * a proxy factory that supports GLSL-style dot-notation field access.
@@ -64,7 +66,82 @@ WebGPUBackend.prototype.createNodeBuilder = function ( object, renderer ) {
 };
 
 // ---------------------------------------------------------------------------
-// 2. TSL struct proxy — enables GLSL-style dot-notation field access
+// 2. Larger timestamp query pool (stats-gl GPU/compute timing)
+// ---------------------------------------------------------------------------
+// Three.js lazily creates each timestamp query pool with a hardcoded 2048
+// queries (= 1024 passes) — `WebGPUBackend.initTimestampQuery` / the upstream
+// `// TODO: Variable maxQueries?`. The wavefront tracer issues hundreds of
+// compute passes per frame (peak right after a maxBounces change: the survivor
+// curve is invalid, so the bounce loop runs the full `loopBound` at full
+// dispatch with no early-exit — ~560 passes / 1124 queries at production
+// settings). stats-gl resolves once per frame, but the resolve is async and
+// `mapAsync` lags several frames under that GPU load, so the counter isn't reset
+// before it overflows → "Maximum number of queries exceeded" + dropped timings.
+//
+// Two parts:
+//   a) Grow the pool to 4096 queries on first use. 4096 is the WebGPU hard cap on
+//      a query set's count ("Query count exceeds the maximum query count (4096)")
+//      — 2× the upstream default, the most a single pool can hold (~2048 passes).
+//      That alone fully covers the interactive case (~200 passes/frame); anything
+//      larger fails CreateQuerySet validation.
+//   b) When even 4096 isn't enough (production spike), degrade gracefully: skip
+//      tracking the overflow passes silently instead of `warnOnce` + an invalid
+//      descriptor. The reported compute ms briefly undercounts during the spike;
+//      rendering is never affected (timestamps don't gate compute correctness).
+const TIMESTAMP_POOL_MAX_QUERIES = 4096;
+
+// Drop-in for the pool's allocateQueriesForContext minus the warnOnce on overflow
+// — returns null silently when full so the pass is cleanly skipped (see below).
+function _allocateQueriesSilently( uid ) {
+
+	if ( ! this.trackTimestamp || this.isDisposed ) return null;
+	if ( this.currentQueryIndex + 2 > this.maxQueries ) return null; // full: skip, no warn
+	const baseOffset = this.currentQueryIndex;
+	this.currentQueryIndex += 2;
+	this.queryOffsets.set( uid, baseOffset );
+	return baseOffset;
+
+}
+
+const _origInitTimestampQuery = WebGPUBackend.prototype.initTimestampQuery;
+
+WebGPUBackend.prototype.initTimestampQuery = function ( type, uid, descriptor ) {
+
+	const poolWasMissing = this.trackTimestamp && ! this.timestampQueryPool[ type ];
+
+	_origInitTimestampQuery.call( this, type, uid, descriptor );
+
+	// (a) First use: replace the fresh 2048 pool with a 4096 one of the same class,
+	// migrating the single allocation just made (offset 0) and re-pointing this
+	// pass's descriptor. Safe — first pass of the first tracked frame, nothing in
+	// flight. Swap in the silent allocator so future overflows don't warn.
+	if ( poolWasMissing ) {
+
+		const pool = this.timestampQueryPool[ type ];
+		if ( pool && pool.maxQueries < TIMESTAMP_POOL_MAX_QUERIES && descriptor.timestampWrites ) {
+
+			const Pool = pool.constructor;
+			const bigPool = new Pool( this.device, type, TIMESTAMP_POOL_MAX_QUERIES );
+			bigPool.allocateQueriesForContext = _allocateQueriesSilently;
+			bigPool.allocateQueriesForContext( uid ); // re-take offset 0 for this pass
+			this.timestampQueryPool[ type ] = bigPool;
+			descriptor.timestampWrites.querySet = bigPool.querySet; // offsets 0/1 unchanged
+			pool.dispose(); // nothing in flight — first pass of the first tracked frame
+
+		}
+
+	}
+
+	// (b) On overflow the (silent) allocator returns null, but upstream still wrote
+	// a descriptor with a null begin index — which both collides on slot 1 and is
+	// invalid. Drop it so the pass is cleanly untimed.
+	const tw = descriptor.timestampWrites;
+	if ( tw && tw.beginningOfPassWriteIndex == null ) descriptor.timestampWrites = undefined;
+
+};
+
+// ---------------------------------------------------------------------------
+// 3. TSL struct proxy — enables GLSL-style dot-notation field access
 // ---------------------------------------------------------------------------
 // TSL structs require `.get('fieldName')` for member access, but GLSL-style
 // dot notation (`.fieldName`) is more natural and matches ported code.

package/src/index.js

@@ -44,6 +44,9 @@ export { IESManager } from './managers/IESManager.js';
 export { DenoisingManager } from './managers/DenoisingManager.js';
 export { OverlayManager } from './managers/OverlayManager.js';
 
+// VRAM accounting
+export { VRAMTracker, bufferBytes, textureBytes } from './Processor/VRAMTracker.js';
+
 // Pipeline infrastructure (for advanced consumers building custom stages)
 export { RenderPipeline } from './Pipeline/RenderPipeline.js';
 export { RenderStage, StageExecutionMode } from './Pipeline/RenderStage.js';

package/src/managers/CameraManager.js

@@ -261,7 +261,7 @@ export class CameraManager extends EventDispatcher {
 	 * @param {Object} params.assetLoader
 	 * @param {import('three').Mesh} params.floorPlane
 	 * @param {number} params.currentFocusDistance
-	 * @param {import('./PathTracer.js').PathTracer} params.pathTracer
+	 * @param {import('../Stages/PathTracer.js').PathTracer} params.pathTracer
 	 * @param {Function} params.setFocusDistance - Callback to update uniform + settings
 	 * @param {Function} params.softReset       - Callback for soft accumulation reset
 	 * @param {Function} params.hardReset       - Callback for hard accumulation reset

package/src/managers/DenoisingManager.js

@@ -41,7 +41,7 @@ export class DenoisingManager extends EventDispatcher {
 		this.pipeline = pipeline;
 
 		// Stage references — only used internally for orchestration
-		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, adaptiveSampling, edgeFilter, ssrc, autoExposure, compositor }
+		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, edgeFilter, ssrc, autoExposure, compositor }
 
 		this._getExposure = getExposure;
 		this._getSaturation = getSaturation;
@@ -231,7 +231,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		// Disable all real-time denoisers first
 		if ( s.asvgf ) s.asvgf.enabled = false;
-		if ( s.variance && ! this._isAdaptiveSamplingActive() ) s.variance.enabled = false;
+		if ( s.variance ) s.variance.enabled = false;
 		if ( s.bilateralFilter ) s.bilateralFilter.enabled = false;
 		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( false );
 		if ( s.ssrc ) s.ssrc.enabled = false;
@@ -258,6 +258,8 @@ export class DenoisingManager extends EventDispatcher {
 
 		}
 
+		this._syncGBufferStages();
+
 	}
 
 	/**
@@ -282,6 +284,8 @@ export class DenoisingManager extends EventDispatcher {
 		// Coordinate with EdgeAware filtering
 		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( ! enabled );
 
+		this._syncGBufferStages();
+
 	}
 
 	/**
@@ -315,35 +319,49 @@ export class DenoisingManager extends EventDispatcher {
 	}
 
 	/**
-	 * Enables/disables adaptive sampling with proper stage and context cleanup.
-	 * @param {boolean} 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
+	 * otherwise skips MotionVector's per-frame compute + copies during preview
+	 * navigation and frees their textures. Call after any consumer toggle.
+	 *
+	 * MotionVector requires NormalDepth (reads pathtracer:normalDepth) and its
+	 * consumers (ASVGF, SSRC) 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.
 	 */
-	setAdaptiveSamplingEnabled( enabled ) {
+	_syncGBufferStages() {
 
 		const s = this._stages;
+		const nd = s.normalDepth;
+		const mv = s.motionVector;
 
-		if ( s.adaptiveSampling ) {
-
-			s.adaptiveSampling.enabled = enabled;
-			s.adaptiveSampling.setHeatmapEnabled( false );
+		// motionVector:* consumed by ASVGF + SSRC
+		const motionNeeded = !! ( s.asvgf?.enabled || s.ssrc?.enabled );
+		// pathtracer:normalDepth consumed by ASVGF, SSRC, EdgeFilter, BilateralFilter
+		const normalNeeded = motionNeeded || !! ( s.edgeFilter?.enabled || s.bilateralFilter?.enabled );
 
-		}
+		if ( nd ) {
 
-		// Variance stage is shared by both ASVGF and adaptive sampling
-		if ( enabled ) {
+			// On disabled→enabled, re-arm dirty/history so the first frame recomputes
+			// (not the stale static fast-path) and seeds prev = current.
+			if ( normalNeeded && ! nd.enabled ) nd.reset();
+			nd.enabled = normalNeeded;
 
-			if ( s.variance ) s.variance.enabled = true;
+		}
 
-		} else if ( ! s.asvgf?.enabled ) {
+		if ( mv ) {
 
-			if ( s.variance ) s.variance.enabled = false;
+			// 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;
 
-		// Clean up stale variance context when disabling
-		if ( ! enabled && this.pipeline?.context && ! s.asvgf?.enabled ) {
+			}
 
-			this.pipeline.context.removeTexture( 'variance:output' );
+			mv.enabled = motionNeeded;
 
 		}
 
@@ -546,6 +564,8 @@ export class DenoisingManager extends EventDispatcher {
 
 		}
 
+		this._syncGBufferStages();
+
 	}
 
 	/** Updates SSRC stage parameters. */
@@ -569,29 +589,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/**
-	 * Updates adaptive sampling parameters (with settings bridge).
-	 * @param {Object} params
-	 */
-	setAdaptiveSamplingParams( params ) {
-
-		if ( params.min !== undefined ) this._stages.pathTracer?.setUniform( 'adaptiveSamplingMin', params.min );
-		if ( params.adaptiveSamplingMax !== undefined ) this._settings?.set( 'adaptiveSamplingMax', params.adaptiveSamplingMax );
-		this._stages.adaptiveSampling?.setAdaptiveSamplingParameters( params );
-
-	}
-
-	/**
-	 * Toggle the AdaptiveSampling heatmap compute pass. When enabled, the
-	 * stage writes the heatmap to its public `heatmapTarget` RenderTarget —
-	 * the host is responsible for rendering it.
-	 */
-	toggleAdaptiveSamplingHelper( enabled ) {
-
-		this._stages.adaptiveSampling?.setHeatmapEnabled( enabled );
-
-	}
-
 	// ── OIDN ─────────────────────────────────────────────────────
 
 	/** Enables or disables Intel OIDN denoiser. */
@@ -608,27 +605,13 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/** Enables or disables the OIDN tile helper overlay. */
-	setOIDNTileHelper( enabled ) {
-
-		this._setTileHelper( enabled );
-
-	}
-
-	/** Enables or disables the tile helper overlay. */
+	/** Enables or disables the denoise/upscale progress overlay. */
 	setTileHelperEnabled( enabled ) {
 
 		this._setTileHelper( enabled );
 
 	}
 
-	/** Enables or disables tile highlight. */
-	setTileHighlightEnabled( enabled ) {
-
-		this._setTileHelper( enabled );
-
-	}
-
 	// ── AI Upscaler ──────────────────────────────────────────────
 
 	/** Enables or disables the AI upscaler. */
@@ -665,17 +648,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/**
-	 * Enables or disables adaptive sampling (convenience wrapper with settings bridge).
-	 * @param {boolean} enabled
-	 */
-	setAdaptiveSampling( enabled ) {
-
-		this._settings?.set( 'useAdaptiveSampling', enabled );
-		this.setAdaptiveSamplingEnabled( enabled );
-
-	}
-
 	/**
 	 * Switches strategy with automatic reset (convenience wrapper).
 	 * @param {'none'|'asvgf'|'ssrc'|'edgeaware'} strategy
@@ -702,7 +674,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-
 	_getEffectiveExposure() {
 
 		return this._stages.autoExposure?.enabled
@@ -717,12 +688,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	_isAdaptiveSamplingActive() {
-
-		return this._stages.adaptiveSampling?.enabled ?? false;
-
-	}
-
 	_clearDenoiserTextures() {
 
 		const ctx = this.pipeline?.context;