rayzee 11.6.0 → 11.8.0

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;
@@ -349,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 } );
 
 		};
@@ -424,6 +426,7 @@ export class DenoisingManager extends EventDispatcher {
 			getToneMapping: () => this._getToneMapping(),
 			getSaturation: () => this._getSaturation(),
 			getDisplayGain: () => this._getDisplayGain?.() ?? null,
+			getTransparentBackground: () => !! this._settings?.get( 'transparentBackground' ),
 		} );
 
 		this.upscaler.enabled = DENOISER_DEFAULTS.enableUpscaler || false;
@@ -447,9 +450,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() {
 
@@ -457,105 +459,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 );
+		if ( ! DENOISER_STRATEGIES.includes( strategy ) ) {
 
-		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 ) {
-
-			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' );
 
 	}
 
@@ -569,6 +521,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
@@ -576,17 +535,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;
@@ -594,8 +546,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 ) {
@@ -612,21 +564,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
@@ -641,7 +586,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?.();
 
@@ -849,21 +794,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();
 
 	}
 
@@ -895,19 +848,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;
 
 	}
 
@@ -1443,7 +1401,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.
@@ -1686,53 +1646,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 ) {
 
@@ -1850,7 +1763,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 ) {
@@ -1919,12 +1832,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' );
 
 	}
 
@@ -1939,21 +1848,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;
-
-		}
-
-	}
-
 }

package/src/managers/InteractionManager.js

@@ -704,6 +704,12 @@ export class InteractionManager extends EventDispatcher {
 	 */
 	_intersectScene() {
 
+		// Nothing in front of an imported camera's clip plane is rendered, so nothing there is picked. An orthographic
+		// ray already starts on the near plane, which a switch to such a camera set to its clip start.
+		const clipStart = this.camera.userData?.clipStart ?? 0;
+		this.raycaster.near = clipStart > 0 && ! this.camera.isOrthographicCamera
+			? clipStart / Math.max( this.raycaster.ray.direction.dot( this.camera.getWorldDirection( _viewAxis ) ), 1e-4 )
+			: 0;
 		return this.isGeometryOnDisk?.() ? [] : this.raycaster.intersectObjects( this.scene.children, true );
 
 	}

package/src/managers/UniformManager.js

@@ -23,7 +23,7 @@ const SHADER_NAMES = {
 export const LIGHT_FLOATS = Object.freeze( {
 	directional: 12, // 8 light fields + gobo { index, signed intensity, scale, pad }
 	area: 16, // 13 base + normalize, spread, shape
-	point: 9,
+	point: 10, // 9 light fields + radius
 	spot: 20, // 14 light fields + gobo { index, signed intensity } + IES { index, intensity } + 2 reserved
 } );
 
@@ -301,6 +301,8 @@ export class UniformManager {
 		u( 'cameraProjectionMatrixInverse', new Matrix4(), 'mat4' );
 		u( 'cameraViewMatrix', new Matrix4(), 'mat4' );
 		u( 'cameraProjectionMatrix', new Matrix4(), 'mat4' );
+		// An imported camera's near clipping plane: camera rays start this far in front of it (0 = at the camera).
+		u( 'cameraClipStart', 0, 'float' );
 
 		// Projection: CAMERA_PROJECTION_IDS. Ranges are radians (UI carries degrees).
 		const radRange = ( [ min, max ] ) => new Vector2( min, max ).multiplyScalar( MathUtils.DEG2RAD );

package/dist/SceneMetadata-D2Sh-0e-.js

@@ -1,110 +0,0 @@
-//#region src/Processor/archiveFormats.js
-var e = Object.freeze({
-	zip: {
-		type: "archive",
-		name: "ZIP Archive"
-	},
-	gz: {
-		type: "archive",
-		name: "Gzipped TAR Archive"
-	},
-	tgz: {
-		type: "archive",
-		name: "Gzipped TAR Archive"
-	},
-	tar: {
-		type: "archive",
-		name: "TAR Archive"
-	}
-}), t = (e) => typeof Blob < "u" && e instanceof Blob, n = (e) => !!e && typeof e == "object" && !t(e) && e.files != null, r = (e) => e.startsWith(".") || e === "__MACOSX";
-function i({ name: e = null, files: n }, { isModel: i = () => !1 } = {}) {
-	let a = /* @__PURE__ */ new Map();
-	for (let e of n) {
-		let n = t(e) ? e : e.file, i = t(e) ? e.webkitRelativePath || e.name : e.path, o = String(i ?? "").replace(/\\/g, "/").split("/").filter((e) => e && e !== ".").join("/");
-		!o || !n || o.split("/").some(r) || a.set(o, {
-			path: o,
-			file: n
-		});
-	}
-	let o = [...a.values()].sort((e, t) => e.path < t.path ? -1 : +(e.path > t.path)), s = o[0]?.path.split("/")[0], c = o.length > 0 && o.every((e) => e.path.startsWith(s + "/")) ? s : null;
-	return {
-		name: e ?? c ?? (o.find((e) => i(e.path)) ?? o[0])?.path.split("/").pop() ?? "Folder",
-		files: o,
-		flat: c === null && o.every((e) => !e.path.includes("/"))
-	};
-}
-//#endregion
-//#region src/Processor/SceneMetadata.js
-var a = [
-	"sourceFile",
-	"url",
-	"file"
-];
-function o(e) {
-	if (typeof e == "string") try {
-		let t = JSON.parse(e);
-		return t && typeof t == "object" ? t : null;
-	} catch {
-		return null;
-	}
-	return e && typeof e == "object" ? e : null;
-}
-function s(e) {
-	let t = typeof e == "string" ? parseFloat(e) : e;
-	return Number.isFinite(t) ? t : void 0;
-}
-function c(e) {
-	let t = o(e);
-	if (!t) return null;
-	let n = (e) => e && (e.environment !== void 0 || e.render !== void 0), r = o(t.rayzee);
-	return n(r) ? r : n(t) ? t : null;
-}
-function l(e) {
-	let t = o(e);
-	if (!t) return null;
-	let n = a.map((e) => t[e]).find((e) => typeof e == "string" && e.trim());
-	if (!n) return null;
-	let r = s(t.rotation), i = s(t.intensity), c = { sourceFile: n.trim() };
-	return r !== void 0 && (c.rotation = r), i !== void 0 && (c.intensity = Math.max(0, i)), c;
-}
-var u = [
-	"maxBounces",
-	"samples",
-	"width",
-	"height"
-];
-function d(e) {
-	let t = o(e);
-	if (!t) return null;
-	let n = {};
-	for (let e of u) {
-		let r = s(t[e]);
-		r !== void 0 && r > 0 && (n[e] = Math.round(r));
-	}
-	return Object.keys(n).length ? n : null;
-}
-function f(e) {
-	let t = c(e);
-	if (!t) return null;
-	let n = l(t.environment), r = d(t.render);
-	return !n && !r ? null : {
-		...n ? { environment: n } : {},
-		...r ? { render: r } : {}
-	};
-}
-function p(e) {
-	if (!e) return null;
-	let t = [
-		e.userData,
-		e.asset?.extras,
-		e.scene?.userData
-	];
-	Array.isArray(e.scenes) && t.push(...e.scenes.map((e) => e?.userData));
-	for (let e of t) {
-		let t = f(e);
-		if (t) return t;
-	}
-	return null;
-}
-//#endregion
-export { i as a, n as i, f as n, e as r, p as t };