rayzee 8.4.1 → 8.5.0

package/src/Stages/PathTracerStage.js

@@ -298,18 +298,6 @@ export class PathTracerStage extends RenderStage {
 		const self = this;
 		const materialInterface = {
 			uniforms: {
-				maxBounceCount: {
-					get value() {
-
-						return self.maxBounces.value;
-
-					},
-					set value( v ) {
-
-						self.maxBounces.value = v;
-
-					}
-				},
 				enableAccumulation: {
 					get value() {
 
@@ -322,15 +310,15 @@ export class PathTracerStage extends RenderStage {
 
 					}
 				},
-				enableEmissiveTriangleSampling: {
+				fireflyThreshold: {
 					get value() {
 
-						return self.enableEmissiveTriangleSampling.value;
+						return self.fireflyThreshold.value;
 
 					},
 					set value( v ) {
 
-						self.enableEmissiveTriangleSampling.value = v;
+						self.fireflyThreshold.value = v;
 
 					}
 				},
@@ -351,11 +339,16 @@ export class PathTracerStage extends RenderStage {
 
 		this.cameraOptimizer = new CameraOptimizer( this.renderer, materialInterface, {
 			enabled: DEFAULT_STATE.interactionModeEnabled,
+			// Nothing that costs light: the app lowers the resolution instead (PathTracerApp._applyRenderScale).
+			// The firefly limit grows with sqrt(frame + 1), and every moving frame is frame 0, where it clipped
+			// ~10% of an emissive-lit interior's light. ×8 is the limit a still image reaches at 64 samples:
+			// lowest large-area error of the values measured, and half the extra grain of turning it off.
 			qualitySettings: {
-				maxBounceCount: 1,
 				enableAccumulation: false,
-				enableEmissiveTriangleSampling: false,
+				fireflyThreshold: ( threshold ) => threshold * 8,
 			},
+			onEnter: () => this.emit( 'pathtracer:interactionStart' ),
+			onExit: () => this.emit( 'pathtracer:interactionEnd' ),
 			onReset: () => {
 
 				this.reset();

package/src/index.js

@@ -18,7 +18,6 @@ export { EngineEvents } from './EngineEvents.js';
 export { renderHeadless, openHeadless, captureHeadless } from './Headless.js';
 
 // Degradation contract — what the engine survived instead of failing on
-export { LUMENS_PER_WATT, areaLightArea, bakeAreaLightScale, lightPower, preserveLightPower, setLightPower } from './LightUnits.js';
 export { ISSUE_CODES, ISSUE_SEVERITY, IssueLog, EngineIssueError } from './EngineIssues.js';
 
 // Settings provenance + viewer-vs-physical tuning

package/src/managers/DenoisingManager.js

@@ -836,14 +836,10 @@ export class DenoisingManager extends EventDispatcher {
 		if ( this.upscalerCanvas ) this.upscalerCanvas.style.display = 'none';
 		if ( this.mainCanvas ) this.mainCanvas.style.opacity = '1';
 
-		if ( wasShowing ) {
+		// The nominal size, not the path tracer's: that one is smaller while the camera moves.
+		if ( wasShowing && this._lastRenderWidth && this._lastRenderHeight ) {
 
-			const stage = this._stages?.pathTracer;
-			if ( stage?.width && stage?.height ) {
-
-				this.dispatchEvent( { type: 'resolution_changed', width: stage.width, height: stage.height } );
-
-			}
+			this.dispatchEvent( { type: 'resolution_changed', width: this._lastRenderWidth, height: this._lastRenderHeight } );
 
 		}
 

package/src/managers/LightManager.js

@@ -2,7 +2,6 @@ import {
 	EventDispatcher, DirectionalLight, PointLight, SpotLight, RectAreaLight,
 	Object3D, MathUtils
 } from 'three';
-import { bakeAreaLightScale, lightPower, setLightPower } from '../LightUnits.js';
 
 /**
  * Manages scene lights: add, remove, transfer from mesh scene to WebGPU
@@ -38,13 +37,12 @@ export class LightManager extends EventDispatcher {
 	 */
 	addLight( type ) {
 
-		// Authored as Blender Power in Watts (the Sun as W/m²), converted to the stored
-		// quantity by setLightPower() once the light exists — see LightUnits.js.
 		const defaults = {
-			DirectionalLight: { position: [ 1, 1, 1 ], power: 1.0, color: '#ffffff' },
-			PointLight: { position: [ 0, 2, 0 ], power: 1000, color: '#ffffff' },
-			SpotLight: { position: [ 0, 1, 0 ], power: 1000, color: '#ffffff', angle: 15 },
-			RectAreaLight: { position: [ 0, 2, 0 ], power: 100, color: '#ffffff', width: 2, height: 2 }
+			// Power in Watts (Blender-style) for point/spot/area; Sun is W/m² strength.
+			DirectionalLight: { position: [ 1, 1, 1 ], intensity: 1.0, color: '#ffffff' },
+			PointLight: { position: [ 0, 2, 0 ], intensity: 1000, color: '#ffffff' },
+			SpotLight: { position: [ 0, 1, 0 ], intensity: 1000, color: '#ffffff', angle: 15 },
+			RectAreaLight: { position: [ 0, 2, 0 ], intensity: 100, color: '#ffffff', width: 2, height: 2 }
 		};
 
 		const props = defaults[ type ];
@@ -54,17 +52,17 @@ export class LightManager extends EventDispatcher {
 
 		if ( type === 'DirectionalLight' ) {
 
-			light = new DirectionalLight( props.color, 1 );
+			light = new DirectionalLight( props.color, props.intensity );
 			light.position.fromArray( props.position );
 
 		} else if ( type === 'PointLight' ) {
 
-			light = new PointLight( props.color, 1 );
+			light = new PointLight( props.color, props.intensity );
 			light.position.fromArray( props.position );
 
 		} else if ( type === 'SpotLight' ) {
 
-			light = new SpotLight( props.color, 1 );
+			light = new SpotLight( props.color, props.intensity );
 			light.position.fromArray( props.position );
 			light.angle = MathUtils.degToRad( props.angle );
 			const target = new Object3D();
@@ -73,7 +71,7 @@ export class LightManager extends EventDispatcher {
 
 		} else if ( type === 'RectAreaLight' ) {
 
-			light = new RectAreaLight( props.color, 1, props.width, props.height );
+			light = new RectAreaLight( props.color, props.intensity, props.width, props.height );
 			light.position.fromArray( props.position );
 			light.lookAt( 0, 0, 0 );
 			// Blender-style emission defaults: power-normalized, full Lambertian
@@ -84,8 +82,6 @@ export class LightManager extends EventDispatcher {
 
 		}
 
-		setLightPower( light, props.power );
-
 		// Blender-style emission controls common to every light type.
 		light.userData.temperature = 6500;
 		light.userData.useTemperature = false;
@@ -182,7 +178,13 @@ export class LightManager extends EventDispatcher {
 			light.getWorldQuaternion( cloned.quaternion );
 			light.getWorldScale( cloned.scale );
 
-			if ( cloned.isRectAreaLight ) bakeAreaLightScale( cloned );
+			if ( cloned.isRectAreaLight ) {
+
+				cloned.width *= cloned.scale.x;
+				cloned.height *= cloned.scale.y;
+				cloned.scale.set( 1, 1, 1 );
+
+			}
 
 			if ( ( light.isSpotLight || light.isDirectionalLight ) && light.target ) {
 
@@ -336,7 +338,7 @@ export class LightManager extends EventDispatcher {
 			name: light.name,
 			type: light.type,
 			visible: light.visible,
-			intensity: lightPower( light ), // Blender Power (W); the light stores the three.js quantity
+			intensity: light.intensity,
 			color: `#${light.color.getHexString()}`,
 			position: [ light.position.x, light.position.y, light.position.z ],
 			angle,

package/src/managers/VideoRenderManager.js

@@ -7,7 +7,7 @@
  */
 
 import { EngineEvents } from '../EngineEvents.js';
-import { PRODUCTION_RENDER_CONFIG } from '../EngineDefaults.js';
+import { PRODUCTION_RENDER_CONFIG, modePresetSettings } from '../EngineDefaults.js';
 import { updateStats, getDisplaySamples } from '../Processor/utils.js';
 
 export class VideoRenderManager {
@@ -273,11 +273,11 @@ export class VideoRenderManager {
 	_saveState() {
 
 		const app = this._app;
+		const effective = app.settings.getEffective();
 
 		return {
-			maxSamples: app.settings.get( 'maxSamples' ),
-			maxBounces: app.settings.get( 'maxBounces' ),
-			transmissiveBounces: app.settings.get( 'transmissiveBounces' ),
+			// Everything configureForMode( 'production' ) overwrites, with who set it.
+			settings: Object.keys( modePresetSettings( PRODUCTION_RENDER_CONFIG ) ).map( key => [ key, effective[ key ] ] ),
 			renderMode: app.stages.pathTracer?.renderMode?.value,
 			controlsEnabled: app.cameraManager.controls?.enabled,
 			oidnEnabled: app.denoisingManager?.finalDenoise,
@@ -296,11 +296,11 @@ export class VideoRenderManager {
 
 		const app = this._app;
 
-		app.settings.setMany( {
-			maxSamples: state.maxSamples,
-			maxBounces: state.maxBounces,
-			transmissiveBounces: state.transmissiveBounces,
-		}, { silent: true } );
+		for ( const [ key, saved ] of state.settings ) {
+
+			if ( saved ) app.settings.set( key, saved.value, { silent: true, reset: false, source: saved.source } );
+
+		}
 
 		if ( app.stages.pathTracer && state.renderMode !== undefined ) {
 

package/src/LightUnits.js

@@ -1,122 +0,0 @@
-/**
- * The engine's light-unit rule, stated once.
- *
- * Every light in the scene graph is a **valid three.js light**: it carries the quantity three.js
- * expects for its type, measured in radiometric (watt-based) units rather than photometric ones.
- *
- *   point / spot  → radiant intensity   W/sr
- *   directional   → irradiance          W/m²
- *   rect area     → radiance            W/(sr·m²), `width`/`height` in world metres, unit scale
- *
- * three.js' shading maths is unit-agnostic — it divides by distance² and integrates a form factor,
- * never caring whether the number it was handed is candela or W/sr. Feeding it radiometric values
- * therefore makes the raster fallback, the light helpers and any host reading `sceneModel` correct
- * without one of them knowing anything about the path tracer.
- *
- * Blender-style **Power in Watts** — what the Lights panel edits — is a view of that, converted
- * here and nowhere else. `LightSerializer` converts the other way when it fills the GPU buffer.
- */
-
-/** Luminous efficacy that glTF, three.js and Blender's exporter all assume (lm/W). */
-export const LUMENS_PER_WATT = 683;
-
-/** Emitting area in m², including the ellipse/disk shape factor. Assumes unit world scale. */
-export function areaLightArea( light ) {
-
-	const shape = light.userData?.shape;
-	const shapeFactor = shape === 'ellipse' || shape === 'disk' ? Math.PI / 4 : 1;
-	const area = Math.abs( light.width * light.height ) * shapeFactor;
-	return Number.isFinite( area ) && area > 0 ? area : 0;
-
-}
-
-/**
- * Blender-style Power for the Lights panel: radiant power in W for point, spot and area lights,
- * and the Sun's strength in W/m² unchanged.
- */
-export function lightPower( light ) {
-
-	if ( light.isRectAreaLight ) {
-
-		const normalize = light.userData?.normalize ?? true;
-		return light.intensity * Math.PI * ( normalize ? areaLightArea( light ) : 1 );
-
-	}
-
-	if ( light.isPointLight || light.isSpotLight ) return light.intensity * 4 * Math.PI;
-
-	return light.intensity;
-
-}
-
-/** Inverse of {@link lightPower} — what the panel writes back. */
-export function setLightPower( light, watts ) {
-
-	if ( light.isRectAreaLight ) {
-
-		const normalize = light.userData?.normalize ?? true;
-		const denominator = Math.PI * ( normalize ? areaLightArea( light ) : 1 );
-		light.intensity = denominator > 0 ? watts / denominator : 0;
-		return;
-
-	}
-
-	if ( light.isPointLight || light.isSpotLight ) {
-
-		light.intensity = watts / ( 4 * Math.PI );
-		return;
-
-	}
-
-	light.intensity = watts;
-
-}
-
-/**
- * Runs `mutate` with the light's Power held constant.
- *
- * Resizing a normalized area light is meant to keep its total power and change its radiance —
- * Blender's Normalize toggle. Since the stored quantity is radiance, that only happens if the
- * edit puts the Power back afterwards. With Normalize off, Power does not depend on the area,
- * so this is a no-op and the same call is still correct.
- */
-export function preserveLightPower( light, mutate ) {
-
-	const watts = lightPower( light );
-	mutate();
-	setLightPower( light, watts );
-
-}
-
-/**
- * Puts an area light's rectangle in world metres with unit scale, leaving its world size and
- * placement untouched.
- *
- * ⚠️ three.js' rasteriser reads `width`/`height` as WORLD dimensions and drops any scale inherited
- * from parent nodes — `RectAreaLightNode` builds the light's basis with `extractRotation`, which
- * normalises the scale away. A light authored as 70 units under a 0.01 node scale therefore rasters
- * as a **70 metre** panel while the path tracer, which uses the world matrix, renders the 0.7 m one
- * it should. Measured on 24001884.glb: 58.7x too bright in the raster view. Baking the scale in and
- * cancelling it on the light itself makes every reader agree.
- *
- * Idempotent: a light already at unit scale is left alone, so re-processing a tree is safe.
- */
-export function bakeAreaLightScale( light ) {
-
-	light.updateWorldMatrix( true, false );
-
-	// Column lengths of the world matrix, read directly so this module needs no three.js import.
-	const e = light.matrixWorld.elements;
-	const sx = Math.hypot( e[ 0 ], e[ 1 ], e[ 2 ] );
-	const sy = Math.hypot( e[ 4 ], e[ 5 ], e[ 6 ] );
-	const sz = Math.hypot( e[ 8 ], e[ 9 ], e[ 10 ] );
-
-	if ( ! Number.isFinite( sx ) || ! Number.isFinite( sy ) || sx === 0 || sy === 0 ) return;
-	if ( Math.abs( sx - 1 ) < 1e-9 && Math.abs( sy - 1 ) < 1e-9 ) return;
-
-	light.width = Math.abs( light.width * sx );
-	light.height = Math.abs( light.height * sy );
-	light.scale.set( light.scale.x / sx, light.scale.y / sy, sz === 0 ? light.scale.z : light.scale.z / sz );
-	light.updateMatrixWorld( true );
-
-}