rayzee 11.8.0 → 11.9.0

package/dist/{sceneCachePolicy-D_uBSbQF.js → sceneCachePolicy-ywbGKHD3.js}

@@ -1,7 +1,7 @@
 import { t as e } from "./EngineEvents-CLckhYbL.js";
 import { a as t, i as n, r } from "./Logger-dDDGj9Av.js";
-import { f as i, v as a, y as o } from "./BufferLayout-xPRH9jYD.js";
-import { n as s } from "./EngineIssues-xljoXM0E.js";
+import { f as i, v as a, y as o } from "./BufferLayout-Bzgccg1o.js";
+import { n as s } from "./EngineIssues-CfJiBaNj.js";
 import { n as c, r as l } from "./shared-BGBcSxBQ.js";
 import { n as u } from "./AssetConfig-DSEntE65.js";
 import { BackSide as d, BufferAttribute as f, Color as p, DoubleSide as m, FrontSide as h, Matrix3 as g, Matrix4 as _, RGBAFormat as v, Vector2 as y, Vector3 as b } from "three";
@@ -230,6 +230,7 @@ var E = de({
 	normalScale: [1, 1],
 	bumpScale: 1,
 	displacementScale: 1,
+	displacementBias: 0,
 	transparent: 0,
 	alphaTest: 0,
 	alphaMode: 0,
@@ -1069,7 +1070,7 @@ var Be = class {
 		this.expandedTriangleCount += u.count, this.meshTriangleRanges.push(u), u.count > 0 && !l && a && this._geometryRanges.set(r, {
 			...u,
 			meshIndex: n
-		}), this._recordPlacements(e, n, l, c, u.count > 0 && a), u.count > 0 && this._onRange?.(n, u);
+		}), u.count > 0 && (this._recordPlacements(e, n, l, c, a), this._onRange?.(n, u));
 	}
 	_recordPlacements(e, t, n = !1, r = !1, i = !1) {
 		let a = e.matrixWorld.elements, o = this.instanceSource;
@@ -1232,6 +1233,7 @@ var Be = class {
 			normalScale: o("normalScale"),
 			bumpScale: o("bumpScale"),
 			displacementScale: o("displacementScale"),
+			displacementBias: o("displacementBias"),
 			transparent: +!!e.transparent,
 			alphaTest: o("alphaTest"),
 			alphaMode: Pe(e),
@@ -1298,9 +1300,10 @@ var Be = class {
 	}
 	extractGeometry(e, t, n, r = !1, i = !1) {
 		e.updateMatrix(), e.updateMatrixWorld();
-		let a = e.geometry;
+		let a = e.geometry, o = a.attributes.position;
+		if (!o) return;
 		a.attributes.normal || a.computeVertexNormals();
-		let o = a.attributes.position, s = a.attributes.normal, c = a.attributes.uv, l = a.index ? a.index.array : null, u = l ? l.length / 3 : o.count / 3;
+		let s = a.attributes.normal, c = a.attributes.uv, l = a.index ? a.index.array : null, u = Math.floor((l ? l.length : o.count) / 3);
 		if (i) {
 			let r = e.count ?? e.instanceMatrix.array.length / 16, i = this._matrixPool.mat4, a = new _();
 			for (let d = 0; d < r; d++) {
@@ -1594,7 +1597,7 @@ var vt = class {
 			samples: this.samples.slice()
 		};
 	}
-}, yt = "11.8.0", $ = 1e4, bt = 15e5;
+}, yt = "11.9.0", $ = 1e4, bt = 15e5;
 function xt(e, t, n = $) {
 	return e >= n && t / bt < e / 3;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "11.8.0",
+  "version": "11.9.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -117,6 +117,7 @@ export const MATERIAL_DEFAULTS = deepFreeze( {
 	normalScale: [ 1, 1 ],
 	bumpScale: 1,
 	displacementScale: 1,
+	displacementBias: 0,
 	transparent: 0,
 	alphaTest: 0,
 	alphaMode: 0,

package/src/EngineIssues.js

@@ -13,6 +13,7 @@ export const ISSUE_CODES = Object.freeze( {
 	ASSET_AMBIGUOUS_ENTRY: 'asset.ambiguous_entry',
 	ASSET_ARCHIVE_TOO_LARGE: 'asset.archive_too_large',
 	ASSET_ENTRY_TOO_LARGE: 'asset.entry_too_large',
+	ASSET_PARAMETERS_IGNORED: 'asset.parameters_ignored',
 	TEXTURE_BUILD_FAILED: 'texture.build_failed',
 	TEXTURE_PROCESSING_FALLBACK: 'texture.processing_fallback',
 	TEXTURE_LIMIT_EXCEEDED: 'texture.limit_exceeded',

package/src/Passes/OIDNTemporalHistory.js

@@ -221,7 +221,7 @@ fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
 
 	}
 
-	let rough = textureLoad( shading, p, 0 ).w;
+	let rough = abs( textureLoad( shading, p, 0 ).w );
 	var cap = mix( P.smoothLength, P.maxLength, smoothstep( P.roughStart, P.roughEnd, rough ) );
 	if ( movedPx ) { cap = min( cap, P.movedLength ); }
 	let newLen = min( len + 1.0, cap );

package/src/Processor/ArchiveImporter.js

@@ -82,16 +82,17 @@ export class ArchiveImporter {
 	constructor( loader ) {
 
 		this.loader = loader;
-		this._pendingGraph = null;
+		this._store = null;
 		this.lastPBRTStats = null;
 		this.lastUSDStats = null;
 
 	}
 
-	/** Drops a parsed scene still waiting to be stored: the model it was for is gone. */
+	/** Abandons a parsed scene the engine has not accepted: the model it was for is gone, or its load failed. */
 	release() {
 
-		this._pendingGraph = null;
+		this._store?.decide( false );
+		this._store = null;
 
 	}
 
@@ -383,7 +384,8 @@ export class ArchiveImporter {
 
 	/**
 	 * Stores a freshly parsed scene for the next open. Encoded here, before onModelLoad or the
-	 * build touch it; written in the background.
+	 * build touch it; written in the background, and visible to an open only once the engine
+	 * accepts the scene ({@link commitPendingGraph}).
 	 * @private
 	 */
 	_storeGraph( key, built, label ) {
@@ -401,7 +403,7 @@ export class ArchiveImporter {
 					meshCount: built.meshCount, entryPath: built.entryPath, candidates: built.candidates, frames: built.frames,
 					warnings: built.warnings, triangleCount: built.triangleCount, placementCount: built.placementCount,
 					mergedShapes: built.mergedShapes, skippedForBudget: built.skippedForBudget, droppedNoTemplate: built.droppedNoTemplate,
-					render: built.render ?? null,
+					render: built.render ?? null, parameters: built.parameters ?? null,
 				},
 			} );
 
@@ -413,13 +415,29 @@ export class ArchiveImporter {
 
 		}
 
-		const pending = { key, encoded, label, parseMs: ( built.parseMs ?? 0 ) + ( built.buildMs ?? 0 ), triangles: built.triangleCount ?? null };
+		let settle;
+		const stop = new AbortController();
+		const store = {
+			key, encoded, label, model: built.group, writing: false, signal: stop.signal,
+			parseMs: ( built.parseMs ?? 0 ) + ( built.buildMs ?? 0 ), triangles: built.triangleCount ?? null,
+			accepted: new Promise( resolve => {
+
+				settle = resolve;
+
+			} ),
+			decide: accepted => {
+
+				settle( accepted );
+				if ( ! accepted ) stop.abort();
+
+			},
+		};
+		this._store = store;
 
 		// A parse slow enough on its own is written now, during the build. Held until the build
 		// ends, it kept every array the build replaces alive with it — the float normals and the
 		// instance matrices, ~1 GB on the whole Moana subset, at the build's peak.
-		if ( worthStoring( pending.parseMs, encoded.byteLength ) ) this._writeGraph( area, pending );
-		else this._pendingGraph = pending;
+		if ( worthStoring( store.parseMs, encoded.byteLength ) ) this._writeGraph( area, store );
 
 	}
 
@@ -430,34 +448,57 @@ export class ArchiveImporter {
 	 */
 	flushPendingGraph( buildMs ) {
 
-		const pending = this._pendingGraph;
-		this._pendingGraph = null;
+		const store = this._store;
+		if ( ! store || store.writing ) return;
 		const area = this.loader.storage?.area( ENGINE_AREAS.SCENES );
-		if ( ! pending || ! area || ! worthStoring( pending.parseMs + buildMs, pending.encoded.byteLength ) ) return;
-		this._writeGraph( area, pending );
+		if ( area && worthStoring( store.parseMs + buildMs, store.encoded.byteLength ) ) this._writeGraph( area, store );
+		else this._store = null;
+
+	}
+
+	/**
+	 * The engine accepted `model`: the scene stored for it is committed once written. Until then the
+	 * entry has no metadata, so no open can restore it.
+	 * @param {import('three').Object3D} model - the model whose load the engine finished
+	 */
+	commitPendingGraph( model ) {
+
+		const store = this._store;
+		if ( ! store || store.model !== model ) return;
+		this._store = null;
+		store.model = null;
+		store.decide( store.writing );
 
 	}
 
 	/** Writes an encoded graph in the background, letting each array go once it is on disk. @private */
-	_writeGraph( area, pending ) {
+	_writeGraph( area, store ) {
 
+		store.writing = true;
 		( async () => {
 
-			const writer = await area.create( pending.key, { label: `${pending.label} (scene)`, expectedBytes: pending.encoded.byteLength } );
-			if ( ! writer ) return;
+			let writer = null;
 			try {
 
-				await writeSceneGraph( writer, pending.encoded, { release: true } );
-				await writer.commit( { triangles: pending.triangles } );
+				writer = await area.create( store.key, { label: `${store.label} (scene)`, expectedBytes: store.encoded.byteLength } );
+				if ( ! writer ) return;
+				await writeSceneGraph( writer, store.encoded, { release: true, signal: store.signal } );
+				store.encoded = null;
+				if ( await store.accepted ) await writer.commit( { triangles: store.triangles } );
+				else await writer.abort();
 
 			} catch ( error ) {
 
-				await writer.abort();
-				console.warn( 'Storing the scene failed:', error );
+				await writer?.abort().catch( () => {} );
+				if ( ! store.signal.aborted ) console.warn( 'Storing the scene failed:', error );
+
+			} finally {
+
+				store.encoded = null;
 
 			}
 
-		} )().catch( error => console.warn( 'Storing the scene failed:', error ) );
+		} )();
 
 	}
 
@@ -651,7 +692,7 @@ export class ArchiveImporter {
 
 		const { group, environment, animations, report, warnings, meshCount, entryPath: loadedEntry, candidates,
 			frames, parseMs, buildMs, triangleCount, placementCount, mergedShapes, skippedForBudget,
-			droppedNoTemplate } = built;
+			droppedNoTemplate, parameters } = built;
 		if ( stored ) console.info( `PBRT scene "${loadedEntry}" opened from storage in ${( buildMs / 1000 ).toFixed( 1 )} s, skipping the parse` );
 
 		// Phase breakdown for scaling work; the engine's own build timings live in
@@ -679,6 +720,8 @@ export class ArchiveImporter {
 
 		}
 
+		if ( parameters ) this._reportParameters( parameters, loadedEntry );
+
 		// Diagnostics — surface what each mesh resolved to (helps debug black/wrong materials).
 		if ( report && report.length && typeof console.table === 'function' ) {
 
@@ -728,6 +771,25 @@ export class ArchiveImporter {
 
 	}
 
+	/**
+	 * Every parameter the scene sets that the loader ignored or approximated, once, each with the number of directives
+	 * that set it: one warning and one console list, never cut short.
+	 * @private
+	 */
+	_reportParameters( { unused, approximated }, entry ) {
+
+		const ignored = Object.keys( unused ).length, approx = Object.keys( approximated ).length;
+		if ( ignored + approx === 0 ) return;
+		const message = `${ignored} pbrt parameter(s) ignored and ${approx} approximated in "${entry}"`;
+		const lines = [
+			...Object.entries( unused ).map( ( [ key, count ] ) => `  ignored       ${key} ×${count}` ),
+			...Object.entries( approximated ).map( ( [ key, count ] ) => `  approximated  ${key} ×${count}` )
+		];
+		console.warn( `PBRT loader: ${message} (× directives that set it)\n${lines.join( '\n' )}` );
+		this.loader._issues?.warn( ISSUE_CODES.ASSET_PARAMETERS_IGNORED, message, { entry, unused, approximated } );
+
+	}
+
 	/** A texture map from an archive, tagged with its path so a stored scene can read it back. @private */
 	async _archiveImage( bytes, fname ) {
 

package/src/Processor/AssetLoader.js

@@ -420,6 +420,13 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
+	/** @see ArchiveImporter#commitPendingGraph */
+	commitPendingGraph( model ) {
+
+		this.archives?.commitPendingGraph( model );
+
+	}
+
 	// Blob's own readers, not FileReader: Node has no FileReader.
 	readFileAsArrayBuffer( file ) {
 

package/src/Processor/BufferLayout.js

@@ -149,8 +149,8 @@ export const MATERIAL_DATA_LAYOUT = {
 	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,
+	// Slot 12: bumpScale + displacementScale + displacementMapIndex + displacementBias
+	BUMP_SCALE: 48, DISPLACEMENT_SCALE: 49, DISPLACEMENT_MAP_INDEX: 50, DISPLACEMENT_BIAS: 51,
 
 	// ── Transform float offsets (8 floats each: 7 matrix values + 1 padding) ──
 	ALBEDO_TRANSFORM: 52,
@@ -193,7 +193,7 @@ export const MATERIAL_DATA_LAYOUT = {
 		SHEEN_COLOR: 9, // [extended] sheenColor, diffuseTransmission
 		SPECULAR: 10, // [extended] specularIntensity, specularColor
 		IRIDESCENCE: 11, // [extended] iridescence, iridescenceIOR, iridescenceThicknessRange
-		BUMP_DISPLACEMENT: 12, // bumpScale, displacementScale, displacementMapIndex
+		BUMP_DISPLACEMENT: 12, // bumpScale, displacementScale, displacementMapIndex, displacementBias
 		ALBEDO_TRANSFORM_A: 13, ALBEDO_TRANSFORM_B: 14,
 		NORMAL_TRANSFORM_A: 15, NORMAL_TRANSFORM_B: 16,
 		ROUGHNESS_TRANSFORM_A: 17, ROUGHNESS_TRANSFORM_B: 18,

package/src/Processor/GeometryExtractor.js

@@ -862,8 +862,13 @@ export class GeometryExtractor {
 		this.expandedTriangleCount += range.count;
 		this.meshTriangleRanges.push( range );
 		if ( range.count > 0 && ! bake && shareable ) this._geometryRanges.set( key, { ...range, meshIndex } );
-		this._recordPlacements( mesh, meshIndex, bake, expand, range.count > 0 && shareable );
-		if ( range.count > 0 ) this._onRange?.( meshIndex, range );
+		// A placement with nothing to trace would get a TLAS leaf with no BLAS to point at.
+		if ( range.count > 0 ) {
+
+			this._recordPlacements( mesh, meshIndex, bake, expand, shareable );
+			this._onRange?.( meshIndex, range );
+
+		}
 
 	}
 
@@ -1227,6 +1232,7 @@ export class GeometryExtractor {
 			normalScale: pick( 'normalScale' ),
 			bumpScale: pick( 'bumpScale' ),
 			displacementScale: pick( 'displacementScale' ),
+			displacementBias: pick( 'displacementBias' ),
 
 			transparent: material.transparent ? 1 : 0,
 			alphaTest: pick( 'alphaTest' ),
@@ -1345,13 +1351,15 @@ export class GeometryExtractor {
 		mesh.updateMatrixWorld();
 
 		const geometry = mesh.geometry;
-		if ( ! geometry.attributes.normal ) geometry.computeVertexNormals();
 		const positions = geometry.attributes.position;
+		if ( ! positions ) return;
+		if ( ! geometry.attributes.normal ) geometry.computeVertexNormals();
 		const normals = geometry.attributes.normal;
 		const uvs = geometry.attributes.uv;
 		const indices = geometry.index ? geometry.index.array : null;
 
-		const triangleCount = indices ? indices.length / 3 : positions.count / 3;
+		// Whole triangles only, as three.js draws them: a trailing vertex or two read past the end as NaN.
+		const triangleCount = Math.floor( ( indices ? indices.length : positions.count ) / 3 );
 
 		if ( expandInstances ) {
 

package/src/Processor/MaterialPacking.js

@@ -16,7 +16,7 @@ const TRANSFORMS = [
 
 /** Floats no field writes; the packer gives them fixed values. */
 export const MATERIAL_RESERVED_FLOATS = Object.freeze( [
-	M.VISIBLE, M.DISPLACEMENT_MAP_INDEX + 1, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 1, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 2,
+	M.VISIBLE, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 1, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 2,
 ] );
 
 /**
@@ -129,6 +129,7 @@ export function packMaterial( data, base, mat ) {
 	s( M.BUMP_SCALE, mat.bumpScale, D.bumpScale );
 	s( M.DISPLACEMENT_SCALE, mat.displacementScale, D.displacementScale );
 	data[ base + M.DISPLACEMENT_MAP_INDEX ] = mapIndex( mat.displacementMap );
+	s( M.DISPLACEMENT_BIAS, mat.displacementBias, D.displacementBias );
 
 	for ( const [ key, offset ] of TRANSFORMS ) {
 
@@ -163,7 +164,6 @@ export function packMaterial( data, base, mat ) {
 	data[ base + M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX ] = mapIndex( mat.diffuseTransmissionColorMap );
 
 	data[ base + M.VISIBLE ] = 1;
-	data[ base + M.DISPLACEMENT_MAP_INDEX + 1 ] = 0;
 	data[ base + M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 1 ] = 0;
 	data[ base + M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 2 ] = 0;
 

package/src/Processor/PBRT/PBRTMaterials.js

@@ -10,6 +10,7 @@
 
 import { MeshPhysicalMaterial, Color, DoubleSide } from 'three';
 import { namedScattering, dipoleReflectance, albedoForReflectance } from './PBRTScattering.js';
+import { approximated, param } from './PBRTParser.js';
 
 // Normal-incidence reflectance approximations for pbrt's named conductor spectra.
 const METAL_ALBEDO = {
@@ -54,21 +55,37 @@ function blackbodyToRGB( kelvin ) {
 
 export function pFloat( params, name, dflt ) {
 
-	const p = params[ name ];
+	const p = param( params, name );
+	if ( p && p.type !== 'float' && p.type !== 'integer' ) approximated( params, name );
 	return p && typeof p.value[ 0 ] === 'number' ? p.value[ 0 ] : dflt;
 
 }
 
+/** An index of refraction: a sampled spectrum ( λ value pairs ) is read at 550 nm, linearly between its samples. */
+export function pEta( params, name, dflt ) {
+
+	const p = param( params, name );
+	if ( p?.type !== 'spectrum' || typeof p.value[ 0 ] !== 'number' ) return pFloat( params, name, dflt );
+	approximated( params, name );
+	const v = p.value;
+	if ( v.length < 2 ) return dflt;
+	let i = 2;
+	while ( i < v.length - 1 && v[ i ] < 550 ) i += 2;
+	if ( i >= v.length - 1 || v[ i - 2 ] >= 550 ) return v[ i >= v.length - 1 ? i - 1 : 1 ];
+	return v[ i - 1 ] + ( v[ i + 1 ] - v[ i - 1 ] ) * ( 550 - v[ i - 2 ] ) / ( v[ i ] - v[ i - 2 ] );
+
+}
+
 export function pString( params, name, dflt ) {
 
-	const p = params[ name ];
+	const p = param( params, name );
 	return p && typeof p.value[ 0 ] === 'string' ? p.value[ 0 ] : dflt;
 
 }
 
 export function pBool( params, name, dflt ) {
 
-	const v = params[ name ]?.value?.[ 0 ];
+	const v = param( params, name )?.value?.[ 0 ];
 	return v === undefined ? dflt : v === true || v === 'true';
 
 }
@@ -80,7 +97,7 @@ export function pBool( params, name, dflt ) {
  */
 export async function resolveSpectrum( params, name, ctx, dfltRGB = null ) {
 
-	const p = params[ name ];
+	const p = param( params, name );
 	if ( ! p ) return { rgb: dfltRGB, texture: null };
 
 	// Reference to a named texture.
@@ -91,6 +108,7 @@ export async function resolveSpectrum( params, name, ctx, dfltRGB = null ) {
 		if ( tex && tex.texture ) return { rgb: tex.constant ?? null, texture: tex.texture };
 		if ( tex && tex.constant ) return { rgb: tex.constant, texture: null };
 		ctx.warn( `texture "${texName}" could not be resolved` );
+		approximated( params, name );
 		return { rgb: dfltRGB, texture: null };
 
 	}
@@ -110,6 +128,7 @@ export async function resolveSpectrum( params, name, ctx, dfltRGB = null ) {
 
 	if ( p.type === 'blackbody' ) {
 
+		approximated( params, name );
 		return { rgb: blackbodyToRGB( p.value[ 0 ] ), texture: null };
 
 	}
@@ -117,6 +136,7 @@ export async function resolveSpectrum( params, name, ctx, dfltRGB = null ) {
 	if ( p.type === 'spectrum' ) {
 
 		// Named spectrum (e.g. "metal-Au-eta") or sampled [lambda val ...].
+		approximated( params, name );
 		if ( typeof p.value[ 0 ] === 'string' ) {
 
 			const key = namedMetalKey( p.value[ 0 ] );
@@ -139,6 +159,7 @@ export async function resolveSpectrum( params, name, ctx, dfltRGB = null ) {
 
 	}
 
+	approximated( params, name );
 	return { rgb: dfltRGB, texture: null };
 
 }
@@ -155,9 +176,10 @@ function namedMetalKey( s ) {
 // A float parameter's value, or a float texture's mean (`ctx.floatTextureMean`); null when absent or unreadable.
 async function floatOrMean( params, name, ctx ) {
 
-	const p = params[ name ];
+	const p = param( params, name );
 	if ( ! p ) return null;
 	if ( typeof p.value[ 0 ] === 'number' ) return p.value[ 0 ];
+	approximated( params, name );
 	if ( p.type === 'texture' ) return ( await ctx.floatTextureMean?.( p.value[ 0 ] ) ) ?? null;
 	return null;
 
@@ -171,7 +193,7 @@ async function floatOrMean( params, name, ctx ) {
  */
 const remapsRoughness = ( params ) => {
 
-	const remap = params.remaproughness?.value?.[ 0 ];
+	const remap = param( params, 'remaproughness' )?.value?.[ 0 ];
 	return remap !== false && remap !== 'false';
 
 };
@@ -225,8 +247,14 @@ async function applyRoughness( mat, target, params, dflt, ctx, prefix = '' ) {
 // A spectrum parameter as one RGB; a texture counts as its mean (`ctx.textureMeanRGB`).
 async function spectrumMean( params, key, ctx, dflt ) {
 
-	const p = params[ key ];
-	if ( p?.type === 'texture' ) return ( await ctx.textureMeanRGB?.( p.value[ 0 ] ) ) ?? dflt;
+	const p = param( params, key );
+	if ( p?.type === 'texture' ) {
+
+		approximated( params, key );
+		return ( await ctx.textureMeanRGB?.( p.value[ 0 ] ) ) ?? dflt;
+
+	}
+
 	return ( await resolveSpectrum( params, key, ctx, dflt ) ).rgb ?? dflt;
 
 }
@@ -243,7 +271,7 @@ const SUBSURFACE_SIGMA_S = [ 2.55, 3.21, 3.77 ];
  */
 async function applySubsurface( mat, params, ctx ) {
 
-	const eta = pFloat( params, 'eta', 1.33 );
+	const eta = pEta( params, 'eta', 1.33 );
 	const scale = pFloat( params, 'scale', 1 );
 	const scaled = ( rgb ) => rgb.map( ( v ) => Math.max( 0, v * scale ) );
 	let g = pFloat( params, 'g', 0 );
@@ -353,6 +381,7 @@ export async function buildMaterial( def, ctx ) {
 
 	const type = def?.type || 'diffuse';
 	const params = def?.params || {};
+	ctx.trackParams?.( params, `Material ${type}`, 'type' );
 	const mat = new MeshPhysicalMaterial( { side: DoubleSide, roughness: 1, metalness: 0 } );
 
 	const setColor = ( rgb ) => {
@@ -416,7 +445,7 @@ export async function buildMaterial( def, ctx ) {
 			mat.transmission = 1;
 			mat.metalness = 0;
 			mat.color.setRGB( 1, 1, 1 );
-			mat.ior = pFloat( params, 'eta', 1.5 );
+			mat.ior = pEta( params, 'eta', 1.5 );
 			await applyRoughness( mat, 'roughness', params, 0, ctx );
 			mat.thickness = type === 'thindielectric' ? 0 : pFloat( params, 'thickness', 0 );
 			break;
@@ -447,7 +476,13 @@ export async function buildMaterial( def, ctx ) {
 			const refl = await resolveSpectrum( params, 'reflectance', ctx, [ 0.25, 0.25, 0.25 ] );
 			const base = ( v ) => Math.min( 1, unit( v ) / ( 1 - dt ) );
 			applyAlbedo( { texture: refl.texture, rgb: refl.rgb ? refl.rgb.map( base ) : ( refl.texture ? [ 1, 1, 1 ].map( base ) : null ) } );
-			if ( trans.texture ) ctx.warn( 'diffusetransmission: a textured "transmittance" is not supported — using 0.5' );
+			if ( trans.texture ) {
+
+				ctx.warn( 'diffusetransmission: a textured "transmittance" is not supported — using 0.5' );
+				approximated( params, 'transmittance' );
+
+			}
+
 			mat.diffuseTransmission = dt;
 			mat.diffuseTransmissionColor = new Color().setRGB( ...T.map( ( v ) => ( dt > 0 ? Math.min( 1, v / dt ) : 1 ) ) );
 			mat.roughness = 1;
@@ -477,7 +512,7 @@ export async function buildMaterial( def, ctx ) {
 			// — physically loose but visually faithful, and crucially silent on success
 			// instead of warning per shape. Recursive: mix-in-mix terminates as the
 			// chain bottoms out at a non-mix.
-			const matNames = params.materials?.value || [];
+			const matNames = param( params, 'materials' )?.value || [];
 			let t = Math.max( 0, Math.min( 1, pFloat( params, 'amount', 0.5 ) ) );
 			const defA = matNames[ 0 ] ? ctx.namedMaterials?.get( matNames[ 0 ] ) : null;
 			const defB = matNames[ 1 ] ? ctx.namedMaterials?.get( matNames[ 1 ] ) : null;