rayzee 10.0.0 → 11.0.0

package/src/EngineDefaults.js

@@ -1,736 +1,93 @@
-import { sunPosition, dayOfYearForMonth } from './Processor/SunPosition.js';
-
-/** The default sun as a time of day (solar hours), month and latitude; north lies along −Z. */
-export const DEFAULT_SUN_PATH = Object.freeze( { time: 10, month: 3, latitude: 40 } );
-
-const DEFAULT_SUN = sunPosition( { hours: DEFAULT_SUN_PATH.time, dayOfYear: dayOfYearForMonth( DEFAULT_SUN_PATH.month ), latitude: DEFAULT_SUN_PATH.latitude } );
-
-/**
- * Engine-owned default values and configuration constants.
- * These are used exclusively by the rendering engine (src/core/)
- * and should not depend on any UI framework or external modules.
- */
-
-/**
- * Product decisions for a real-time viewer, not physical constants. Both are invisible from
- * outside and both move output away from a reference renderer. `viewer` is the default.
- */
-export const RENDER_PROFILES = Object.freeze( {
-	viewer: Object.freeze( {
-		areaLightIntensityScale: 0.1, // scales glTF placeholder area-light power (viewer tuning)
-		environmentRotation: 0.0, // degrees — the HDRI as authored, as Blender shows it
-		toneMapping: 6, // AgXToneMapping
-		saturation: 1.0, // no grade
-		dofMode: 'look', // depth of field set by how blurry it looks, not by a lens — right at any scene scale
-	} ),
-	physical: Object.freeze( {
-		areaLightIntensityScale: 1.0,
-		environmentRotation: 0.0,
-		// AgX, matching Blender/Cycles' default view transform. ACES crushes shadows on this
-		// engine's own corpus (shade 1.48 vs AgX 3.01 from identical radiance).
-		toneMapping: 6,
-		saturation: 1.0, // no grade
-		dofMode: 'physical',
-	} ),
-} );
+/** Default values of the render settings and materials, and the presets built on them. */
 
 /**
- * @param {string} [name] - a RENDER_PROFILES key
- * @returns {{areaLightIntensityScale: number, environmentRotation: number}}
- * @throws {Error} on an unknown name — a typo must not silently select viewer tuning
+ * The default of every render setting, under the setting's own name: each key is a RenderSettings route
+ * and nothing else lives here. A viewer piece keeps its own defaults beside its code.
  */
-export function getRenderProfile( name = 'viewer' ) {
+export const ENGINE_DEFAULTS = deepFreeze( {
 
-	const profile = RENDER_PROFILES[ name ];
-	if ( ! profile ) {
-
-		throw new Error( `unknown render profile "${name}" — expected one of ${Object.keys( RENDER_PROFILES ).join( ', ' )}` );
-
-	}
-
-	return profile;
-
-}
-
-export const ENGINE_DEFAULTS = {
-	// Canvas output
-	resolution: 512,
-	canvasWidth: 512,
-	canvasHeight: 512,
+	// Light paths
+	maxBounces: 3,
+	transmissiveBounces: 5,
+	maxSubsurfaceSteps: 8, // a low cap on the subsurface random walk; the final tier raises it
+	maxTransparentBounces: 32, // alpha skips are free bounces; uncapped, cutout foliage eats the loop
+	integrator: 'path', // 'path' | 'bidirectional' | 'vcm'
+	shadowRays: 'two', // 'all' | 'two' | 'one' — shadow rays a hit (path integrator)
+	samplingTechnique: 2, // 0 PCG, 1 Halton, 2 Sobol
+	enableEmissiveTriangleSampling: false,
+	emissiveBoost: 1.0,
+	enableAlphaShadows: false,
+	fireflyThreshold: 3.0,
+	shadowTerminatorOffset: 0.1, // Cycles' Geometry Offset at Blender's default; 0 turns it off
+	globalIlluminationIntensity: 1,
+	wavefrontSortMaterials: true, // sort rays by material before Shade (above 8 materials); read when kernels build
 
-	// Max material-texture dimension (longest edge) used when processing a scene's
-	// textures into GPU arrays. Larger = sharper textures but ~quadratic VRAM. Clamped
-	// to TEXTURE_CONSTANTS.MAX_TEXTURE_SIZE (hardware ceiling). Applied at scene load.
-	maxTextureSize: 4096,
+	// Sampling and convergence
+	maxSamples: 60,
+	renderLimitMode: 'frames',
+	renderTimeLimit: 30,
+	renderMode: 0, // 0 preview, 1 production; configureForMode() sets it
+	useAdaptiveSampling: true,
+	noiseThreshold: 0.1, // a pixel under this √-luminance noise has converged; the interactive tier's value
+	adaptiveMinSamples: 8,
+	adaptiveStopFraction: 0.90, // a calibration, not a dial: the share of converged pixels that retires a frame
+	usePixelFreeze: true,
+	// Stricter than noiseThreshold on purpose: it tests plain relative error, and a pixel frozen before it
+	// passes the frame's own test never will.
+	pixelFreezeThreshold: 0.02,
+	pixelFreezeStability: 8, // candidate frames in a row before a pixel freezes
+	convergenceOverlay: false, // display only; never alters the render
+	interactionModeEnabled: true,
 
-	toneMapping: RENDER_PROFILES.viewer.toneMapping,
+	// Output
 	exposure: 1,
-	saturation: RENDER_PROFILES.viewer.saturation,
-	enableEnvironment: true,
-	showBackground: true,
+	saturation: 1.0, // no grade
 	transparentBackground: false,
+	backgroundColor: '#000000', // what a camera miss shows when the backdrop is a solid colour
+
+	// Environment and background
+	enableEnvironment: true,
 	environmentIntensity: 1,
+	environmentRotation: 0.0, // degrees; 0 is the HDRI as authored, as Blender shows it
+	showBackground: true,
 	backgroundIntensity: 1,
-	// Solid backdrop color shown on camera-ray misses in 'color' background mode
-	// (showBackground=false, transparentBackground=false). Black = legacy hidden-backdrop look.
-	backgroundColor: '#000000',
-	// Backdrop blur (env background only). 0 = sharp/off (no cost). Cone-jitter blur of the
-	// primary-ray env lookup; lighting/reflections stay sharp. Samples = taps/frame (noise vs cost).
-	backgroundBlurriness: 0,
+	backgroundBlurriness: 0, // blurs the backdrop only; lighting and reflections stay sharp
 	backgroundBlurSamples: 8,
-	environmentRotation: RENDER_PROFILES.viewer.environmentRotation,
 	groundProjectionEnabled: false,
 	groundProjectionRadius: 100,
 	groundProjectionHeight: 15,
-	// World Y of the projected ground plane; auto-seeded to the scene floor (min-Y) on model
-	// load so models that aren't authored at y=0 sit ON the ground instead of sinking into it.
-	groundProjectionLevel: 0,
-	// Analytic ground-plane shadow catcher (primary-ray holdout; no geometry)
+	groundProjectionLevel: 0, // world Y of the projected ground; seeded to the scene's floor on load
 	enableGroundCatcher: false,
 	groundCatcherHeight: 0,
-	globalIlluminationIntensity: 1,
 
-	// Environment Mode System
-	environmentMode: 'hdri', // 'hdri' | 'procedural' | 'gradient' | 'color'
-
-	// Gradient Sky Colors
-	gradientZenithColor: '#0077BE',
-	gradientHorizonColor: '#87CEEB',
-	gradientGroundColor: '#654321',
-
-	// Solid Color Sky
-	solidSkyColor: '#87CEEB',
-
-	// Physical sky (Processor/PhysicalSky.js) — the Clear Day preset
-	skySunAzimuth: 180 - DEFAULT_SUN.azimuth,
-	skySunElevation: DEFAULT_SUN.elevation,
-	skySunStrength: 1, // artistic multiplier on the disc and its light; 1 is physical
-	skySunSize: 0.53, // angular diameter, degrees
-	skyTurbidity: 2, // 1 is aerosol-free air, ~2 a clear day, 6+ hazy
-	skyOzone: 300, // Dobson units
-	skyAirDensity: 1,
-	skyGroundAlbedo: '#959595', // 0.3 linear
-	skyAltitude: 50, // metres
-	skyPreset: 'clearDay',
-
-	// Camera projection — 'perspective' | 'orthographic' | 'equirectangular'. Panorama ranges are UI-facing degrees.
-	cameraProjection: 'perspective',
-	panoramaLonRange: [ - 180, 180 ],
+	// Camera
+	cameraProjection: 'perspective', // 'perspective' | 'orthographic' | 'equirectangular'
+	panoramaLonRange: [ - 180, 180 ], // degrees
 	panoramaLatRange: [ - 90, 90 ],
 	panoramaLevelHorizon: true,
-
 	enableDOF: false,
-	fov: 55,
+	dofMode: 'look', // 'look': set by how blurry it looks, right at any scene scale; 'physical': a real lens
+	dofBlur: 0.05, // look mode: a far background's blur, as a fraction of the image height
 	focusDistance: 0.8,
 	aperture: 5.6,
 	focalLength: 50,
 	apertureScale: 1.0,
 	anamorphicRatio: 1.0,
-	unitsPerMetre: 1, // scene units per real metre; the lens is specified in mm
-	dofMode: RENDER_PROFILES.viewer.dofMode, // 'look' | 'physical'
-	dofBlur: 0.05, // look mode: a far background's blur, as a fraction of the image height
+	unitsPerMetre: 1, // scene units per real metre; the lens is in mm
 
-	// Auto-focus
-	autoFocusMode: 'auto', // 'manual' | 'auto'
-	afScreenPoint: { x: 0.5, y: 0.5 },
-	afSmoothingFactor: 0.15,
+	// Read when a model loads
+	maxTextureSize: 4096, // longest edge of a material texture; clamped to the hardware ceiling
+	areaLightIntensityScale: 0.1, // power of a glTF model's placeholder area lights (RectAreaLight extras)
 
-	enablePathTracer: true,
-	enableAccumulation: true,
-	pauseRendering: false,
-	maxSamples: 60,
-	bounces: 3,
-	transmissiveBounces: 5,
-	maxSubsurfaceSteps: 8, // interactive default: low cap (bounded random-walk SSS)
-
-	maxTransparentBounces: 32, // guard: alpha skips are free bounces, else cutout foliage eats the loop budget
-
-	// Adaptive sampling (Blender-style): stop the frame once enough pixels drop below the noise threshold.
-	useAdaptiveSampling: true,
-	// √-luminance-normalized per-pixel noise below which a pixel counts as converged. Base tracks the
-	// interactive tier — that is what a freshly booted engine renders before configureForMode runs.
-	noiseThreshold: 0.1,
-	adaptiveMinSamples: 8, // min samples before adaptive sampling can trigger
-	// Fraction of pixels that must pass the 3×3-eroded convergence count before the frame retires; the
-	// geometry-only fraction has to clear the same bar (PathTracer._isConvergedComplete).
-	// ENGINE-INTERNAL: a calibration constant rather than a quality dial — it only means anything against
-	// those two counts. configureForMode supplies the per-tier value.
-	adaptiveStopFraction: 0.90,
-	// Per-pixel freeze: skip tracing pixels that individually converged (noise threshold only — no dark floor,
-	// which would bake dim regions too dark). Naturally engages only on static/idle views.
-	// Set together with useAdaptiveSampling by the single UI switch — two tiers of one feature.
-	usePixelFreeze: true,
-	// ENGINE-INTERNAL, and not the sibling of noiseThreshold it looks like: freeze bars on plain relErr where
-	// the frame test uses the √-normalized error, so the same number is 2-5× stricter here. Deriving it from
-	// noiseThreshold was measured and rejected — a pixel frozen before it satisfies the frame test can never
-	// satisfy it afterwards, so a looser bar delays the early stop rather than hastening it.
-	pixelFreezeThreshold: 0.02,
-	pixelFreezeStability: 8, // ENGINE-INTERNAL: consecutive candidate frames before a pixel freezes
-	convergenceOverlay: false, // display-only Compositor overlay; never alters the render
-
-	samplingTechnique: 2,
-	enableEmissiveTriangleSampling: false,
-	emissiveBoost: 1.0,
-
-	fireflyThreshold: 3.0,
-	// Cycles' Shadow Terminator → Geometry Offset, and its default: light shadow rays leave a
-	// smooth-shaded triangle from the smooth surface near the terminator. 0 disables.
-	shadowTerminatorOffset: 0.1,
-	// Wavefront material-coherence sort: global counting-sort of entering rays by material before
-	// Shade (material-pure workgroups), under dynamic dispatch. Measured −8% at 1024²/8b. Gated on
-	// material count > 8; the histogram bin count is sized per-scene to the material count.
-	wavefrontSortMaterials: true,
-	renderLimitMode: 'frames',
-	renderTimeLimit: 30,
-	renderMode: 0,
-	enableAlphaShadows: false,
-	tilesHelper: true, // show OIDN denoise / AI upscale tile progress overlay
-	showLightHelper: false,
-
-	directionalLightIntensity: 0,
-	directionalLightColor: "#ffffff",
-	directionalLightPosition: [ 1, 1, 1 ],
-	directionalLightAngle: 0.0,
-
-	// EdgeAware denoiser (spatial-only SVGF à-trous). filterStrength: final blend
-	// (0 = raw, 1 = filtered). edgeAtrousIterations: à-trous passes (step 1,2,4,8,16).
-	// edgePhiLuminance: variance-scaled luminance edge-stop. edgePhiNormal: normal cone
-	// exponent. edgePhiDepth: RELATIVE depth tolerance (fraction of ray distance).
-	filterStrength: 1.0,
-	edgeAtrousIterations: 5,
-	edgePhiLuminance: 4.0,
-	edgePhiNormal: 64.0,
-	edgePhiDepth: 0.1,
-
-	enableOIDN: false,
-	oidnQuality: 'fast',
-	// OIDN as the live-view denoiser, refreshing the accumulating image. Set by choosing 'oidn' in
-	// the real-time denoiser list, so that only ever one thing denoises the live view — not by
-	// `enableOIDN`, which is the separate question of whether the finished image gets a pass.
-	continuousDenoise: false,
-	// Lower bound on the gap between cadence denoises. DenoisingManager also floors that gap at a
-	// multiple of what the last denoise actually cost, and above ~1024² that is what binds — this
-	// value only governs where a denoise is cheap. 8 ms measured 31 refreshes/sec at 512² at an
-	// unchanged sample rate; 50 ms measured 18/sec for nothing in return.
-	continuousDenoiseInterval: 8,
-	// While the view moves, feed OIDN the reprojected history of restarted frames, not one sample.
-	oidnTemporalHistory: true,
-
-	enableUpscaler: false,
-	upscalerScale: 2,
-	upscalerQuality: 'fast',
-	upscalerHdr: true,
-
-	debugMode: 0,
-	debugThreshold: 100,
-	debugModel: 0,
-
-	enableBloom: false,
-	bloomStrength: 0.2,
-	bloomRadius: 0.15,
-	bloomThreshold: 0.85,
-	interactionModeEnabled: true,
-	// Per-axis render scale while the camera moves (0.5 = a quarter of the pixels); 1 turns it off.
-	interactionRenderScale: 0.5,
+	// Debug
+	visMode: 0, // a debug view (TSL/Debugger.js); 0 renders normally
 	debugVisScale: 100,
 
-	// Denoising strategy
-	denoiserStrategy: 'none',
-
-	enableASVGF: false,
-	asvgfTemporalAlpha: 0.1,
-	asvgfAtrousIterations: 8,
-	asvgfPhiColor: 10.0,
-	asvgfPhiNormal: 128.0,
-	asvgfPhiDepth: 1.0,
-	asvgfVarianceBoost: 1.0,
-	asvgfMaxAccumFrames: 32,
-	// Must be > 0: the gradient also rejects fireflies before the EMA smears them across
-	// ~1/alpha frames. At 0 the denoiser measures ~3x worse than no denoiser at 1 spp.
-	asvgfGradientStrength: 1.0,
-	asvgfGradientSigmaScale: 2.0,
-	asvgfGradientNoiseFloor: 0.0,
-	asvgfDebugMode: 0,
-	asvgfQualityPreset: 'medium',
-	showAsvgfHeatmap: false,
-
-	// NRD (ReBLUR port) real-time denoiser — see NRD_DEFAULTS / NRD_QUALITY_PRESETS.
-	nrdQualityPreset: 'medium',
-	nrdDebugMode: 0,
-
-	// Auto-exposure settings
-	autoExposure: false,
-	autoExposureKeyValue: 0.18,
-	autoExposureMinExposure: 0.1,
-	autoExposureMaxExposure: 20.0,
-	autoExposureAdaptSpeedBright: 3.0,
-	autoExposureAdaptSpeedDark: 0.5,
-};
+} );
 
 /** The `cameraProjection` uniform's value for each setting value. */
 export const CAMERA_PROJECTION_IDS = Object.freeze( { perspective: 0, equirectangular: 1, orthographic: 2 } );
 
-// Ray distance NormalDepth writes on a miss. Max finite half-float, so miss−miss diffs stay 0
-// rather than Inf−Inf=NaN.
-export const GBUFFER_MISS_DEPTH = 65504.0;
-export const GBUFFER_MISS_THRESHOLD = 6e4;
-
-// normHitDist = hitDist / (A + B·viewZ). A constant, not a uniform: the Shade write and the NRD
-// decode must agree, and the normalization is a pure round trip.
-export const NRD_HIT_DIST_A = 3.0;
-export const NRD_HIT_DIST_B = 0.1;
-
-// Albedo demodulation safety floor. ASVGF and BilateralFilter MUST use the
-// same value — demod (`color / safeAlbedo`) and remod (`lighting * safeAlbedo`)
-// only round-trip exactly when both sides agree.
-export const ALBEDO_EPS = 0.01;
-
-// Hard ceiling the engine supports for the reserved (pre-allocated) render size. 4K (3840×2160)
-// fits within 4096². Raising the reserved size to this pins ~1.5 GB of MRT textures — opt-in only.
-export const MAX_RESERVABLE_RENDER_SIZE = 4096;
-
-// Reserved render size: every per-resolution compute StorageTexture + aux buffer is pre-allocated at
-// this SQUARE size and never resized at runtime (works around three.js StorageTexture-resize bugs —
-// see TSL/patches history). Render resolution must not exceed it; the engine warns + ignores larger.
-// It is a LIVE binding (mutable) so it can be raised (e.g. for 4K) via setReservedRenderSize(); consumers
-// read it inside their constructors, and stages already built at a lower value are re-initialised in place
-// by PathTracerApp.setReservedRenderResolution() — which is the device-gated API hosts should call, at any
-// point in the lifecycle. Default 2048 (zero VRAM regression). See docs/internal/specs/wavefront-chunked-pool.md.
-export let MAX_STORAGE_TEXTURE_SIZE = 2048;
-
-// Set the reserved render size. MUST be called before pipeline construction (stages pre-allocate at
-// this value and cannot resize). Clamped to [256, MAX_RESERVABLE_RENDER_SIZE]. Returns the applied value.
-export function setReservedRenderSize( px ) {
-
-	MAX_STORAGE_TEXTURE_SIZE = Math.max( 256, Math.min( MAX_RESERVABLE_RENDER_SIZE, Math.floor( px ) || 256 ) );
-	return MAX_STORAGE_TEXTURE_SIZE;
-
-}
-
-export const ASVGF_QUALITY_PRESETS = {
-	// phiColor / phiDepth are RELATIVE tolerances (fractions). Bigger = more
-	// permissive. The adaptive temporal gradient (gradientStrength > 0) is always
-	// on: it measures real change in units of noise σ (gradientSigmaScale), so a
-	// static scene reads ~0 (no convergence penalty) and only moving lights / anim
-	// / disocclusion drop history. See ASVGF._buildGradientCompute.
-	low: {
-		temporalAlpha: 0.1,
-		gradientStrength: 0.8,
-		gradientSigmaScale: 2.5,
-		gradientNoiseFloor: 0.05,
-		atrousIterations: 3,
-		phiColor: 1.0,
-		phiNormal: 64.0,
-		phiDepth: 0.1,
-		phiLuminance: 6.0,
-		maxAccumFrames: 16,
-		varianceBoost: 0.5
-	},
-	medium: {
-		temporalAlpha: 0.03,
-		gradientStrength: 1.0,
-		gradientSigmaScale: 2.5,
-		gradientNoiseFloor: 0.05,
-		atrousIterations: 4,
-		phiColor: 0.5,
-		phiNormal: 128.0,
-		phiDepth: 0.05,
-		phiLuminance: 4.0,
-		maxAccumFrames: 64,
-		varianceBoost: 1.0
-	},
-	high: {
-		temporalAlpha: 0.0,
-		gradientStrength: 1.0,
-		gradientSigmaScale: 2.5,
-		gradientNoiseFloor: 0.05,
-		atrousIterations: 6,
-		phiColor: 0.3,
-		phiNormal: 256.0,
-		phiDepth: 0.02,
-		phiLuminance: 2.0,
-		maxAccumFrames: 128,
-		varianceBoost: 1.5
-	}
-};
-
-// NRD ReBLUR port (Stages/NRD.js). Names follow nrd::ReblurSettings so NVIDIA's tuning notes apply.
-export const NRD_DEFAULTS = {
-	maxAccumulatedFrameNum: 30,
-	maxFastAccumulatedFrameNum: 6,
-	maxStabilizedFrameNum: 63,
-	historyFixFrameNum: 3,
-	historyFixBasePixelStride: 14,
-	prepassBlurRadius: 30,
-	minBlurRadius: 1,
-	maxBlurRadius: 30,
-	lobeAngleFraction: 0.15,
-	roughnessFraction: 0.15,
-	planeDistanceSensitivity: 0.02,
-	minHitDistanceWeight: 0.1,
-	fastHistoryClampingSigmaScale: 2.0,
-	fireflySuppressorMinRelativeScale: 2.0,
-	enableAntiFirefly: true,
-	antilagLuminanceSigmaScale: 2.0,
-	antilagLuminanceSensitivity: 3.0,
-	disocclusionThreshold: 0.01,
-	convergenceS: 1.0,
-	convergenceB: 0.2,
-	convergenceP: 0.8,
-	// Share of the lobe the normal weight accepts before any history exists. NRD's own constant is
-	// 0.75, which its source flags as probably too much; at that width it smears curved surfaces.
-	lobeVolumePercent: 0.1,
-	// Progressive handover: input sample count at which the denoiser passes the render through untouched.
-	// 0 = 2 · maxAccumulatedFrameNum.
-	handoverFrames: 0,
-};
-
-// Keys a preset may override. Applying one resets every key to its default first, so a preset only
-// states its deltas and `medium` can be empty.
-export const NRD_PRESET_KEYS = [
-	'maxAccumulatedFrameNum', 'maxFastAccumulatedFrameNum', 'maxStabilizedFrameNum',
-	'historyFixFrameNum', 'prepassBlurRadius', 'maxBlurRadius', 'enableAntiFirefly',
-];
-
-export const NRD_QUALITY_PRESETS = {
-	// Short history + no pre-pass: most responsive, noisiest.
-	low: {
-		maxAccumulatedFrameNum: 16,
-		maxFastAccumulatedFrameNum: 4,
-		maxStabilizedFrameNum: 16,
-		historyFixFrameNum: 2,
-		prepassBlurRadius: 0,
-		maxBlurRadius: 20,
-		enableAntiFirefly: false,
-	},
-	// nrd::ReblurSettings defaults.
-	medium: {},
-	// Longer history and wider kernels: smoother, more lag on lighting change.
-	high: {
-		maxAccumulatedFrameNum: 45,
-		maxFastAccumulatedFrameNum: 8,
-		historyFixFrameNum: 4,
-		prepassBlurRadius: 40,
-		maxBlurRadius: 40,
-	},
-};
-
-export const CAMERA_RANGES = {
-	fov: {
-		min: 10,
-		max: 90,
-		default: ENGINE_DEFAULTS.fov
-	},
-	focusDistance: {
-		min: 0.3,
-		max: 100.0,
-		default: ENGINE_DEFAULTS.focusDistance
-	},
-	aperture: {
-		options: [ 1.4, 2.0, 2.8, 4.0, 5.6, 8.0, 11.0, 16.0 ],
-		default: ENGINE_DEFAULTS.aperture
-	},
-	focalLength: {
-		min: 0,
-		max: 200,
-		default: ENGINE_DEFAULTS.focalLength
-	}
-};
-
-// `exposure` (EV) makes up about two thirds of the light a lower sun loses, as a photographer
-// would: a sunset still reads darker than noon.
-export const SKY_PRESETS = {
-	clearDay: { name: 'Clear Day', sunAzimuth: 180 - DEFAULT_SUN.azimuth, sunElevation: DEFAULT_SUN.elevation, turbidity: 2, exposure: 0 },
-	clearMorning: { name: 'Clear Morning', sunAzimuth: 90, sunElevation: 15, turbidity: 2, exposure: 1.4 },
-	clearNoon: { name: 'Clear Noon', sunAzimuth: 180, sunElevation: 70, turbidity: 2, exposure: 0 },
-	hazyAfternoon: { name: 'Hazy Afternoon', sunAzimuth: 225, sunElevation: 35, turbidity: 4.5, exposure: 0.4 },
-	goldenHour: { name: 'Golden Hour', sunAzimuth: 270, sunElevation: 6, turbidity: 2.5, exposure: 2.7 },
-	sunset: { name: 'Sunset', sunAzimuth: 270, sunElevation: 1, turbidity: 3, exposure: 4.2 },
-	blueHour: { name: 'Blue Hour', sunAzimuth: 270, sunElevation: - 4, turbidity: 2, exposure: 7 },
-	mountain: { name: 'Mountain Air', sunAzimuth: 135, sunElevation: 40, turbidity: 1.3, altitude: 3000, exposure: 0 },
-};
-
-export const CAMERA_PRESETS = {
-	portrait: {
-		name: "Portrait",
-		description: "Shallow depth of field, background blur",
-		dofBlur: 0.10,
-		aperture: 1.4,
-		focalLength: 135,
-		apertureScale: 1.0
-	},
-	landscape: {
-		name: "Landscape",
-		description: "Maximum depth of field, everything in focus",
-		dofBlur: 0.001,
-		aperture: 16.0,
-		focalLength: 24,
-		apertureScale: 0.5
-	},
-	macro: {
-		name: "Macro",
-		description: "Very thin focus plane for close-ups",
-		dofBlur: 0.14,
-		aperture: 1.4,
-		focalLength: 100,
-		apertureScale: 2.0
-	},
-	product: {
-		name: "Product",
-		description: "Sharp detail with subtle background separation",
-		dofBlur: 0.013,
-		aperture: 2.8,
-		focalLength: 85,
-		apertureScale: 0.4
-	},
-	architectural: {
-		name: "Architectural",
-		description: "Deep focus for rooms and buildings",
-		dofBlur: 0.001,
-		aperture: 11.0,
-		focalLength: 16,
-		apertureScale: 0.5
-	},
-	cinematic: {
-		name: "Cinematic",
-		description: "Dramatic depth separation with anamorphic bokeh",
-		dofBlur: 0.13,
-		aperture: 1.4,
-		focalLength: 200,
-		apertureScale: 1.0,
-		anamorphicRatio: 1.5
-	}
-};
-
-export const AUTO_FOCUS_MODES = {
-	MANUAL: 'manual',
-	AUTO: 'auto',
-};
-
-export const AF_DEFAULTS = {
-	SMOOTHING_FACTOR: 0.15,
-	RESET_THRESHOLD: 0.05,
-	FALLBACK_DISTANCE: 10.0,
-	SNAP_THRESHOLD: 0.5,
-};
-
-/**
- * Triangle record: 5 uvec4 lanes (80 bytes). The buffer is declared `uvec4` so packed lanes
- * keep their exact bit pattern — a packSnorm2x16 result can land in the f32 NaN range, and an
- * f32 lane may canonicalise it (the same reason the G-buffer is uvec4). Positions and UVs are
- * written as f32 through a Float32Array view of the same memory and read back with
- * `uintBitsToFloat`, so they carry full precision; only normals are compressed.
- *
- * Was 32 floats (128 B) with 4 dead padding lanes. At 128 B the 2 GB V8 ArrayBuffer cap put a
- * hard ceiling of 16.7M triangles on the scene — 80 B lifts that to 26.8M and cuts geometry
- * VRAM by the same 37.5%. Each normal now rides in its position's spare .w lane, so the three
- * vec4 loads the intersection test already does carry the normals with them.
- */
-export const TRIANGLE_DATA_LAYOUT = {
-	FLOATS_PER_TRIANGLE: 20,
-
-	POSITION_A_OFFSET: 0, // f32 xyz + packed normal A
-	POSITION_B_OFFSET: 4,
-	POSITION_C_OFFSET: 8,
-
-	NORMAL_A_PACKED_OFFSET: 3, // oct16 in each position's .w lane
-	NORMAL_B_PACKED_OFFSET: 7,
-	NORMAL_C_PACKED_OFFSET: 11,
-
-	UV_AB_OFFSET: 12, // f32 uvA.xy, uvB.xy
-	UV_C_OFFSET: 16, // f32 uvC.xy
-	MATERIAL_FLAGS_OFFSET: 18, // materialIndex | side << 24 | shadowBlockerBits << 26 (two bits)
-	MESH_INDEX_OFFSET: 19
-};
-
-export const TRI_MATERIAL_MASK = 0xffffff;
-export const TRI_SIDE_SHIFT = 24; // 0 front, 1 back, 2 double, 3 cutaway
-// Front only for every ray, shadow rays too: a cut-away wall or roof. Set by `material.userData.cutaway`
-// at extraction, or `app.setMaterialsSide( indices, MATERIAL_SIDE_CUTAWAY )` on a built scene.
-export const MATERIAL_SIDE_CUTAWAY = 3;
-export const TRI_BLOCKER_SHIFT = 26; // 1 = blocks shadow rays whatever the settings
-export const TRI_BLOCKER_ALPHA_SHIFT = 27; // 1 = blocks them unless alpha-cutout shadows are on
-
-/**
- * How a shadow ray settles on this material without fetching it, mirroring traceShadowRay:
- * bit 0 set = always a blocker; bit 1 set = a blocker while alpha-cutout shadows are off
- * (MASK/BLEND with nothing else letting light through); 0 = light may pass, so the shadow
- * traversal has to find the nearest such surface.
- */
-export function shadowBlockerBits( material ) {
-
-	if ( ! material ) return 0;
-	const solid = ( material.transmission || 0 ) === 0
-		&& ( ( material.transparent | 0 ) === 0 || ( material.opacity ?? 1 ) >= 1 );
-	if ( ! solid ) return 0;
-	return ( material.alphaMode | 0 ) === 0 ? 1 : 2;
-
-}
-
-/**
- * Material index plus the per-triangle flags the shader reads without touching the
- * material buffer: `side` for inline culling and the two shadow-blocker bits.
- */
-export function packTriangleFlags( materialIndex, material ) {
-
-	return ( ( materialIndex & TRI_MATERIAL_MASK )
-		| ( ( material?.side ?? 0 ) << TRI_SIDE_SHIFT )
-		| ( shadowBlockerBits( material ) << TRI_BLOCKER_SHIFT ) ) >>> 0;
-
-}
-
-/**
- * Octahedral-encode a unit normal into one u32 (two snorm16). Worst-case error is ~0.03°,
- * well under what normal maps and barycentric interpolation already contribute.
- * A degenerate (zero-length) normal encodes as +Z rather than NaN.
- */
-export function packNormalOct( x, y, z ) {
-
-	const len = Math.sqrt( x * x + y * y + z * z );
-	if ( len > 0 ) {
-
-		x /= len; y /= len; z /= len;
-
-	} else {
-
-		x = 0; y = 0; z = 1;
-
-	}
-
-	const sum = Math.abs( x ) + Math.abs( y ) + Math.abs( z );
-	let u = x / sum, v = y / sum;
-	if ( z < 0 ) {
-
-		const au = u, av = v;
-		u = ( 1 - Math.abs( av ) ) * ( au >= 0 ? 1 : - 1 );
-		v = ( 1 - Math.abs( au ) ) * ( av >= 0 ? 1 : - 1 );
-
-	}
-
-	const qu = Math.round( Math.min( 1, Math.max( - 1, u ) ) * 32767 ) & 0xffff;
-	const qv = Math.round( Math.min( 1, Math.max( - 1, v ) ) * 32767 ) & 0xffff;
-	return ( ( qv << 16 ) | qu ) >>> 0;
-
-}
-
-/** Inverse of packNormalOct; writes into `out` (length >= 3) and returns it. */
-export function unpackNormalOct( packed, out ) {
-
-	const u = ( ( packed << 16 ) >> 16 ) / 32767;
-	const v = ( packed >> 16 ) / 32767;
-	let x = u, y = v, z = 1 - Math.abs( u ) - Math.abs( v );
-	if ( z < 0 ) {
-
-		const ax = x, ay = y;
-		x = ( 1 - Math.abs( ay ) ) * ( ax >= 0 ? 1 : - 1 );
-		y = ( 1 - Math.abs( ax ) ) * ( ay >= 0 ? 1 : - 1 );
-
-	}
-
-	const len = Math.sqrt( x * x + y * y + z * z ) || 1;
-	out[ 0 ] = x / len; out[ 1 ] = y / len; out[ 2 ] = z / len;
-	return out;
-
-}
-
-// Material data layout constants — single source of truth for material buffer offsets.
-// Shared between CPU writers (TextureCreator, MaterialDataManager) and GPU readers (Common.js getMaterial).
-export const MATERIAL_DATA_LAYOUT = {
-
-	SLOTS_PER_MATERIAL: 33, // vec4 slots per material
-	FLOATS_PER_MATERIAL: 132, // total floats per material (33 × 4)
-
-	// ── Flat float offsets (CPU side) ────────────────────────────────
-	// Used as: data[ materialIndex * FLOATS_PER_MATERIAL + offset ]
-	// Ordered for cache-line coherence: shadow/culling → BxDF core → maps → extended → transforms
-
-	// Slot 0: ior + transmission + thickness + emissiveIntensity   [shadow]
-	IOR: 0, TRANSMISSION: 1, THICKNESS: 2, EMISSIVE_INTENSITY: 3,
-	// Slot 1: attenuationColor.rgb + attenuationDistance            [shadow]
-	ATTENUATION_COLOR: 4, ATTENUATION_DISTANCE: 7,
-	// Slot 2: opacity + side + transparent + alphaTest              [shadow + culling]
-	OPACITY: 8, SIDE: 9, TRANSPARENT: 10, ALPHA_TEST: 11,
-	// Slot 3: alphaMode + depthWrite + normalScale                  [shadow]
-	ALPHA_MODE: 12, DEPTH_WRITE: 13, NORMAL_SCALE: 14,
-	// Slot 4: color.rgb + metalness                                 [BxDF core]
-	COLOR: 16, METALNESS: 19,
-	// Slot 5: emissive.rgb + roughness                              [BxDF core]
-	EMISSIVE: 20, ROUGHNESS: 23,
-	// Slot 6: map indices (albedo, normal, roughness, metalness)    [maps]
-	ALBEDO_MAP_INDEX: 24, NORMAL_MAP_INDEX: 25, ROUGHNESS_MAP_INDEX: 26, METALNESS_MAP_INDEX: 27,
-	// Slot 7: map indices (emissive, bump) + clearcoat              [maps]
-	EMISSIVE_MAP_INDEX: 28, BUMP_MAP_INDEX: 29, CLEARCOAT: 30, CLEARCOAT_ROUGHNESS: 31,
-	// Slot 8: dispersion + visible + sheen + sheenRoughness         [extended BxDF]
-	DISPERSION: 32, VISIBLE: 33, SHEEN: 34, SHEEN_ROUGHNESS: 35,
-	// Slot 9: sheenColor.rgb + (reserved)                           [extended BxDF]
-	SHEEN_COLOR: 36,
-	// Slot 10: specularIntensity + specularColor.rgb                [extended BxDF]
-	SPECULAR_INTENSITY: 40, SPECULAR_COLOR: 41,
-	// Slot 11: iridescence + iridescenceIOR + iridescenceThicknessRange [extended BxDF]
-	IRIDESCENCE: 44, IRIDESCENCE_IOR: 45, IRIDESCENCE_THICKNESS_RANGE: 46,
-	// Slot 12: bumpScale + displacementScale + displacementMapIndex + (padding)
-	BUMP_SCALE: 48, DISPLACEMENT_SCALE: 49, DISPLACEMENT_MAP_INDEX: 50,
-
-	// ── Transform float offsets (8 floats each: 7 matrix values + 1 padding) ──
-	ALBEDO_TRANSFORM: 52,
-	NORMAL_TRANSFORM: 60,
-	ROUGHNESS_TRANSFORM: 68,
-	METALNESS_TRANSFORM: 76,
-	EMISSIVE_TRANSFORM: 84,
-	BUMP_TRANSFORM: 92,
-	DISPLACEMENT_TRANSFORM: 100,
-
-	// ── Subsurface scattering (3 slots appended after transforms) ────
-	// Slot 27: subsurfaceColor.rgb (scatter albedo) + subsurface weight
-	SUBSURFACE_COLOR: 108, SUBSURFACE: 111,
-	// Slot 28: subsurfaceRadius.rgb (mean free path) + radius scale
-	SUBSURFACE_RADIUS: 112, SUBSURFACE_RADIUS_SCALE: 115,
-	// Slot 29: subsurfaceAnisotropy g (116) + surface anisotropy (strength 117, rotation 118, map index 119)
-	SUBSURFACE_ANISOTROPY: 116, ANISOTROPY: 117, ANISOTROPY_ROTATION: 118, ANISOTROPY_MAP_INDEX: 119,
-	// Slot 30: extension-texture map indices A (transmission, clearcoat, clearcoatRoughness, sheenColor)
-	TRANSMISSION_MAP_INDEX: 120, CLEARCOAT_MAP_INDEX: 121, CLEARCOAT_ROUGHNESS_MAP_INDEX: 122, SHEEN_COLOR_MAP_INDEX: 123,
-	// Slot 31: extension-texture map indices B (sheenRoughness, iridescence, iridescenceThickness, specularIntensity)
-	SHEEN_ROUGHNESS_MAP_INDEX: 124, IRIDESCENCE_MAP_INDEX: 125, IRIDESCENCE_THICKNESS_MAP_INDEX: 126, SPECULAR_INTENSITY_MAP_INDEX: 127,
-	// Slot 32: extension-texture map indices C (specularColor + 3 reserved)
-	SPECULAR_COLOR_MAP_INDEX: 128,
-
-	// ── Vec4 slot indices (GPU/TSL side) ─────────────────────────────
-	// Used with getDatafromStorageBuffer( buf, matIdx, int(slot), int(SLOTS_PER_MATERIAL) )
-	SLOT: {
-		IOR_TRANSMISSION: 0, // [shadow] ior, transmission, thickness, emissiveIntensity
-		ATTENUATION: 1, // [shadow] attenuationColor, attenuationDistance
-		OPACITY_ALPHA: 2, // [shadow+culling] opacity, side, transparent, alphaTest
-		ALPHA_MODE: 3, // [shadow] alphaMode, depthWrite, normalScale
-		COLOR_METALNESS: 4, // [BxDF] color.rgb, metalness
-		EMISSIVE_ROUGHNESS: 5, // [BxDF] emissive.rgb, roughness
-		MAP_INDICES_A: 6, // [maps] albedo, normal, roughness, metalness
-		MAP_INDICES_B: 7, // [maps] emissive, bump, clearcoat, clearcoatRoughness
-		DISPERSION_SHEEN: 8, // [extended] dispersion, visible, sheen, sheenRoughness
-		SHEEN_COLOR: 9, // [extended] sheenColor, reserved
-		SPECULAR: 10, // [extended] specularIntensity, specularColor
-		IRIDESCENCE: 11, // [extended] iridescence, iridescenceIOR, iridescenceThicknessRange
-		BUMP_DISPLACEMENT: 12, // bumpScale, displacementScale, displacementMapIndex
-		ALBEDO_TRANSFORM_A: 13, ALBEDO_TRANSFORM_B: 14,
-		NORMAL_TRANSFORM_A: 15, NORMAL_TRANSFORM_B: 16,
-		ROUGHNESS_TRANSFORM_A: 17, ROUGHNESS_TRANSFORM_B: 18,
-		METALNESS_TRANSFORM_A: 19, METALNESS_TRANSFORM_B: 20,
-		EMISSIVE_TRANSFORM_A: 21, EMISSIVE_TRANSFORM_B: 22,
-		BUMP_TRANSFORM_A: 23, BUMP_TRANSFORM_B: 24,
-		DISPLACEMENT_TRANSFORM_A: 25, DISPLACEMENT_TRANSFORM_B: 26,
-		SUBSURFACE_A: 27, // subsurfaceColor.rgb, subsurface weight
-		SUBSURFACE_B: 28, // subsurfaceRadius.rgb, subsurfaceRadiusScale
-		SUBSURFACE_C: 29, // subsurfaceAnisotropy g, anisotropy, anisotropyRotation, anisotropyMapIndex
-		EXT_MAP_INDICES_A: 30, // transmission, clearcoat, clearcoatRoughness, sheenColor map indices
-		EXT_MAP_INDICES_B: 31, // sheenRoughness, iridescence, iridescenceThickness, specularIntensity map indices
-		EXT_MAP_INDICES_C: 32, // specularColor map index + 3 reserved
-	},
-
-};
-
-// glTF/three.js spell "no volume absorption" as attenuationDistance = Infinity, while the GPU
-// contract is `> 0 = on` (calculateBeerLawAbsorption). Every writer into ATTENUATION_DISTANCE
-// collapses both spellings to 0 so no shader divides by Inf.
-export const normalizeAttenuationDistance = d => ( Number.isFinite( d ) && d > 0 ? d : 0 );
 
 // The only fallback for a property a three.js material doesn't carry: MeshPhysicalMaterial's own
 // default (glTF with the extension absent), or the value that turns an engine-only feature off.
@@ -772,6 +129,9 @@ export const MATERIAL_DEFAULTS = deepFreeze( {
 	subsurfaceAnisotropy: 0,
 	anisotropy: 0,
 	anisotropyRotation: 0,
+	// KHR_materials_diffuse_transmission: the share of the diffuse lobe passed through to the other side.
+	diffuseTransmission: 0,
+	diffuseTransmissionColor: [ 1, 1, 1 ],
 } );
 
 function deepFreeze( object ) {
@@ -781,324 +141,6 @@ function deepFreeze( object ) {
 
 }
 
-// BVH node leaf markers
-/**
- * Node tags, written into slot [3] of a BVH node as a raw u32 bit pattern.
- *
- * Node indices, triangle offsets and counts are integers living inside a Float32Array. Written as
- * float *values* they round silently past 2^24 (16,777,216): in a 24M-node scene half of every
- * BLAS pointer landed on a neighbouring node and that geometry vanished from the render with no
- * error at all. Every one of those fields is written as a u32 bit pattern instead, exact to 2^30.
- *
- * Tags sit above {@link BVH_MAX_INDEX} so a single unsigned compare separates a leaf from an inner
- * node's left-child index. All three are ordinary finite floats — nothing lands in the NaN range,
- * which an f32 storage buffer is free to canonicalise.
- */
-export const BVH_MAX_INDEX = 0x40000000; // 2^30
-
-/**
- * Slot [1] of a BLAS-pointer leaf holds its placement index, which {@link BVH_MAX_INDEX} keeps
- * below 2^30. Bit 30 is therefore free to say the leaf's matrix is identity: geometry no other
- * placement shares is baked to world space at extraction, and a ray reaching it needs no
- * transform at all. Mask the bit off before using the slot as an index.
- */
-export const TLAS_LEAF_IDENTITY = 0x40000000;
-export const TLAS_PLACEMENT_MASK = 0x3fffffff;
-
-export const BVH_LEAF_MARKERS = {
-	TRIANGLE_LEAF: 0x40000000, // leaf containing triangle references
-	BLAS_POINTER_LEAF: 0x40000001, // TLAS leaf pointing to a BLAS root node
-	FRONTIER: 0x40000002, // parallel-build placeholder, overwritten during assembly
-};
-
-/**
- * A triangle leaf of at most this many triangles is folded into its parent: the child's slot ([3]
- * or [7]) holds `~( first << 4 | count )`, the very value traversal pushes, so an inner node is
- * read exactly as before and only popping a negative entry differs. Node indices stay below
- * {@link BVH_MAX_INDEX}, leaf tags between it and 2^31, folded leaves from 2^31 up — so the count
- * has four bits and the first triangle must stay below {@link BVH_FOLDED_FIRST_LIMIT}.
- */
-export const BVH_FOLDED_LEAF_MAX = 15;
-export const BVH_FOLDED_FIRST_LIMIT = 1 << 27;
-
-/** A u32 view over a float buffer, for writing index fields as exact bit patterns. */
-export function bvhIndexView( f32 ) {
-
-	return new Uint32Array( f32.buffer, f32.byteOffset, f32.length );
-
-}
-
-/**
- * Refuse to build a BVH whose indices would collide with the leaf tags.
- *
- * Throws rather than degrades: the failure this replaces was a scene that rendered with half its
- * geometry silently missing, which is far worse than a scene that refuses to load. Guarding the
- * totals covers every individual write, since no index can exceed the count it indexes into.
- *
- * @param {number} count - node or triangle total about to be indexed
- * @param {string} what - what the count is, for the message
- * @throws {RangeError}
- */
-export function assertBVHIndexFits( count, what ) {
-
-	if ( count >= BVH_MAX_INDEX ) {
-
-		throw new RangeError(
-			`${what} is ${count.toLocaleString()}, at or past the BVH index limit of ` +
-			`${BVH_MAX_INDEX.toLocaleString()}. Node indices are stored as u32 bit patterns and the ` +
-			'leaf tags occupy everything above that.'
-		);
-
-	}
-
-	return count;
-
-}
-
-// Texture processing constants
-export const TEXTURE_CONSTANTS = {
-	PIXELS_PER_MATERIAL: 30,
-	RGBA_COMPONENTS: 4,
-	VEC4_PER_TRIANGLE: 8,
-	VEC4_PER_BVH_NODE: 4,
-	FLOATS_PER_VEC4: 4,
-	MIN_TEXTURE_WIDTH: 4,
-	MAX_CONCURRENT_WORKERS: Math.min( typeof navigator !== 'undefined' ? navigator.hardwareConcurrency || 4 : 4, 6 ),
-	BUFFER_POOL_SIZE: 20,
-	CANVAS_POOL_SIZE: 12,
-	CACHE_SIZE_LIMIT: 50,
-	// Hardware ceiling for a single texture-array dimension (WebGPU maxTextureDimension2D
-	// guaranteed minimum). The configurable maxTextureSize setting is clamped to this.
-	MAX_TEXTURE_SIZE: 8192,
-	// Default cap applied when no maxTextureSize is supplied (engine standalone use).
-	DEFAULT_MAX_TEXTURE_SIZE: 4096,
-	// Per-map-type ceiling before bucketing; the real cap is per (pool, bucket) in _bucketTextures.
-	MAX_TEXTURES_LIMIT: 4 * 256,
-	// Array shapes per colorSpace pool. Material maps are grouped into this many
-	// (width, height) classes so a small or oddly-shaped map no longer pays a large
-	// neighbour's footprint. 4 → ~8 bound material arrays (4 sRGB + 4 linear).
-	MATERIAL_BUCKET_COUNT: 4,
-	// Packing stride: a map's stored index encodes bucketId * BUCKET_LAYER_STRIDE + layer.
-	// Also the per-bucket layer cap. Kept at the WebGPU portable maxTextureArrayLayers floor (256)
-	// so a consolidated bucket (which merges several map types of one size) stays portable.
-	BUCKET_LAYER_STRIDE: 256,
-};
-
-// An RGBA8 row upload must be a multiple of 256 bytes, so bucket widths land on 64 texels.
-const BUCKET_WIDTH_ALIGN = 64;
-
-export function alignBucketWidth( width, maxTextureSize ) {
-
-	const aligned = Math.ceil( Math.max( 1, width ) / BUCKET_WIDTH_ALIGN ) * BUCKET_WIDTH_ALIGN;
-	return Math.min( maxTextureSize, Math.max( TEXTURE_CONSTANTS.MIN_TEXTURE_WIDTH, aligned ) );
-
-}
-
-function bucketOf( units ) {
-
-	let width = 0, height = 0, count = 0;
-	for ( const unit of units ) {
-
-		width = Math.max( width, unit.width );
-		height = Math.max( height, unit.height );
-		count += unit.count;
-
-	}
-
-	return { units, width, height, count };
-
-}
-
-// Footprint times layer count.
-function bucketCost( bucket, maxTextureSize ) {
-
-	return alignBucketWidth( bucket.width, maxTextureSize ) * bucket.height * bucket.count * 4;
-
-}
-
-function totalCost( buckets, maxTextureSize ) {
-
-	return buckets.reduce( ( sum, b ) => sum + bucketCost( b, maxTextureSize ), 0 );
-
-}
-
-// Repeatedly fuse the pair of buckets whose union wastes least, until `count` remain.
-function mergeDown( buckets, count, maxTextureSize ) {
-
-	let current = buckets.slice();
-
-	while ( current.length > count ) {
-
-		let best = null;
-
-		for ( let i = 0; i < current.length; i ++ ) {
-
-			for ( let j = i + 1; j < current.length; j ++ ) {
-
-				const fused = bucketOf( current[ i ].units.concat( current[ j ].units ) );
-				const delta = bucketCost( fused, maxTextureSize )
-					- bucketCost( current[ i ], maxTextureSize ) - bucketCost( current[ j ], maxTextureSize );
-				if ( ! best || delta < best.delta ) best = { i, j, delta, fused };
-
-			}
-
-		}
-
-		current = current.filter( ( _, k ) => k !== best.i && k !== best.j ).concat( [ best.fused ] );
-
-	}
-
-	return current;
-
-}
-
-// The pre-shape-aware layout, kept as a rival opening: square scenes still do well on it.
-function ladderBuckets( units, count, maxTextureSize ) {
-
-	const ladder = [];
-	for ( let i = count - 1; i >= 0; i -- ) {
-
-		ladder.push( Math.max( TEXTURE_CONSTANTS.MIN_TEXTURE_WIDTH, Math.round( maxTextureSize / Math.pow( 2, i ) ) ) );
-
-	}
-
-	const bins = ladder.map( () => [] );
-
-	for ( const unit of units ) {
-
-		const longest = Math.pow( 2, Math.ceil( Math.log2( Math.max( unit.width, unit.height ) ) ) );
-		let slot = ladder.findIndex( size => longest <= size );
-		if ( slot < 0 ) slot = ladder.length - 1;
-		bins[ slot ].push( unit );
-
-	}
-
-	return bins.filter( bin => bin.length ).map( bucketOf );
-
-}
-
-// Both openings above are greedy and stop short on mixed aspects; moving one shape at a time
-// to whichever bucket makes the pool cheapest recovers the difference.
-function refine( buckets, maxTextureSize ) {
-
-	let current = buckets;
-
-	for ( let pass = 0; pass < 8; pass ++ ) {
-
-		let improved = false;
-
-		for ( const unit of current.flatMap( b => b.units ) ) {
-
-			const from = current.findIndex( b => b.units.includes( unit ) );
-			if ( from < 0 ) continue;
-
-			for ( let to = 0; to < current.length; to ++ ) {
-
-				if ( to === from ) continue;
-
-				const moved = [];
-				for ( let i = 0; i < current.length; i ++ ) {
-
-					if ( i === from ) {
-
-						const rest = current[ i ].units.filter( u => u !== unit );
-						if ( rest.length ) moved.push( bucketOf( rest ) );
-
-					} else if ( i === to ) moved.push( bucketOf( current[ i ].units.concat( [ unit ] ) ) );
-					else moved.push( current[ i ] );
-
-				}
-
-				if ( totalCost( moved, maxTextureSize ) < totalCost( current, maxTextureSize ) ) {
-
-					current = moved;
-					improved = true;
-					break;
-
-				}
-
-			}
-
-		}
-
-		if ( ! improved ) break;
-
-	}
-
-	return current;
-
-}
-
-/**
- * Choose up to `count` array shapes for one colorSpace pool. Grouping by longest edge alone
- * forces a 2000x453 banner into a 2048x2048 array; grouping on both axes does not.
- *
- * @param {Array<{width: number, height: number}>} sizes - every texture in the pool
- * @param {number} maxTextureSize
- * @param {number} [count]
- * @returns {Array<{width: number, height: number}>} ascending by footprint
- */
-export function planTextureBuckets( sizes, maxTextureSize, count = TEXTURE_CONSTANTS.MATERIAL_BUCKET_COUNT ) {
-
-	const distinct = new Map();
-
-	for ( const { width, height } of sizes ) {
-
-		const w = Math.min( maxTextureSize, Math.max( 1, width || 1 ) );
-		const h = Math.min( maxTextureSize, Math.max( 1, height || 1 ) );
-		const key = `${w}x${h}`;
-		const seen = distinct.get( key );
-		if ( seen ) seen.count ++;
-		else distinct.set( key, { width: w, height: h, count: 1 } );
-
-	}
-
-	const units = [ ...distinct.values() ];
-	let buckets = units.map( unit => bucketOf( [ unit ] ) );
-
-	if ( buckets.length > count ) {
-
-		const ladder = ladderBuckets( units, count, maxTextureSize );
-		const merged = mergeDown( buckets, count, maxTextureSize );
-		buckets = totalCost( ladder, maxTextureSize ) < totalCost( merged, maxTextureSize ) ? ladder : merged;
-		buckets = refine( buckets, maxTextureSize );
-
-	}
-
-	return buckets
-		.map( b => ( { width: alignBucketWidth( b.width, maxTextureSize ), height: b.height } ) )
-		.sort( ( a, b ) => a.width * a.height - b.width * b.height );
-
-}
-
-/**
- * Index of the cheapest planned bucket that can hold a texture at its native size.
- * A texture larger than every bucket lands in the largest and is downscaled there.
- *
- * @param {number} width
- * @param {number} height
- * @param {Array<{width: number, height: number}>} shapes - from {@link planTextureBuckets}
- * @returns {number}
- */
-export function getTextureBucketId( width, height, shapes ) {
-
-	const w = Math.max( 1, width || 1 );
-	const h = Math.max( 1, height || 1 );
-	for ( let i = 0; i < shapes.length; i ++ ) if ( shapes[ i ].width >= w && shapes[ i ].height >= h ) return i;
-	return Math.max( 0, shapes.length - 1 );
-
-}
-
-// Pack (bucketId, layer) into the single int slot a material map index occupies.
-export function packTextureIndex( bucketId, layer ) {
-
-	return bucketId * TEXTURE_CONSTANTS.BUCKET_LAYER_STRIDE + layer;
-
-}
-
-// Default texture matrix for materials
-export const DEFAULT_TEXTURE_MATRIX = [ 0, 0, 1, 1, 0, 0, 0, 1 ];
-
 // Render quality configurations.
 // 'interactive' — low-sample, bounded bounces, no offline denoising, controls enabled.
 // 'production'  — high-sample, deep bounces, OIDN enabled, controls disabled.
@@ -1119,14 +161,14 @@ export const PRODUCTION_RENDER_CONFIG = {
 };
 
 export const INTERACTIVE_RENDER_CONFIG = {
-	maxSamples: ENGINE_DEFAULTS.maxSamples, bounces: ENGINE_DEFAULTS.bounces,
+	maxSamples: ENGINE_DEFAULTS.maxSamples, bounces: ENGINE_DEFAULTS.maxBounces,
 	renderMode: ENGINE_DEFAULTS.renderMode, enableAlphaShadows: ENGINE_DEFAULTS.enableAlphaShadows,
 	// 12, not 5: a spent budget leaves black glass and costs MORE — the ray then bounces diffusely.
 	transmissiveBounces: 12,
 	maxSubsurfaceSteps: ENGINE_DEFAULTS.maxSubsurfaceSteps,
 	// On, like production. The final pass costs one cheap denoise when the preview settles, and both
 	// neural passes need a denoised frame to be worth running — on Monte-Carlo noise the upscaler
-	// measured worse than a plain resize. ⚠️ `ENGINE_DEFAULTS.enableOIDN` stays false: the bench
+	// measured worse than a plain resize. ⚠️ `DENOISER_DEFAULTS.enableOIDN` stays false: the bench
 	// renders against it and every quality golden would move.
 	enableOIDN: true, oidnQuality: 'fast',
 	interactionModeEnabled: true,
@@ -1158,12 +200,3 @@ export function modePresetSettings( config ) {
 	};
 
 }
-
-// Memory management constants
-export const MEMORY_CONSTANTS = {
-	MAX_BUFFER_MEMORY: 1024 * 1024 * 1024,
-	MAX_TEXTURE_MEMORY: 2048 * 1024 * 1024,
-	CLEANUP_THRESHOLD: 0.8,
-	CHUNK_SIZE_THRESHOLD: 64 * 1024 * 1024,
-	STREAM_BATCH_SIZE: 4
-};