rayzee 8.4.1 → 8.6.0

package/src/Processor/CameraOptimizer.js

@@ -19,12 +19,11 @@ export class CameraOptimizer {
 		this.interactionMode = false;
 		this.interactionTimeout = null;
 		this.originalValues = {};
+		this.appliedValues = {};
 		this.wasAccumulationEnabled = true; // Track original accumulation state
 
 		// Enhanced interaction mode settings for reduced quality during interaction
 		this.interactionQualitySettings = {
-			maxBounceCount: 1,
-			// pixelRatio: 0.25,
 			enableAccumulation: false,
 			...settings.qualitySettings
 		};
@@ -54,6 +53,7 @@ export class CameraOptimizer {
 			// Enter interaction mode and save original values
 			this.interactionMode = true;
 			this.originalValues = {}; // Reset stored values
+			this.appliedValues = {};
 
 			// Store original accumulation state before any changes
 			if ( this.material.uniforms.enableAccumulation ) {
@@ -80,7 +80,8 @@ export class CameraOptimizer {
 
 					// Handle material uniforms
 					this.originalValues[ key ] = this.material.uniforms[ key ].value;
-					this.material.uniforms[ key ].value = this.interactionQualitySettings[ key ];
+					this.material.uniforms[ key ].value = this._resolveQualityValue( key, this.interactionQualitySettings[ key ] );
+					this.appliedValues[ key ] = this.material.uniforms[ key ].value;
 
 				}
 
@@ -136,8 +137,13 @@ export class CameraOptimizer {
 
 			} else if ( this.material.uniforms[ key ] ) {
 
-				// Restore material uniforms
-				this.material.uniforms[ key ].value = this.originalValues[ key ];
+				// A value written while we held it (a settings change) is newer than the one we saved.
+				const applied = this.appliedValues[ key ];
+				if ( applied === undefined || this.material.uniforms[ key ].value === applied ) {
+
+					this.material.uniforms[ key ].value = this.originalValues[ key ];
+
+				}
 
 			}
 
@@ -145,6 +151,7 @@ export class CameraOptimizer {
 
 		this.interactionMode = false;
 		this.originalValues = {}; // Clear stored values
+		this.appliedValues = {};
 
 		// Call exit callback first (this may trigger a reset)
 		if ( this.onExitCallback ) {
@@ -213,7 +220,8 @@ export class CameraOptimizer {
 
 				} else if ( this.material.uniforms[ key ] ) {
 
-					this.material.uniforms[ key ].value = settings[ key ];
+					this.material.uniforms[ key ].value = this._resolveQualityValue( key, settings[ key ] );
+					this.appliedValues[ key ] = this.material.uniforms[ key ].value;
 
 				}
 
@@ -223,6 +231,14 @@ export class CameraOptimizer {
 
 	}
 
+	// A function derives the interaction value from the one it replaces.
+	_resolveQualityValue( key, target ) {
+
+		if ( typeof target !== 'function' ) return target;
+		return target( this.originalValues[ key ] ?? this.material.uniforms[ key ].value );
+
+	}
+
 	/**
      * Set the interaction delay
      * @param {number} delay - Delay in milliseconds

package/src/Processor/EmissiveTriangleBuilder.js

@@ -10,6 +10,28 @@ import { DataTexture, RGBAFormat, FloatType, NearestFilter } from 'three';
 import { TRIANGLE_DATA_LAYOUT, TRI_MATERIAL_MASK } from '../EngineDefaults.js';
 import { LightBVHBuilder } from './LightBVHBuilder.js';
 import { createLogger, fmt } from '../utils/Logger.js';
+import { convertLinearTriple, getWorkingMatrix } from '../Color/WorkingMatrix.js';
+
+const NO_EMISSION = Object.freeze( { r: 0, g: 0, b: 0 } );
+
+/**
+ * A material's emission in the working space.
+ *
+ * The emitter seen directly reads the material buffer, which is already converted, and so does the
+ * shader's pick probability. This buffer is the other copy of the same colour — the one next-event
+ * estimation lights the scene with — so it has to move with them, or a working space adopted from a
+ * config lights everything in the wrong primaries and weights the pick by a colour nothing renders.
+ */
+function workingEmissive( emissive ) {
+
+	if ( ! emissive ) return NO_EMISSION;
+	if ( ! getWorkingMatrix() ) return emissive;
+
+	const rgb = [ emissive.r, emissive.g, emissive.b ];
+	convertLinearTriple( rgb );
+	return { r: rgb[ 0 ], g: rgb[ 1 ], b: rgb[ 2 ] };
+
+}
 
 const log = createLogger( 'emissive' );
 
@@ -62,6 +84,9 @@ export class EmissiveTriangleBuilder {
 		const flatU = chunked ? null : triangleData;
 		const flatF = chunked ? null : new Float32Array( triangleData.buffer, triangleData.byteOffset, triangleData.length );
 
+		// Once per material, not once per triangle: this loop runs over every triangle in the scene.
+		const emissiveOf = new Map();
+
 		for ( let i = 0; i < triangleCount; i ++ ) {
 
 			const triU = chunked ? chunked.chunkFor( i ) : flatU;
@@ -75,7 +100,14 @@ export class EmissiveTriangleBuilder {
 			if ( ! material ) continue;
 
 			// Check if emissive
-			const emissive = material.emissive || { r: 0, g: 0, b: 0 };
+			let emissive = emissiveOf.get( material );
+			if ( emissive === undefined ) {
+
+				emissive = workingEmissive( material.emissive );
+				emissiveOf.set( material, emissive );
+
+			}
+
 			const emissiveIntensity = material.emissiveIntensity || 0;
 
 			const isEmissive = emissiveIntensity > 0 && (
@@ -461,7 +493,7 @@ export class EmissiveTriangleBuilder {
 	 */
 	updateMaterialEmissive( materialIndex, material, triangleData, materials, triangleCount ) {
 
-		const emissive = material.emissive || { r: 0, g: 0, b: 0 };
+		const emissive = workingEmissive( material.emissive );
 		const emissiveIntensity = material.emissiveIntensity || 0;
 		const isNowEmissive = emissiveIntensity > 0 && ( emissive.r > 0 || emissive.g > 0 || emissive.b > 0 );
 

package/src/Processor/GeometryExtractor.js

@@ -1,6 +1,6 @@
 import { BufferAttribute, Vector3, Vector2, Color, Matrix3, Matrix4, FrontSide, BackSide, DoubleSide, RGBAFormat } from "three";
 import {
-	TEXTURE_CONSTANTS, TRIANGLE_DATA_LAYOUT, packNormalOct, packTriangleFlags
+	TEXTURE_CONSTANTS, TRIANGLE_DATA_LAYOUT, MATERIAL_DEFAULTS, packNormalOct, packTriangleFlags
 } from '../EngineDefaults.js';
 import { ISSUE_CODES } from '../EngineIssues.js';
 import { ChunkedRecords, SHARED_MEMORY_AVAILABLE } from './ChunkedRecords.js';
@@ -10,6 +10,20 @@ const log = createLogger( 'geometry' );
 
 const MAX_TEXTURES_LIMIT = TEXTURE_CONSTANTS.MAX_TEXTURES_LIMIT;
 
+const COLOR_DEFAULTS = new Set( [ 'color', 'emissive', 'attenuationColor', 'sheenColor', 'specularColor', 'subsurfaceColor' ] );
+
+/**
+ * Where a packed material value came from: the three.js material carried it, a legacy-type
+ * conversion (Basic/Lambert/Phong/Toon) produced it, the engine filled it from
+ * MATERIAL_DEFAULTS, or a host set it at runtime through setMaterialProperty.
+ */
+export const MATERIAL_VALUE_SOURCE = Object.freeze( {
+	MATERIAL: 'material',
+	MAPPED: 'mapped',
+	DEFAULT: 'default',
+	HOST: 'host',
+} );
+
 const IDENTITY_ELEMENTS = [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ];
 
 function isIdentityElements( e ) {
@@ -19,6 +33,36 @@ function isIdentityElements( e ) {
 
 }
 
+/**
+ * The texture that feeds each GPU map slot. Re-packing texture indices without this loses the
+ * unlit routing (a MeshBasicMaterial's map is also its emission map).
+ * @param {import('three').Material} material
+ * @returns {Object<string, import('three').Texture|undefined>}
+ */
+export function resolveMaterialTextures( material ) {
+
+	return {
+		map: material.map,
+		normalMap: material.normalMap,
+		bumpMap: material.bumpMap,
+		roughnessMap: material.roughnessMap,
+		metalnessMap: material.metalnessMap,
+		emissiveMap: material.emissiveMap ?? ( material.isMeshBasicMaterial ? material.map : undefined ),
+		displacementMap: material.displacementMap,
+		anisotropyMap: material.anisotropyMap,
+		clearcoatMap: material.clearcoatMap,
+		clearcoatRoughnessMap: material.clearcoatRoughnessMap,
+		transmissionMap: material.transmissionMap,
+		sheenColorMap: material.sheenColorMap,
+		sheenRoughnessMap: material.sheenRoughnessMap,
+		specularIntensityMap: material.specularIntensityMap,
+		specularColorMap: material.specularColorMap,
+		iridescenceMap: material.iridescenceMap,
+		iridescenceThicknessMap: material.iridescenceThicknessMap,
+	};
+
+}
+
 /**
  * glTF 2.0 alphaMode for a three.js material: 0 OPAQUE, 1 MASK, 2 BLEND.
  *
@@ -734,43 +778,15 @@ export class GeometryExtractor {
 
 	getPhysicalDefaults() {
 
-		// Defaults optimized for physically-based path tracing
-		return {
-			emissive: new Color( 0, 0, 0 ),
-			emissiveIntensity: 1.0,
-			roughness: 1.0,
-			metalness: 0.0,
-			ior: 1.5, // Common dielectric IOR (glass, plastic)
-			opacity: 1.0,
-			transmission: 0.0,
-			thickness: 0.1,
-			attenuationColor: new Color( 0xffffff ),
-			attenuationDistance: Infinity, // No attenuation by default
-			dispersion: 0.0,
-			sheen: 0.0,
-			sheenRoughness: 1.0,
-			sheenColor: new Color( 0x000000 ),
-			specularIntensity: 1.0,
-			specularColor: new Color( 0xffffff ),
-			clearcoat: 0.0,
-			clearcoatRoughness: 0.0,
-			iridescence: 0.0,
-			iridescenceIOR: 1.3,
-			iridescenceThicknessRange: [ 100, 400 ],
-			normalScale: { x: 1, y: 1 },
-			bumpScale: 1.0,
-			displacementScale: 1.0,
-			alphaTest: 0.0,
-			// Subsurface scattering (no native MeshPhysicalMaterial equivalent)
-			subsurface: 0.0,
-			subsurfaceColor: new Color( 0xffffff ),
-			subsurfaceRadius: [ 1.0, 0.2, 0.1 ], // skin-like: red travels furthest
-			subsurfaceRadiusScale: 1.0,
-			subsurfaceAnisotropy: 0.0,
-			// Surface specular anisotropy (native MeshPhysicalMaterial / KHR_materials_anisotropy)
-			anisotropy: 0.0,
-			anisotropyRotation: 0.0
-		};
+		const defaults = {};
+		for ( const [ key, value ] of Object.entries( MATERIAL_DEFAULTS ) ) {
+
+			defaults[ key ] = COLOR_DEFAULTS.has( key ) ? new Color().fromArray( value ) : Array.isArray( value ) ? [ ...value ] : value;
+
+		}
+
+		defaults.normalScale = { x: MATERIAL_DEFAULTS.normalScale[ 0 ], y: MATERIAL_DEFAULTS.normalScale[ 1 ] };
+		return defaults;
 
 	}
 
@@ -782,12 +798,13 @@ export class GeometryExtractor {
 		switch ( materialType ) {
 
 			case 'basic':
-				// MeshBasicMaterial -> Unlit/Emissive material
+				// Unlit (GLTFLoader's KHR_materials_unlit): colour and texture are emission, nothing reflects.
 				mapped.emissive = material.color.clone();
 				mapped.emissiveIntensity = 1.0;
-				mapped.color = new Color( 0x000000 ); // No diffuse reflection
+				mapped.color = new Color( 0x000000 );
 				mapped.roughness = 1.0;
 				mapped.metalness = 0.0;
+				mapped.specularIntensity = 0.0;
 				break;
 
 			case 'lambert':
@@ -807,14 +824,14 @@ export class GeometryExtractor {
 
 				}
 
-				// Convert specular color to specular intensity
+				// Strength in specularIntensity, hue alone in specularColor; carrying it in both squared it.
 				if ( material.specular ) {
 
-					const specularLuminance = material.specular.r * 0.299 +
-                                        material.specular.g * 0.587 +
-                                        material.specular.b * 0.114;
+					const s = material.specular;
+					const specularLuminance = s.r * 0.299 + s.g * 0.587 + s.b * 0.114;
+					const peak = Math.max( s.r, s.g, s.b );
 					mapped.specularIntensity = Math.min( specularLuminance * 2.0, 1.0 );
-					mapped.specularColor = material.specular.clone();
+					mapped.specularColor = peak > 0 ? s.clone().multiplyScalar( 1 / peak ) : new Color( 1, 1, 1 );
 
 				}
 
@@ -842,121 +859,117 @@ export class GeometryExtractor {
 		const defaults = this.getPhysicalDefaults();
 		const materialType = this.getMaterialType( material );
 		const legacyMapping = this.mapLegacyMaterialToPhysical( material, materialType );
+		const textures = resolveMaterialTextures( material );
+		const sources = {};
 
-		// A transmissive surface is a dielectric interface whose IOR drives refraction, so it wins
-		// over the metal Fresnel hack: glTF defaults metallicFactor to 1, which otherwise stamps
-		// 2.5 onto water/glass authored as MeshStandardMaterial.
-		const isTransmissive = ( material.transmission ?? 0.0 ) > 0.0;
-		const isMetallic = ( material.metalness ?? legacyMapping.metalness ?? 0.0 ) > 0.1;
-		const defaultIOR = ( isMetallic && ! isTransmissive ) ? 2.5 : defaults.ior;
+		const pick = ( key ) => {
 
-		// Handle color conversion for different material types
-		let baseColor = material.color || new Color( 0xffffff );
-		if ( materialType === 'basic' && ! material.map ) {
+			if ( legacyMapping[ key ] !== undefined ) {
 
-			// For basic materials without textures, treat color as emissive
-			baseColor = new Color( 0x000000 );
+				sources[ key ] = MATERIAL_VALUE_SOURCE.MAPPED;
+				return legacyMapping[ key ];
 
-		}
+			}
+
+			if ( material[ key ] !== undefined && material[ key ] !== null ) {
+
+				sources[ key ] = MATERIAL_VALUE_SOURCE.MATERIAL;
+				return material[ key ];
+
+			}
+
+			sources[ key ] = MATERIAL_VALUE_SOURCE.DEFAULT;
+			return defaults[ key ];
+
+		};
+
+		for ( const key of [ 'transparent', 'alphaMode', 'side', 'depthWrite' ] ) sources[ key ] = MATERIAL_VALUE_SOURCE.MATERIAL;
 
 		return {
 			uuid: material.uuid,
 
-			// Base material properties
-			color: baseColor,
-			emissive: legacyMapping.emissive ?? material.emissive ?? defaults.emissive,
-			emissiveIntensity: legacyMapping.emissiveIntensity ?? material.emissiveIntensity ?? defaults.emissiveIntensity,
+			color: pick( 'color' ),
+			emissive: pick( 'emissive' ),
+			emissiveIntensity: pick( 'emissiveIntensity' ),
 
-			// Surface properties
 			// Floor at 0.02 (the sampler's own VNDF-PDF clamp, MaterialProperties.js) rather than
 			// 0.05, so near-mirror metals stay sharp without entering a new firefly regime.
-			roughness: Math.max( 0.02, legacyMapping.roughness ?? material.roughness ?? defaults.roughness ),
-			metalness: legacyMapping.metalness ?? material.metalness ?? defaults.metalness,
-
-			// Optical properties
-			ior: material.ior ?? defaultIOR,
-			opacity: material.opacity ?? defaults.opacity,
-
-			// Transmission properties (MeshPhysicalMaterial only)
-			transmission: material.transmission ?? defaults.transmission,
-			thickness: material.thickness ?? defaults.thickness,
-			attenuationColor: material.attenuationColor ?? defaults.attenuationColor,
-			attenuationDistance: material.attenuationDistance ?? defaults.attenuationDistance,
-
-			// Advanced properties (MeshPhysicalMaterial only)
-			dispersion: material.dispersion ?? defaults.dispersion,
-			sheen: material.sheen ?? defaults.sheen,
-			sheenRoughness: material.sheenRoughness ?? defaults.sheenRoughness,
-			sheenColor: material.sheenColor ?? defaults.sheenColor,
-			clearcoat: material.clearcoat ?? defaults.clearcoat,
-			clearcoatRoughness: material.clearcoatRoughness ?? defaults.clearcoatRoughness,
-			iridescence: material.iridescence ?? defaults.iridescence,
-			iridescenceIOR: material.iridescenceIOR ?? defaults.iridescenceIOR,
-			iridescenceThicknessRange: material.iridescenceThicknessRange ?? defaults.iridescenceThicknessRange,
-
-			// Subsurface scattering (custom props; MeshPhysicalMaterial has none)
-			subsurface: material.subsurface ?? defaults.subsurface,
-			subsurfaceColor: material.subsurfaceColor ?? defaults.subsurfaceColor,
-			subsurfaceRadius: material.subsurfaceRadius ?? defaults.subsurfaceRadius,
-			subsurfaceRadiusScale: material.subsurfaceRadiusScale ?? defaults.subsurfaceRadiusScale,
-			subsurfaceAnisotropy: material.subsurfaceAnisotropy ?? defaults.subsurfaceAnisotropy,
-
-			// Surface specular anisotropy (native MeshPhysicalMaterial / KHR_materials_anisotropy)
-			anisotropy: material.anisotropy ?? defaults.anisotropy,
-			anisotropyRotation: material.anisotropyRotation ?? defaults.anisotropyRotation,
-
-			// Specular properties (for compatibility)
-			specularIntensity: legacyMapping.specularIntensity ?? material.specularIntensity ?? defaults.specularIntensity,
-			specularColor: legacyMapping.specularColor ?? material.specularColor ?? defaults.specularColor,
-
-			// Surface detail properties
-			normalScale: material.normalScale ?? defaults.normalScale,
-			bumpScale: material.bumpScale ?? defaults.bumpScale,
-			displacementScale: material.displacementScale ?? defaults.displacementScale,
-
-			// Transparency and alpha
+			roughness: Math.max( 0.02, pick( 'roughness' ) ),
+			metalness: pick( 'metalness' ),
+
+			ior: pick( 'ior' ),
+			opacity: pick( 'opacity' ),
+
+			transmission: pick( 'transmission' ),
+			thickness: pick( 'thickness' ),
+			attenuationColor: pick( 'attenuationColor' ),
+			attenuationDistance: pick( 'attenuationDistance' ),
+
+			dispersion: pick( 'dispersion' ),
+			sheen: pick( 'sheen' ),
+			sheenRoughness: pick( 'sheenRoughness' ),
+			sheenColor: pick( 'sheenColor' ),
+			clearcoat: pick( 'clearcoat' ),
+			clearcoatRoughness: pick( 'clearcoatRoughness' ),
+			iridescence: pick( 'iridescence' ),
+			iridescenceIOR: pick( 'iridescenceIOR' ),
+			iridescenceThicknessRange: pick( 'iridescenceThicknessRange' ),
+
+			subsurface: pick( 'subsurface' ),
+			subsurfaceColor: pick( 'subsurfaceColor' ),
+			subsurfaceRadius: pick( 'subsurfaceRadius' ),
+			subsurfaceRadiusScale: pick( 'subsurfaceRadiusScale' ),
+			subsurfaceAnisotropy: pick( 'subsurfaceAnisotropy' ),
+
+			anisotropy: pick( 'anisotropy' ),
+			anisotropyRotation: pick( 'anisotropyRotation' ),
+
+			specularIntensity: pick( 'specularIntensity' ),
+			specularColor: pick( 'specularColor' ),
+
+			normalScale: pick( 'normalScale' ),
+			bumpScale: pick( 'bumpScale' ),
+			displacementScale: pick( 'displacementScale' ),
+
 			transparent: material.transparent ? 1 : 0,
-			alphaTest: material.alphaTest ?? defaults.alphaTest,
+			alphaTest: pick( 'alphaTest' ),
 			alphaMode: deriveAlphaMode( material ),
 
-			// Rendering properties
 			side: this.getMaterialSide( material ),
 			depthWrite: material.depthWrite ?? true ? 1 : 0,
 
-			// Texture processing
-			map: this.processTexture( material.map, this.maps ),
-			normalMap: this.processTexture( material.normalMap, this.normalMaps ),
-			bumpMap: this.processTexture( material.bumpMap, this.bumpMaps ),
-			roughnessMap: this.processTexture( material.roughnessMap, this.roughnessMaps ),
-			metalnessMap: this.processTexture( material.metalnessMap, this.metalnessMaps ),
-			emissiveMap: this.processTexture( material.emissiveMap, this.emissiveMaps ),
-			displacementMap: this.processTexture( material.displacementMap, this.displacementMaps ),
-			anisotropyMap: this.processTexture( material.anisotropyMap, this.anisotropyMaps ),
+			map: this.processTexture( textures.map, this.maps ),
+			normalMap: this.processTexture( textures.normalMap, this.normalMaps ),
+			bumpMap: this.processTexture( textures.bumpMap, this.bumpMaps ),
+			roughnessMap: this.processTexture( textures.roughnessMap, this.roughnessMaps ),
+			metalnessMap: this.processTexture( textures.metalnessMap, this.metalnessMaps ),
+			emissiveMap: this.processTexture( textures.emissiveMap, this.emissiveMaps ),
+			displacementMap: this.processTexture( textures.displacementMap, this.displacementMaps ),
+			anisotropyMap: this.processTexture( textures.anisotropyMap, this.anisotropyMaps ),
 
 			// Advanced texture maps (MeshPhysicalMaterial only). Folded into their scalar factors
 			// in ShadeKernel (applyExtensionMaps). thicknessMap stays dropped — thickness has no
 			// render effect yet (see gap-plan Phase 4.4).
-			clearcoatMap: this.processTexture( material.clearcoatMap, this.clearcoatMaps ),
-			clearcoatRoughnessMap: this.processTexture( material.clearcoatRoughnessMap, this.clearcoatRoughnessMaps ),
-			transmissionMap: this.processTexture( material.transmissionMap, this.transmissionMaps ),
+			clearcoatMap: this.processTexture( textures.clearcoatMap, this.clearcoatMaps ),
+			clearcoatRoughnessMap: this.processTexture( textures.clearcoatRoughnessMap, this.clearcoatRoughnessMaps ),
+			transmissionMap: this.processTexture( textures.transmissionMap, this.transmissionMaps ),
 			thicknessMap: this.processTexture( material.thicknessMap, [] ),
-			sheenColorMap: this.processTexture( material.sheenColorMap, this.sheenColorMaps ),
-			sheenRoughnessMap: this.processTexture( material.sheenRoughnessMap, this.sheenRoughnessMaps ),
-			specularIntensityMap: this.processTexture( material.specularIntensityMap, this.specularIntensityMaps ),
-			specularColorMap: this.processTexture( material.specularColorMap, this.specularColorMaps ),
-			iridescenceMap: this.processTexture( material.iridescenceMap, this.iridescenceMaps ),
-			iridescenceThicknessMap: this.processTexture( material.iridescenceThicknessMap, this.iridescenceThicknessMaps ),
-
-			// Texture transformation matrices
-			mapMatrix: this.getTextureMatrix( material.map ),
-			normalMapMatrices: this.getTextureMatrix( material.normalMap ),
-			bumpMapMatrices: this.getTextureMatrix( material.bumpMap ),
-			roughnessMapMatrices: this.getTextureMatrix( material.roughnessMap ),
-			metalnessMapMatrices: this.getTextureMatrix( material.metalnessMap ),
-			emissiveMapMatrices: this.getTextureMatrix( material.emissiveMap ),
-			displacementMapMatrices: this.getTextureMatrix( material.displacementMap ),
-
-			// Material type for debugging/optimization
+			sheenColorMap: this.processTexture( textures.sheenColorMap, this.sheenColorMaps ),
+			sheenRoughnessMap: this.processTexture( textures.sheenRoughnessMap, this.sheenRoughnessMaps ),
+			specularIntensityMap: this.processTexture( textures.specularIntensityMap, this.specularIntensityMaps ),
+			specularColorMap: this.processTexture( textures.specularColorMap, this.specularColorMaps ),
+			iridescenceMap: this.processTexture( textures.iridescenceMap, this.iridescenceMaps ),
+			iridescenceThicknessMap: this.processTexture( textures.iridescenceThicknessMap, this.iridescenceThicknessMaps ),
+
+			mapMatrix: this.getTextureMatrix( textures.map ),
+			normalMapMatrices: this.getTextureMatrix( textures.normalMap ),
+			bumpMapMatrices: this.getTextureMatrix( textures.bumpMap ),
+			roughnessMapMatrices: this.getTextureMatrix( textures.roughnessMap ),
+			metalnessMapMatrices: this.getTextureMatrix( textures.metalnessMap ),
+			emissiveMapMatrices: this.getTextureMatrix( textures.emissiveMap ),
+			displacementMapMatrices: this.getTextureMatrix( textures.displacementMap ),
+
+			sources,
 			originalType: materialType
 		};
 

package/src/Processor/LightSerializer.js

@@ -1,11 +1,11 @@
 import { Vector3, Quaternion } from 'three';
 import { blackbodyToLinearRGB } from './blackbody.js';
-import { lightPower } from '../LightUnits.js';
+import { convertLinearTriple } from '../Color/WorkingMatrix.js';
 
-// Scene lights hold the three.js quantity in radiometric units (see LightUnits.js): point and
-// spot in W/sr, the Sun in W/m², area lights in radiance. The GPU buffer wants radiant intensity
-// for point/spot — already what they hold — and radiant POWER for area lights, which the shader
-// turns back into radiance with its own π·area. This is where that adaptation happens.
+// Point & spot lights specify Power in Watts; the shader uses radiant intensity
+// (W/sr) as `intensity / dist²`, so convert with I = P / 4π (isotropic emitter),
+// matching Blender. Area lights are already radiant power; the Sun is irradiance.
+const INV_4PI = 1 / ( 4 * Math.PI );
 
 // Effective emission colour + intensity after per-light Exposure (EV stops) and
 // optional blackbody Temperature tint (Blender-style). Both fold into the values
@@ -16,15 +16,19 @@ function effectiveEmission( light ) {
 	const exposure = Number.isFinite( ud.exposure ) ? ud.exposure : 0;
 	const intensity = light.intensity * Math.pow( 2, exposure );
 
-	let r = light.color.r, g = light.color.g, b = light.color.b;
+	const rgb = [ light.color.r, light.color.g, light.color.b ];
 	if ( ud.useTemperature ) {
 
 		const [ tr, tg, tb ] = blackbodyToLinearRGB( ud.temperature ?? 6500 );
-		r *= tr; g *= tg; b *= tb;
+		rgb[ 0 ] *= tr; rgb[ 1 ] *= tg; rgb[ 2 ] *= tb;
 
 	}
 
-	return { r, g, b, intensity };
+	// A light colour is authored against sRGB primaries, like everything else three.js hands over.
+	// Rendering in a wider working space without converting it tints every surface it touches.
+	convertLinearTriple( rgb );
+
+	return { r: rgb[ 0 ], g: rgb[ 1 ], b: rgb[ 2 ], intensity };
 
 }
 
@@ -62,10 +66,9 @@ export class LightSerializer {
 
 	calculateLightImportance( light, type = 'directional' ) {
 
-		// Ranked on Power, so the ordering does not shift when a light type's stored quantity
-		// differs from what the panel shows.
+		// Calculate luminance-weighted importance
 		const luminance = 0.2126 * light.color.r + 0.7152 * light.color.g + 0.0722 * light.color.b;
-		let importance = lightPower( light ) * luminance;
+		let importance = light.intensity * luminance;
 
 		// Area lights get additional importance based on size
 		if ( type === 'area' ) {
@@ -174,12 +177,6 @@ export class LightSerializer {
 
 		const em = effectiveEmission( light );
 
-		// The shader recovers radiance as power/(π·area), so hand it the power that inverts to
-		// the radiance the light holds. Area is measured off u/v exactly as the shader does it.
-		const rectArea = 4 * u.clone().cross( v ).length();
-		const emittingArea = shape > 0.5 ? rectArea * Math.PI / 4 : rectArea;
-		const power = em.intensity * Math.PI * ( normalize > 0.5 ? emittingArea : 1 );
-
 		// Store in cache with importance (16 floats, vec4-aligned)
 		this.areaLightCache.push( {
 			data: [
@@ -187,7 +184,7 @@ export class LightSerializer {
 				u.x, u.y, u.z, // u half-vector (3)
 				v.x, v.y, v.z, // v half-vector (3)
 				em.r, em.g, em.b, // color (3) — incl. temperature tint
-				power, // radiant power in Watts (1) — incl. exposure
+				em.intensity, // radiant power in Watts (1) — incl. exposure
 				normalize, // power-normalize flag (1)
 				spread, // emission spread in radians (1)
 				shape, // 0 = rect, 1 = disk/ellipse (1)
@@ -217,7 +214,7 @@ export class LightSerializer {
 			data: [
 				position.x, position.y, position.z, // position (3)
 				em.r, em.g, em.b, // color (3) — incl. temperature tint
-				em.intensity, // radiant intensity W/sr, incl. exposure (1)
+				em.intensity * INV_4PI, // radiant intensity W/sr = power(W)/4π, incl. exposure (1)
 				light.distance || 0.0, // cutoff distance (0 = infinite) (1)
 				light.decay !== undefined ? light.decay : 2.0 // decay exponent (1)
 			],
@@ -260,7 +257,7 @@ export class LightSerializer {
 				position.x, position.y, position.z, // position (3)
 				direction.x, direction.y, direction.z, // direction (3)
 				em.r, em.g, em.b, // color (3) — incl. temperature tint
-				em.intensity, // radiant intensity W/sr, incl. exposure (1)
+				em.intensity * INV_4PI, // radiant intensity W/sr = power(W)/4π, incl. exposure (1)
 				light.angle || Math.PI / 4, // cone half-angle in radians (1)
 				light.penumbra || 0.0, // penumbra [0,1] (1)
 				light.distance || 0.0, // cutoff distance (0 = infinite) (1)