rayzee 8.4.1 → 8.6.0

package/src/PathTracerApp.js

@@ -1,4 +1,4 @@
-import { WebGPURenderer, RectAreaLightNode, SRGBColorSpace } from 'three/webgpu';
+import { WebGPURenderer, RectAreaLightNode, SRGBColorSpace, LinearSRGBColorSpace } from 'three/webgpu';
 import { texture as _tslTexture, cubeTexture as _tslCubeTexture } from 'three/tsl';
 import {
 	Scene, EventDispatcher, Box3
@@ -17,15 +17,18 @@ import { AutoExposure } from './Stages/AutoExposure.js';
 import { Compositor } from './Stages/Compositor.js';
 import { RenderPipeline } from './Pipeline/RenderPipeline.js';
 import { CompletionTracker } from './Pipeline/CompletionTracker.js';
-import { ENGINE_DEFAULTS as DEFAULT_STATE, PRODUCTION_RENDER_CONFIG, INTERACTIVE_RENDER_CONFIG, MAX_STORAGE_TEXTURE_SIZE, MAX_RESERVABLE_RENDER_SIZE, setReservedRenderSize, getRenderProfile } from './EngineDefaults.js';
+import { ENGINE_DEFAULTS as DEFAULT_STATE, PRODUCTION_RENDER_CONFIG, INTERACTIVE_RENDER_CONFIG, modePresetSettings, MAX_STORAGE_TEXTURE_SIZE, MAX_RESERVABLE_RENDER_SIZE, setReservedRenderSize, getRenderProfile } from './EngineDefaults.js';
 import { updateStats, updateLoading, resetLoading, setStatusCallback, getDisplaySamples, disposeObjectFromMemory, disposeRenderer } from './Processor/utils.js';
 import { BuildTimer } from './Processor/BuildTimer.js';
+import { TextureReadback } from './Processor/TextureReadback.js';
 import { createLogger, fmt } from './utils/Logger.js';
 import { InteractionManager } from './managers/InteractionManager.js';
 import { EngineEvents } from './EngineEvents.js';
 import { IssueLog, ISSUE_CODES } from './EngineIssues.js';
 import { SETTING_SOURCE } from './RenderSettings.js';
 import { toneMapToRGBA8 } from './Processor/ToneMapCPU.js';
+import { ColorManagement, setActiveColorManagement } from './Color/ColorManagement.js';
+import { getViewTransform } from './Color/ViewTransforms.js';
 import { AssetLoader } from './Processor/AssetLoader.js';
 import { SceneProcessor } from './Processor/SceneProcessor.js';
 
@@ -163,6 +166,15 @@ export class PathTracerApp extends EventDispatcher {
 			onIssue: ( issue ) => this.dispatchEvent( { type: EngineEvents.ISSUE, issue } ),
 		} );
 
+		/**
+		 * Colour management: what the engine renders in, shows it as, and hands out.
+		 *
+		 * Inert until a host loads an OCIO config — until then the working space is linear
+		 * Rec.709 and the view transforms are three.js's own seven, exactly as before.
+		 */
+		this.color = new ColorManagement( { issues: this._issues } );
+		setActiveColorManagement( this.color );
+
 		// ── Settings (single source of truth for all render parameters) ──
 		this.settings = new RenderSettings(
 			{
@@ -239,6 +251,12 @@ export class PathTracerApp extends EventDispatcher {
 
 		// Resolution state
 		this._resizeDebounceTimer = null;
+		// The size the host asked for. The canvas backing store is this × _renderScale, which drops
+		// below 1 only while the camera moves.
+		this._displayWidth = 0;
+		this._displayHeight = 0;
+		this._renderScale = 1;
+		this._pendingRenderScale = null;
 
 		// Tracked listeners for clean dispose()
 		this._trackedListeners = [];
@@ -342,6 +360,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( this.cameraManager.controls ) this.cameraManager.controls.update();
 
+		this._applyPendingRenderScale();
+
 		// Animation playback: compute skinned positions and refit BVH.
 		// Guard prevents overlapping async refits (fire-and-forget with 1-frame latency).
 		if ( this.animationManager?.isPlaying && ! this._animRefitInFlight ) {
@@ -590,6 +610,12 @@ export class PathTracerApp extends EventDispatcher {
 
 		this._issues.detach(); // onIssue captures `this`; see IssueLog.detach()
 
+		// Holds the renderer and the issue log, both of which outlive it otherwise.
+		this.color?.dispose();
+		this.color = null;
+		this._textureReadback?.dispose();
+		this._textureReadback = null;
+
 		this.interactionManager?.deselect?.();
 		this.transformManager?.detach?.();
 
@@ -764,9 +790,8 @@ export class PathTracerApp extends EventDispatcher {
 	 * by reference, and any ancestor transform is baked in. Later edits to `object3d` do not
 	 * reach the render — mutate {@link sceneModel}, then {@link refitBVH}/{@link refitBLASes}.
 	 *
-	 * Lights are read as three.js lights in RADIOMETRIC units — W/sr for point and spot, W/m² for
-	 * directional, radiance for area — and are left as they are; only an area light's rectangle is
-	 * put into world metres on the copy. See `LightUnits.js`.
+	 * Lights keep three.js units — `RectAreaLight.intensity` in nits, point/spot in candela — and are
+	 * converted to radiant power on the copy. `areaLightIntensityScale` does not apply here.
 	 *
 	 * @param {import('three').Object3D} object3d - The Object3D to render; left untouched.
 	 * @param {string} [name='object3d'] - Display name for the object
@@ -1813,9 +1838,7 @@ export class PathTracerApp extends EventDispatcher {
 		if ( ! this._isRenderSizeSupported( width, height ) ) return;
 
 		this.renderer.setPixelRatio( 1.0 );
-		this.renderer.setSize( width, height, false );
-		this.cameraManager.camera.aspect = width / height;
-		this.cameraManager.camera.updateProjectionMatrix();
+		this._setDisplaySize( width, height );
 
 		const lastW = this.denoisingManager?._lastRenderWidth ?? 0;
 		const lastH = this.denoisingManager?._lastRenderHeight ?? 0;
@@ -1834,7 +1857,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( ! this._isRenderSizeSupported( renderWidth, renderHeight ) ) return;
 
-		this.pipeline?.setSize( renderWidth, renderHeight );
+		this.pipeline?.setSize( this._scaled( renderWidth ), this._scaled( renderHeight ) );
+		// Full size: the denoiser only runs once the camera has stopped.
 		this.denoisingManager?.setRenderSize( renderWidth, renderHeight );
 		this.needsReset = true;
 
@@ -1857,9 +1881,7 @@ export class PathTracerApp extends EventDispatcher {
 		if ( ! this._isRenderSizeSupported( width, height ) ) return null;
 
 		this.renderer.setPixelRatio( 1.0 );
-		this.renderer.setSize( width, height, false );
-		this.cameraManager.camera.aspect = width / height;
-		this.cameraManager.camera.updateProjectionMatrix();
+		this._setDisplaySize( width, height );
 
 		clearTimeout( this._resizeDebounceTimer );
 		this._applyRenderResize( width, height );
@@ -1868,6 +1890,66 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	_scaled( size ) {
+
+		return Math.max( 1, Math.round( size * this._renderScale ) );
+
+	}
+
+	// The wavefront takes its resolution from the canvas backing store, so that is what has to shrink.
+	// updateStyle=false keeps the CSS size, and the browser stretches the smaller frame over it.
+	_setDisplaySize( width, height ) {
+
+		this._displayWidth = width;
+		this._displayHeight = height;
+
+		this.renderer.setSize( this._scaled( width ), this._scaled( height ), false );
+		this.cameraManager.camera.aspect = width / height;
+		this.cameraManager.camera.updateProjectionMatrix();
+
+	}
+
+	// OIDN as the live denoiser rebuilds its network on every size change, so it keeps full size.
+	_interactionRenderScale() {
+
+		if ( this.denoisingManager?.continuousDenoise ) return 1;
+		const scale = Number( this.settings.get( 'interactionRenderScale' ) );
+		return scale > 0 ? Math.min( 1, Math.max( 0.125, scale ) ) : 1;
+
+	}
+
+	// Interaction can start inside PathTracer.render(), where resizing would pull textures out from
+	// under the frame, so the change waits for the next frame boundary. No wake(): the move that
+	// started it already woke the loop, and waking from inside render() would re-enter it.
+	_requestRenderScale( scale ) {
+
+		this._pendingRenderScale = scale;
+
+	}
+
+	_applyPendingRenderScale() {
+
+		if ( this._pendingRenderScale !== null ) this._applyRenderScale( this._pendingRenderScale );
+
+	}
+
+	_applyRenderScale( scale ) {
+
+		this._pendingRenderScale = null;
+		if ( this._disposed || scale === this._renderScale ) return;
+
+		this._renderScale = scale;
+		if ( ! this._displayWidth || ! this._displayHeight ) return;
+
+		this._setDisplaySize( this._displayWidth, this._displayHeight );
+		this.pipeline?.setSize( this._scaled( this._displayWidth ), this._scaled( this._displayHeight ) );
+		// History from the other size would reproject garbage.
+		this.pipeline?.eventBus.emit( 'asvgf:reset' );
+		this.pipeline?.eventBus.emit( 'denoiser:reset' );
+		this.needsReset = true;
+
+	}
+
 	// ═══════════════════════════════════════════════════════════════
 	// Mode Configuration
 	// ═══════════════════════════════════════════════════════════════
@@ -1890,22 +1972,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		// Anything with a SETTING_ROUTES entry must go through settings, not setUniform: set() early-returns on
 		// `prev === value`, so a uniform written behind the map leaves it stale and the next set() silently no-ops.
-		this.settings.setMany( {
-			maxSamples: config.maxSamples,
-			maxBounces: config.bounces,
-			transmissiveBounces: config.transmissiveBounces,
-			maxSubsurfaceSteps: config.maxSubsurfaceSteps,
-			enableAlphaShadows: config.enableAlphaShadows ?? false,
-			// Tier-1 convergence early-stop
-			useAdaptiveSampling: config.useAdaptiveSampling ?? false,
-			noiseThreshold: config.noiseThreshold ?? DEFAULT_STATE.noiseThreshold,
-			adaptiveStopFraction: config.adaptiveStopFraction ?? DEFAULT_STATE.adaptiveStopFraction,
-			adaptiveMinSamples: config.adaptiveMinSamples ?? DEFAULT_STATE.adaptiveMinSamples,
-			// Tier-2 per-pixel freeze
-			usePixelFreeze: config.usePixelFreeze ?? false,
-			pixelFreezeThreshold: config.pixelFreezeThreshold ?? DEFAULT_STATE.pixelFreezeThreshold,
-			pixelFreezeStability: config.pixelFreezeStability ?? DEFAULT_STATE.pixelFreezeStability,
-		}, { silent: true, source: SETTING_SOURCE.MODE_PRESET } );
+		this.settings.setMany( modePresetSettings( config ), { silent: true, source: SETTING_SOURCE.MODE_PRESET } );
 
 		// renderMode has no SETTING_ROUTES entry
 		this.stages.pathTracer?.setUniform( 'renderMode', parseInt( config.renderMode ) );
@@ -2015,7 +2082,7 @@ export class PathTracerApp extends EventDispatcher {
 	 * - `_bounceEarlyExitThreshold` / `_useDynamicDispatch` both consume the async
 	 *   survivor curve. Kernels bind on ENTERING_COUNT, so an under-sized grid silently
 	 *   drops rays, and the frame a readback lands on is GPU-scheduled.
-	 * - `interactionModeEnabled` is a 100 ms timer that clamps bounces to 1, disables
+	 * - `interactionModeEnabled` is a 100 ms timer that lowers the render resolution, disables
 	 *   accumulation and freezes frameCount; it engages on the very first frame.
 	 * - auto-focus raycasts per frame and auto-exposure adapts off `performance.now()`.
 	 *
@@ -2263,15 +2330,23 @@ export class PathTracerApp extends EventDispatcher {
 	 * the viewport shows.
 	 *
 	 * @param {Object} [options]
-	 * @param {'linear'|'srgb'} [options.colorSpace='srgb']
+	 * @param {string} [options.colorSpace='srgb'] - `'srgb'` for display bytes through the active
+	 *   view transform, `'linear'` for the raw working-space accumulation, or the name of a colour
+	 *   space in the loaded OCIO config for a delivery buffer (float, e.g. `'ACES2065-1'`)
 	 * @param {boolean} [options.preserveAlpha=false] - srgb only
+	 * @param {'accumulation'|'display'} [options.source='accumulation'] - `'display'` reads what the
+	 *   viewport is showing — denoised when a denoiser has run, without bloom — instead of the raw
+	 *   accumulation
 	 * @returns {Promise<{data: Float32Array|Uint8ClampedArray, width: number, height: number, colorSpace: string}>}
 	 */
-	async renderToBuffer( { colorSpace = 'srgb', preserveAlpha = false } = {} ) {
+	async renderToBuffer( { colorSpace = 'srgb', preserveAlpha = false, source = 'accumulation' } = {} ) {
 
-		if ( colorSpace !== 'linear' && colorSpace !== 'srgb' ) {
+		const named = colorSpace !== 'linear' && colorSpace !== 'srgb';
+		if ( named && ! this.color?.hasConfig ) {
 
-			throw new Error( `renderToBuffer: colorSpace must be 'linear' or 'srgb', got "${colorSpace}"` );
+			throw new Error(
+				`renderToBuffer: colorSpace must be 'linear' or 'srgb' without a colour config loaded, got "${colorSpace}"`
+			);
 
 		}
 
@@ -2282,9 +2357,27 @@ export class PathTracerApp extends EventDispatcher {
 		// The pool over-allocates to the reserve, so the texture is larger than the frame.
 		const { width, height } = stage;
 
-		const linear = await this.renderer.readRenderTargetPixelsAsync( target, 0, 0, width, height, 0 );
+		const linear = source === 'display'
+			? await this._readDisplaySource( target, width, height )
+			: await this.renderer.readRenderTargetPixelsAsync( target, 0, 0, width, height, 0 );
 
-		if ( colorSpace === 'linear' ) return { data: linear, width, height, colorSpace };
+		// `colorSpace` stays 'linear' — callers branch on it. `workingSpace` is the new, additive
+		// answer to "linear in what primaries", which only means something once a config is loaded.
+		if ( colorSpace === 'linear' ) {
+
+			return { data: linear, width, height, colorSpace, workingSpace: this.color?.workingSpace ?? null };
+
+		}
+
+		// A named space is a delivery buffer, not a picture: scene-referred float in whatever the
+		// config calls that space. Saving an EXR for a compositor and grading through an sRGB view
+		// on screen are different questions, and this is the one that answers the first.
+		if ( named ) {
+
+			const { rgba, colorSpace: got } = this.color.exportPixels( linear, colorSpace );
+			return { data: rgba, width, height, colorSpace: got };
+
+		}
 
 		return {
 			data: toneMapToRGBA8( linear, {
@@ -2716,6 +2809,20 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/**
+	 * Where a material property's value came from: `'material'` (the three.js material carried
+	 * it), `'mapped'` (converted from a Basic/Lambert/Phong/Toon material), `'default'` (the model
+	 * never said; filled from MATERIAL_DEFAULTS) or `'host'` (set through setMaterialProperty).
+	 * @param {number} materialIndex
+	 * @param {string} property
+	 * @returns {string|undefined}
+	 */
+	getMaterialPropertySource( materialIndex, property ) {
+
+		return this.stages.pathTracer?.materialData.getMaterialPropertySource( materialIndex, property );
+
+	}
+
 	setMaterialProperty( materialIndex, property, value ) {
 
 		this.stages.pathTracer?.materialData.updateMaterialProperty( materialIndex, property, value );
@@ -2868,6 +2975,163 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/**
+	 * What the Compositor is drawing from, as linear float. Falls back to the accumulation when no
+	 * denoiser has published anything, which is also what the viewport shows then.
+	 * @private
+	 */
+	async _readDisplaySource( accumulation, width, height ) {
+
+		const context = this.pipeline?.context;
+		const texture = context && this.stages.compositor?.resolveLightTexture( context );
+		if ( ! texture || texture === accumulation.texture ) {
+
+			return await this.renderer.readRenderTargetPixelsAsync( accumulation, 0, 0, width, height, 0 );
+
+		}
+
+		this._textureReadback ??= new TextureReadback( this.renderer );
+		return await this._textureReadback.read( texture, width, height );
+
+	}
+
+	/**
+	 * Set what colour space one texture is in, then rebuild so it takes effect.
+	 *
+	 * The per-image colour space every OCIO application offers. Three kinds of answer:
+	 *   - `null`             — automatic: tag, override, the config's file rules, then three.js
+	 *   - `'srgb'`/`'linear'` — three.js's own two, which work with no config at all
+	 *   - a config space     — anything the loaded config names, including log and camera spaces
+	 *
+	 * A config space is carried as `userData.ocioColorSpace`, and the texture's three.js colour space
+	 * is set to match the colour pool while it is, so harmonization leaves the stored bytes as the
+	 * author wrote them — the named transform has to read them raw. The original is kept and put
+	 * back when the choice is cleared.
+	 *
+	 * @param {import('three').Texture} texture
+	 * @param {?string} choice
+	 */
+	async setTextureColorSpace( texture, choice ) {
+
+		if ( ! texture?.isTexture ) throw new Error( 'setTextureColorSpace wants a three.js texture' );
+
+		const ud = texture.userData ?? ( texture.userData = {} );
+		if ( ud.__rayzeeOriginalColorSpace === undefined ) ud.__rayzeeOriginalColorSpace = texture.colorSpace;
+		const original = ud.__rayzeeOriginalColorSpace;
+
+		delete ud.ocioColorSpace;
+		delete ud.__rayzeeColorSpaceChoice;
+
+		if ( choice === null || choice === undefined ) {
+
+			texture.colorSpace = original;
+			delete ud.__rayzeeOriginalColorSpace;
+
+		} else if ( choice === 'srgb' || choice === 'linear' ) {
+
+			texture.colorSpace = choice === 'srgb' ? SRGBColorSpace : LinearSRGBColorSpace;
+			ud.__rayzeeColorSpaceChoice = choice;
+
+		} else {
+
+			if ( ! this.color?.hasConfig ) throw new Error( `"${choice}" needs a colour config loaded` );
+			ud.ocioColorSpace = choice;
+			texture.colorSpace = SRGBColorSpace;
+
+		}
+
+		texture.needsUpdate = true;
+		if ( this.stages.pathTracer?.sdfs ) await this.rebuildMaterials();
+
+	}
+
+	/**
+	 * Load a colour config, keeping the scene consistent with it.
+	 *
+	 * Prefer this to `app.color.loadConfig()` whenever a scene is loaded. A working space adopted
+	 * under the previous config is undone first, *while that config is still loaded* — the
+	 * environment is converted in place, and only the config that converted it can convert it
+	 * back. With `adoptWorkingSpace` the scene is rebuilt in the new space afterwards.
+	 *
+	 * @param {Object} options - as `ColorManagement.loadConfig`
+	 * @returns {Promise<Object>} the config description
+	 */
+	async loadColorConfig( options = {} ) {
+
+		await this._leaveColorWorkingSpace();
+		const shown = getViewTransform( this.renderer?.toneMapping );
+		const described = await this.color.loadConfig( options );
+		if ( this.color.workingSpaceAdopted ) await this.applyColorWorkingSpace();
+		// A baked view the config kept is still what is on screen.
+		const kept = shown?.source === 'ocio' && getViewTransform( this.renderer?.toneMapping ) === shown;
+		if ( ! kept || this.color.workingSpaceAdopted ) this.reset();
+		return described;
+
+	}
+
+	/** Unload the colour config, putting the scene back into linear Rec.709 first. */
+	async unloadColorConfig() {
+
+		await this._leaveColorWorkingSpace();
+		this.color.unloadConfig();
+		this.reset();
+
+	}
+
+	/** @private */
+	async _leaveColorWorkingSpace() {
+
+		if ( ! this.color?.workingSpaceAdopted ) return;
+		this.color.setWorkingSpace( null );
+		await this.applyColorWorkingSpace();
+
+	}
+
+	/**
+	 * Rebuild everything the working space touches, after it has been changed.
+	 *
+	 * Changing what the engine renders in is not a display setting — it changes what every texture,
+	 * tint and light colour already loaded *means*. Textures and materials are re-packed from their
+	 * pristine three.js sources, so they convert cleanly; the environment is converted where it
+	 * lies, from whichever space it currently holds, and its importance-sampling table is rebuilt
+	 * because its pixels moved.
+	 *
+	 * Call this after `app.color.setWorkingSpace()`. Doing nothing instead leaves a scene half in
+	 * one space and half in another, which reads as a colour cast with no obvious cause.
+	 */
+	async applyColorWorkingSpace() {
+
+		const env = this.environmentManager?.getEnvironmentTexture?.();
+		let envChanged = false;
+
+		if ( env && this.color?.hasConfig ) {
+
+			try {
+
+				envChanged = this.color.convertTexturePixels( env );
+
+			} catch ( error ) {
+
+				log.warn( `environment colour conversion failed: ${error.message}` );
+
+			}
+
+		}
+
+		// Nothing to rebuild before a scene exists; anything loaded later converts on its way in.
+		if ( this.stages.pathTracer?.sdfs ) {
+
+			await this.rebuildMaterials();
+			this._uploadEmissivePayload( this._sdf?.rebuildEmissiveColors?.() ?? null );
+
+		}
+
+		if ( envChanged ) await this.environmentManager?.buildEnvironmentCDF?.();
+
+		this.reset();
+
+	}
+
 	/**
 	 * Full material rebuild (required after texture changes).
 	 * @param {import('three').Scene} [scene]
@@ -2995,6 +3259,11 @@ export class PathTracerApp extends EventDispatcher {
 		this.renderer.toneMappingExposure = 1.0;
 		this.renderer.setPixelRatio( 1.0 );
 
+		// Hands every registered view transform to the renderer and keeps `outputColorSpace` in
+		// step with whichever is selected — an OCIO view already encoded for its display must not
+		// be encoded a second time by the output pass.
+		this.color.attachRenderer( this.renderer );
+
 	}
 
 	_initCameraManager() {
@@ -3028,6 +3297,8 @@ export class PathTracerApp extends EventDispatcher {
 		this._addTrackedListener( this.cameraManager.controls, 'change', () => {
 
 			this.needsReset = true;
+			// Here rather than in render(), so the first frame of the move is already at the lower resolution.
+			this.stages.pathTracer?.enterInteractionMode();
 			this.wake();
 
 		} );
@@ -3054,8 +3325,15 @@ export class PathTracerApp extends EventDispatcher {
 
 		const initRenderW = this.canvas.clientWidth || 1;
 		const initRenderH = this.canvas.clientHeight || 1;
+		this._displayWidth = initRenderW;
+		this._displayHeight = initRenderH;
 		this.pipeline.setSize( initRenderW, initRenderH );
 
+		this.pipeline.eventBus.on( 'pathtracer:interactionStart', () => this._requestRenderScale( this._interactionRenderScale() ) );
+		// Never fires inside a frame (a timer, or interaction mode being switched off), so it applies at once —
+		// renderFrames() and the video renderer drive pipeline.render() without passing through animate().
+		this.pipeline.eventBus.on( 'pathtracer:interactionEnd', () => this._applyRenderScale( 1 ) );
+
 	}
 
 	async _initManagers() {
@@ -3176,6 +3454,11 @@ export class PathTracerApp extends EventDispatcher {
 			reconcileCompletion: () => this._reconcileCompletion(),
 			denoisingManager: this.denoisingManager,
 			cameraManager: this.cameraManager,
+			onInteractionRenderScale: () => {
+
+				if ( this.stages.pathTracer?.interactionMode ) this._requestRenderScale( this._interactionRenderScale() );
+
+			},
 		} );
 
 		this.renderer.toneMappingExposure = this.settings.get( 'exposure' ) ?? 1.0;

package/src/Processor/AssetLoader.js

@@ -19,7 +19,6 @@ import { getAssetConfig } from '../AssetConfig.js';
 import { loadPBRTScene, pickEntryPath } from './PBRT/index.js';
 import { extractSceneMetadata } from './SceneMetadata.js';
 import { ISSUE_CODES, ISSUE_SEVERITY } from '../EngineIssues.js';
-import { bakeAreaLightScale, LUMENS_PER_WATT } from '../LightUnits.js';
 import { getRenderProfile } from '../EngineDefaults.js';
 
 // Define supported file formats
@@ -68,43 +67,19 @@ function standInForSplit( source ) {
 
 }
 
-const PLACEHOLDER_SHAPES = new Set( [ 'rectangle', 'square', 'disk', 'ellipse' ] );
+// Luminous efficacy glTF, three.js and Blender's exporter all assume (PBR_WATTS_TO_LUMENS).
+const LUMENS_PER_WATT = 683;
 
-/**
- * Build the light a placeholder node stands for. glTF has no area light, so a three.js host's
- * patched GLTFExporter writes the RectAreaLight into the node's `extras` and leaves the node
- * itself carrying the transform. `intensity` is three.js radiance, which is what the engine
- * stores, so the number is used as authored; only the rectangle needs normalising to world
- * metres (see `bakeAreaLightScale`).
- *
- * `power`, `position`, `rotation` and `direction` are present in the record and deliberately
- * unused. The node's matrix already carries the transform, `direction` is not even normalised,
- * and `power` was written from the light's UNSCALED dimensions — on 24155522.glb's window light,
- * whose ancestor scale is non-uniform (1.6 × 1.2 m in world, not 1.2 × 1.2), it is 25 % low.
- *
- * @returns {RectAreaLight|null} null when the record carries no usable size or intensity.
- */
-function areaLightFromPlaceholder( node, record ) {
+// three.js nits → the engine's radiant power, inverting areaLightRadiance.
+function areaLightPowerFactor( node, width, height, userData ) {
 
-	const width = Number( record.width );
-	const height = Number( record.height );
-	const intensity = Number( record.intensity );
-	if ( ! ( width > 0 ) || ! ( height > 0 ) || ! Number.isFinite( intensity ) ) return null;
+	if ( ! ( userData.normalize ?? true ) ) return Math.PI;
 
-	const shape = PLACEHOLDER_SHAPES.has( record.shape ) ? record.shape : 'rectangle';
-	const color = Array.isArray( record.color ) && record.color.length >= 3 ? record.color : [ 1, 1, 1 ];
-
-	const light = new RectAreaLight( new Color( ...color ), intensity, width, height );
-	light.name = record.name || 'RectAreaLight';
-	light.userData.normalize = record.normalize ?? true;
-	light.userData.spread = Number.isFinite( record.spread ) ? record.spread : Math.PI;
-	light.userData.shape = shape;
-
-	// Parented before baking: the bake needs the node's world scale, and on the append path
-	// nothing has refreshed the tree yet.
-	node.add( light );
-	bakeAreaLightScale( light );
-	return light;
+	const shapeFactor = userData.shape === 'ellipse' || userData.shape === 'disk' ? Math.PI / 4 : 1;
+	const scale = node.getWorldScale( new Vector3() );
+	// abs: a mirrored ancestor decomposes negative; the serializer takes the area as |u × v|.
+	const factor = Math.PI * shapeFactor * Math.abs( width * scale.x * height * scale.y );
+	return Number.isFinite( factor ) ? factor : Math.PI;
 
 }
 
@@ -876,8 +851,7 @@ export class AssetLoader extends EventDispatcher {
 		this.targetModel = group;
 
 		// The light's own orientation and `scale` are already baked into the texture, so the
-		// scene is only correct at rotation 0 / intensity 1. Without this the viewer profile's
-		// default 270° rotation lands on top and the sky sits 90° from where pbrt puts it.
+		// scene is only correct at rotation 0 / intensity 1 — pinned, whatever the host's defaults.
 		if ( environment?.texture ) this.sceneMetadata = { environment: { rotation: 0, intensity: 1 } };
 
 		updateLoading( { isLoading: true, status: 'Processing PBRT geometry...', progress: 10 } );
@@ -2109,18 +2083,22 @@ export class AssetLoader extends EventDispatcher {
 
 			const userData = object.userData;
 
-			// three.js states RectAreaLight.intensity as radiance, which is what the engine
-			// stores, so only the rectangle needs putting into world metres.
-			if ( object.isRectAreaLight ) bakeAreaLightScale( object );
+			// An adopted light carries three.js units; convert as point/spot are below.
+			if ( object.isRectAreaLight && ! userData.__radianceConverted ) {
+
+				object.intensity *= areaLightPowerFactor( object, object.width, object.height, userData );
+				userData.__radianceConverted = true;
+
+			}
 
 			// Punctual lights arrive photometric: glTF (and three.js) state point/spot in
-			// candela and directional in lux. The engine keeps the same QUANTITY in radiometric
-			// units — W/sr and W/m² — so only the luminous efficacy is divided back out, which
-			// is what Blender's own glTF importer does. Skipping it rendered every Blender lamp
-			// 683x too bright.
+			// candela and directional in lux. The engine is radiometric Blender Watts, which
+			// LightSerializer turns into W/sr with ÷4π, so the luminous efficacy has to be
+			// divided back out — Blender's own glTF importer does exactly this. Skipping it
+			// rendered every Blender lamp 683x too bright.
 			if ( ( object.isPointLight || object.isSpotLight ) && ! userData.__candelaConverted ) {
 
-				object.intensity /= LUMENS_PER_WATT;
+				object.intensity *= 4 * Math.PI / LUMENS_PER_WATT;
 				userData.__candelaConverted = true;
 
 			}
@@ -2132,17 +2110,31 @@ export class AssetLoader extends EventDispatcher {
 
 			}
 
-			// An area light serialized into a placeholder node. Keyed on the record's own type
-			// rather than the node's name, so a renamed placeholder still lights the scene.
-			if ( userData.type === 'RectAreaLight' ) {
+			// Process ceiling lights
+			if ( object.name.startsWith( 'RectAreaLightPlaceholder' ) &&
+				userData.name
+				// && userData.name.includes( "ceilingLight" )
+			) {
+
+				if ( userData.type === 'RectAreaLight' ) {
+
+					const normalize = userData.normalize ?? true;
+					const shape = userData.shape ?? 'rectangle';
+					const power = userData.intensity * areaLightPowerFactor( object, userData.width, userData.height, userData );
+					const light = new RectAreaLight(
+						new Color( ...userData.color ),
+						power * this._profile.areaLightIntensityScale,
+						userData.width,
+						userData.height
+					);
+					light.userData.normalize = normalize;
+					light.userData.spread = Number.isFinite( userData.spread ) ? userData.spread : Math.PI;
+					light.userData.shape = shape;
+					light.userData.__radianceConverted = true; // already power, and traverse() reaches it
+					light.name = userData.name;
+					object.add( light );
 
-				const light = areaLightFromPlaceholder( object, userData );
-				if ( ! light ) this._issues?.record(
-					ISSUE_CODES.LIGHT_PLACEHOLDER_INVALID,
-					`area-light placeholder "${object.name}" carries no usable size or intensity`,
-					{ node: object.name, record: userData },
-					ISSUE_SEVERITY.WARNING,
-				);
+				}
 
 			}