rayzee 10.0.0 → 11.1.0

package/src/Processor/IESParser.js

@@ -125,19 +125,39 @@ export function parseIES( text, name = 'ies' ) {
 
 }
 
+/**
+ * The horizontal angle a type C profile stores for `hDeg` in [0, 360), by the symmetry its range implies
+ * (LM-63): one angle — the same all round; 0–90 — mirrored about the 0–180 and 90–270 planes; 0–180 — about the
+ * 0–180 plane; 90–270 — about the 90–270 plane; 0–360 — none.
+ */
+function storedHorizontalAngle( hDeg, hMin, hMax ) {
+
+	if ( hMin === 0 && hMax === 90 ) {
+
+		const half = hDeg % 180;
+		return half > 90 ? 180 - half : half;
+
+	}
+
+	if ( hMin === 0 && hMax === 180 ) return hDeg > 180 ? 360 - hDeg : hDeg;
+	if ( hMin === 90 && hMax === 270 ) return hDeg >= 90 && hDeg <= 270 ? hDeg : ( ( 540 - hDeg ) % 360 );
+	return hDeg;
+
+}
+
 /**
  * Resample an IESProfile onto a fixed-size 2D grid suitable for a
  * DataArrayTexture layer. Values are normalised to [0,1] by `maxCandela`
  * so the shader gets a pure shape multiplier; absolute intensity scaling
  * stays in `light.intensity`.
  *
- * UV convention:
+ * UV convention (TSL/LightsCore.js sampleIESProfile reads it so):
  *   U = horizontal angle / 360  (0..1)
  *   V = vertical angle / 180    (0..1, 0 = bulb axis, 1 = opposite axis)
  *
- * Profiles that are rotationally symmetric (single horizontal sample, or all
- * H angles identical) replicate the row across the U axis so the shader can
- * sample uniformly without a symmetry flag.
+ * The grid always spans the whole sphere: a downlight's 0–90° fills the lower half and leaves the upper dark, and
+ * a horizontal range with a symmetry is mirrored round (storedHorizontalAngle). Angles outside the file's range
+ * emit nothing. Type A and B profiles, whose angles mean something else, are stretched over the grid as before.
  *
  * @param {IESProfile} profile
  * @param {number} width   - texture width in samples (horizontal/U axis)
@@ -147,20 +167,34 @@ export function parseIES( text, name = 'ies' ) {
 export function resampleIESToGrid( profile, width, height ) {
 
 	const data = new Uint8Array( width * height );
-	const { verticalAngles: vA, horizontalAngles: hA, candela, maxCandela } = profile;
+	const { verticalAngles: vA, horizontalAngles: hA, candela, maxCandela, photometricType } = profile;
 
 	if ( maxCandela <= 0 ) return data; // dead profile → zeros
 
-	const vMaxDeg = vA[ vA.length - 1 ];
-	const hMaxDeg = hA[ hA.length - 1 ];
+	const typeC = photometricType === undefined || photometricType === 1;
+	const vMin = vA[ 0 ];
+	const vMax = vA[ vA.length - 1 ];
 	const hMin = hA[ 0 ];
-	const rotationallySymmetric = hA.length === 1 || hMaxDeg === hMin;
+	const hMax = hA[ hA.length - 1 ];
+	const rotationallySymmetric = hA.length === 1 || hMax === hMin;
+
+	const at = ( v0, v1, vt, hDeg ) => {
+
+		if ( rotationallySymmetric ) return lerp( candela[ v0 ][ 0 ], candela[ v1 ][ 0 ], vt );
+		if ( hDeg < hMin || hDeg > hMax ) return 0;
+		const h0 = lowerBoundIdx( hA, hDeg );
+		const h1 = Math.min( h0 + 1, hA.length - 1 );
+		const hSpan = hA[ h1 ] - hA[ h0 ];
+		const ht = hSpan > 0 ? ( hDeg - hA[ h0 ] ) / hSpan : 0;
+		return lerp( lerp( candela[ v0 ][ h0 ], candela[ v0 ][ h1 ], ht ), lerp( candela[ v1 ][ h0 ], candela[ v1 ][ h1 ], ht ), vt );
+
+	};
 
 	for ( let py = 0; py < height; py ++ ) {
 
-		// V coordinate → vertical angle in degrees. Texture covers [0, vMaxDeg].
 		const tV = ( py + 0.5 ) / height;
-		const vDeg = tV * vMaxDeg;
+		const vDeg = typeC ? tV * 180 : vMin + tV * ( vMax - vMin );
+		if ( vDeg < vMin || vDeg > vMax ) continue;
 		const v0 = lowerBoundIdx( vA, vDeg );
 		const v1 = Math.min( v0 + 1, vA.length - 1 );
 		const vSpan = vA[ v1 ] - vA[ v0 ];
@@ -168,31 +202,9 @@ export function resampleIESToGrid( profile, width, height ) {
 
 		for ( let px = 0; px < width; px ++ ) {
 
-			let cd;
-
-			if ( rotationallySymmetric ) {
-
-				// Single column → just bilerp on V axis.
-				cd = lerp( candela[ v0 ][ 0 ], candela[ v1 ][ 0 ], vt );
-
-			} else {
-
-				const tH = ( px + 0.5 ) / width;
-				const hDeg = hMin + tH * ( hMaxDeg - hMin );
-				const h0 = lowerBoundIdx( hA, hDeg );
-				const h1 = Math.min( h0 + 1, hA.length - 1 );
-				const hSpan = hA[ h1 ] - hA[ h0 ];
-				const ht = hSpan > 0 ? ( hDeg - hA[ h0 ] ) / hSpan : 0;
-
-				const c00 = candela[ v0 ][ h0 ];
-				const c10 = candela[ v0 ][ h1 ];
-				const c01 = candela[ v1 ][ h0 ];
-				const c11 = candela[ v1 ][ h1 ];
-				cd = lerp( lerp( c00, c10, ht ), lerp( c01, c11, ht ), vt );
-
-			}
-
-			const norm = Math.min( 1, Math.max( 0, cd / maxCandela ) );
+			const tH = ( px + 0.5 ) / width;
+			const hDeg = typeC ? storedHorizontalAngle( tH * 360, hMin, hMax ) : hMin + tH * ( hMax - hMin );
+			const norm = Math.min( 1, Math.max( 0, at( v0, v1, vt, hDeg ) / maxCandela ) );
 			data[ py * width + px ] = Math.round( norm * 255 );
 
 		}

package/src/Processor/InstanceTable.js

@@ -9,7 +9,7 @@
  * denormalised one. World bounds and the inverse transform are derived on demand.
  */
 
-import { BVH_LEAF_MARKERS, TRIANGLE_DATA_LAYOUT, assertBVHIndexFits, bvhIndexView } from '../EngineDefaults.js';
+import { TRIANGLE_DATA_LAYOUT, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView } from './BufferLayout.js';
 
 const IDENTITY = Float64Array.from( [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ] );
 

package/src/Processor/KernelManager.js

@@ -95,11 +95,44 @@ export class KernelManager {
 	 * Register a pre-built compute node.
 	 * @param {string} name - Kernel name (e.g. 'generate', 'extend')
 	 * @param {ComputeNode} computeNode - Built via `Fn().compute([dx,dy,dz], [wgx,wgy,wgz])`
+	 * @param {{eager?: boolean}} [options] - `eager: false` leaves it out of compile(): it compiles at its first dispatch
 	 */
-	register( name, computeNode ) {
+	register( name, computeNode, { eager = true } = {} ) {
 
 		this.kernels.set( name, computeNode );
-		this.timing.set( name, { compiledOnce: false, lastDispatchMs: 0 } );
+		this.timing.set( name, { compiledOnce: false, lastDispatchMs: 0, eager } );
+
+	}
+
+	/**
+	 * Whether compile() can run here: three yields between build steps through scheduler.yield or requestAnimationFrame,
+	 * and Node has neither (nor a page to keep responsive).
+	 */
+	static get canCompileInBackground() {
+
+		return typeof globalThis.requestAnimationFrame === 'function' || typeof globalThis.scheduler?.yield === 'function';
+
+	}
+
+	/**
+	 * Compiles the eager kernels without blocking the page: three.js generates their WGSL in steps that yield and
+	 * creates the GPU pipelines asynchronously. A dispatch after it compiles nothing.
+	 * @returns {Promise<void>}
+	 */
+	async compile() {
+
+		const eager = [ ...this.kernels ].filter( ( [ name ] ) => this.timing.get( name )?.eager );
+		const t0 = performance.now();
+		// One call per kernel, all at once: the GPU compiles them side by side rather than each after the last.
+		await Promise.all( eager.map( ( [ , node ] ) => this.renderer.compileComputeAsync( node ) ) );
+		for ( const [ name ] of eager ) {
+
+			const entry = this.timing.get( name );
+			if ( entry ) entry.compiledOnce = true;
+
+		}
+
+		log.info( `${eager.length} kernels compiled in the background in ${fmt.ms( performance.now() - t0 )}` );
 
 	}
 

package/src/Processor/MaterialPacking.js

@@ -1,4 +1,5 @@
-import { MATERIAL_DATA_LAYOUT as M, MATERIAL_DEFAULTS as D, normalizeAttenuationDistance } from '../EngineDefaults.js';
+import { MATERIAL_DEFAULTS as D } from '../EngineDefaults.js';
+import { MATERIAL_DATA_LAYOUT as M, normalizeAttenuationDistance } from './BufferLayout.js';
 
 // The first 8 Matrix3 elements; the GPU rebuilds the 9th (always 1).
 const IDENTITY_UV = [ 1, 0, 0, 0, 1, 0, 0, 0 ];
@@ -15,8 +16,7 @@ const TRANSFORMS = [
 
 /** Floats no field writes; the packer gives them fixed values. */
 export const MATERIAL_RESERVED_FLOATS = Object.freeze( [
-	M.VISIBLE, M.SHEEN_COLOR + 3, M.DISPLACEMENT_MAP_INDEX + 1,
-	M.SPECULAR_COLOR_MAP_INDEX + 1, M.SPECULAR_COLOR_MAP_INDEX + 2, M.SPECULAR_COLOR_MAP_INDEX + 3,
+	M.VISIBLE, M.DISPLACEMENT_MAP_INDEX + 1, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 1, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 2,
 ] );
 
 /**
@@ -25,7 +25,7 @@ export const MATERIAL_RESERVED_FLOATS = Object.freeze( [
  */
 export const UNIT_RANGE_PROPERTIES = Object.freeze( new Set( [
 	'metalness', 'roughness', 'transmission', 'opacity', 'clearcoat', 'clearcoatRoughness',
-	'sheen', 'sheenRoughness', 'specularIntensity', 'iridescence', 'subsurface', 'anisotropy',
+	'sheen', 'sheenRoughness', 'specularIntensity', 'iridescence', 'subsurface', 'anisotropy', 'diffuseTransmission',
 ] ) );
 
 export const clampUnit = ( value ) => Math.min( Math.max( value, 0 ), 1 );
@@ -116,6 +116,7 @@ export function packMaterial( data, base, mat ) {
 	u( M.SHEEN_ROUGHNESS, mat.sheenRoughness, D.sheenRoughness );
 
 	writeTriple( data, base + M.SHEEN_COLOR, mat.sheenColor, D.sheenColor );
+	u( M.DIFFUSE_TRANSMISSION, mat.diffuseTransmission, D.diffuseTransmission );
 
 	u( M.SPECULAR_INTENSITY, mat.specularIntensity, D.specularIntensity );
 	writeTriple( data, base + M.SPECULAR_COLOR, mat.specularColor, D.specularColor );
@@ -157,12 +158,13 @@ export function packMaterial( data, base, mat ) {
 	data[ base + M.SPECULAR_INTENSITY_MAP_INDEX ] = mapIndex( mat.specularIntensityMap );
 
 	data[ base + M.SPECULAR_COLOR_MAP_INDEX ] = mapIndex( mat.specularColorMap );
+	writeTriple( data, base + M.DIFFUSE_TRANSMISSION_COLOR, mat.diffuseTransmissionColor, D.diffuseTransmissionColor );
+	data[ base + M.DIFFUSE_TRANSMISSION_MAP_INDEX ] = mapIndex( mat.diffuseTransmissionMap );
+	data[ base + M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX ] = mapIndex( mat.diffuseTransmissionColorMap );
 
 	data[ base + M.VISIBLE ] = 1;
-	data[ base + M.SHEEN_COLOR + 3 ] = 1;
 	data[ base + M.DISPLACEMENT_MAP_INDEX + 1 ] = 0;
-	data[ base + M.SPECULAR_COLOR_MAP_INDEX + 1 ] = 0;
-	data[ base + M.SPECULAR_COLOR_MAP_INDEX + 2 ] = 0;
-	data[ base + M.SPECULAR_COLOR_MAP_INDEX + 3 ] = 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

@@ -9,6 +9,7 @@
  */
 
 import { MeshPhysicalMaterial, Color, DoubleSide } from 'three';
+import { namedScattering, dipoleReflectance, albedoForReflectance } from './PBRTScattering.js';
 
 // Normal-incidence reflectance approximations for pbrt's named conductor spectra.
 const METAL_ALBEDO = {
@@ -65,6 +66,13 @@ export function pString( params, name, dflt ) {
 
 }
 
+export function pBool( params, name, dflt ) {
+
+	const v = params[ name ]?.value?.[ 0 ];
+	return v === undefined ? dflt : v === true || v === 'true';
+
+}
+
 /**
  * Resolve a spectrum/color/float-valued parameter to an RGB triple and/or a
  * texture. Returns `{ rgb, texture }` — exactly one is typically non-null.
@@ -144,15 +152,191 @@ function namedMetalKey( s ) {
 
 }
 
-/** Roughness from `roughness` or anisotropic `uroughness`/`vroughness`. */
-function resolveRoughness( params, dflt ) {
+// 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 ];
+	if ( ! p ) return null;
+	if ( typeof p.value[ 0 ] === 'number' ) return p.value[ 0 ];
+	if ( p.type === 'texture' ) return ( await ctx.floatTextureMean?.( p.value[ 0 ] ) ) ?? null;
+	return null;
+
+}
+
+/**
+ * The engine's roughness for pbrt's `roughness` or anisotropic `uroughness`/`vroughness` (their α averaged), under
+ * `prefix` for a layer (`conductor.`, `interface.`); a textured roughness counts as its mean. pbrt-v4 takes GGX
+ * α = √roughness (`remaproughness`, the default) or α = roughness; the engine's GGX takes α = roughness². Passing
+ * pbrt's number through made `remaproughness false` 0.1 an α of 0.01, a near mirror. `dflt` is the engine's.
+ */
+const remapsRoughness = ( params ) => {
+
+	const remap = params.remaproughness?.value?.[ 0 ];
+	return remap !== false && remap !== 'false';
+
+};
+
+async function resolveRoughness( params, dflt, ctx, prefix = '' ) {
+
+	const remap = remapsRoughness( params );
+	const alpha = ( r ) => ( remap ? Math.sqrt( Math.max( r, 0 ) ) : r );
+	let a = null;
+	const r = await floatOrMean( params, `${prefix}roughness`, ctx );
+	if ( r !== null ) a = alpha( r );
+	else {
+
+		const u = await floatOrMean( params, `${prefix}uroughness`, ctx );
+		const v = await floatOrMean( params, `${prefix}vroughness`, ctx );
+		if ( u !== null ) a = v !== null ? ( alpha( u ) + alpha( v ) ) / 2 : alpha( u );
+
+	}
+
+	return a === null ? dflt : Math.sqrt( Math.max( a, 0 ) );
+
+}
+
+/**
+ * Sets `target` (`roughness` or `clearcoatRoughness`) as resolveRoughness does, except that a textured roughness becomes
+ * a roughness map with the remap baked in (`ctx.bakeFloatMap`), the value 1 multiplying it.
+ */
+async function applyRoughness( mat, target, params, dflt, ctx, prefix = '' ) {
+
+	const single = params[ `${prefix}roughness` ];
+	const keys = single ? [ `${prefix}roughness` ] : [ `${prefix}uroughness`, `${prefix}vroughness` ].filter( ( key ) => params[ key ] );
+	if ( ctx.bakeFloatMap && keys.some( ( key ) => params[ key ].type === 'texture' ) ) {
+
+		const remap = remapsRoughness( params );
+		const alpha = ( r ) => ( remap ? Math.sqrt( Math.max( r, 0 ) ) : Math.max( r, 0 ) );
+		const map = await ctx.bakeFloatMap( params, keys, ( values ) => Math.sqrt( values.reduce( ( sum, r ) => sum + alpha( r ), 0 ) / values.length ) );
+		if ( map ) {
+
+			mat[ `${target}Map` ] = map;
+			mat[ target ] = 1;
+			return;
+
+		}
+
+	}
+
+	mat[ target ] = await resolveRoughness( 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 ) {
 
-	if ( params.roughness && typeof params.roughness.value[ 0 ] === 'number' ) return params.roughness.value[ 0 ];
-	const u = pFloat( params, 'uroughness', null );
-	const v = pFloat( params, 'vroughness', null );
-	if ( u !== null && v !== null ) return ( u + v ) / 2;
-	if ( u !== null ) return u;
-	return dflt;
+	const p = params[ key ];
+	if ( p?.type === 'texture' ) return ( await ctx.textureMeanRGB?.( p.value[ 0 ] ) ) ?? dflt;
+	return ( await resolveSpectrum( params, key, ctx, dflt ) ).rgb ?? dflt;
+
+}
+
+// pbrt's default subsurface medium (materials.cpp), mm⁻¹.
+const SUBSURFACE_SIGMA_A = [ 0.0011, 0.0024, 0.014 ];
+const SUBSURFACE_SIGMA_S = [ 2.55, 3.21, 3.77 ];
+
+/**
+ * pbrt's `subsurface` as the engine's random walk under a dielectric boundary of `eta`: σt = σa + σs (times `scale`),
+ * single-scattering albedo σs / σt, mean free path 1 / σt. The coefficients come as pbrt takes them — a named medium
+ * (g 0), `sigma_a` and `sigma_s`, or a `reflectance` and `mfp` (scaled) inverted through the dipole — and default to
+ * pbrt's. The base colour is the reflectance the dipole gives, for what reads it as an albedo.
+ */
+async function applySubsurface( mat, params, ctx ) {
+
+	const eta = pFloat( 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 );
+	let sigmaA, sigmaS;
+
+	const name = pString( params, 'name', '' );
+	const named = name ? namedScattering( name ) : null;
+	if ( name && ! named ) ctx.warn( `subsurface: no medium named "${name}" — using pbrt's default` );
+
+	if ( named ) {
+
+		sigmaA = scaled( named.sigmaA );
+		sigmaS = scaled( named.sigmaS );
+		g = 0;
+
+	} else if ( params.sigma_a && params.sigma_s ) {
+
+		sigmaA = scaled( await spectrumMean( params, 'sigma_a', ctx, SUBSURFACE_SIGMA_A ) );
+		sigmaS = scaled( await spectrumMean( params, 'sigma_s', ctx, SUBSURFACE_SIGMA_S ) );
+
+	} else if ( params.reflectance && ! name ) {
+
+		const reflectance = await spectrumMean( params, 'reflectance', ctx, [ 0.5, 0.5, 0.5 ] );
+		const mfp = scaled( params.mfp ? await spectrumMean( params, 'mfp', ctx, [ 1, 1, 1 ] ) : [ 1, 1, 1 ] );
+		sigmaA = [];
+		sigmaS = [];
+		for ( let c = 0; c < 3; c ++ ) {
+
+			const sigmaT = 1 / Math.max( mfp[ c ], 1e-9 );
+			// The reduced albedo σ′s / ( σa + σ′s ), σ′s = ( 1 − g ) σs, back to σs at this σt.
+			const reduced = albedoForReflectance( reflectance[ c ], eta );
+			sigmaS[ c ] = reduced * sigmaT / ( 1 - g + reduced * g );
+			sigmaA[ c ] = sigmaT - sigmaS[ c ];
+
+		}
+
+	} else {
+
+		sigmaA = scaled( SUBSURFACE_SIGMA_A );
+		sigmaS = scaled( SUBSURFACE_SIGMA_S );
+
+	}
+
+	const sigmaT = sigmaA.map( ( a, c ) => a + sigmaS[ c ] );
+	mat.subsurface = 1;
+	mat.subsurfaceColor = new Color( ...sigmaT.map( ( t, c ) => ( t > 0 ? sigmaS[ c ] / t : 0 ) ) );
+	mat.subsurfaceRadius = sigmaT.map( ( t ) => ( t > 0 ? 1 / t : 1e6 ) );
+	mat.subsurfaceRadiusScale = 1;
+	mat.subsurfaceAnisotropy = Math.max( - 0.99, Math.min( 0.99, g ) );
+	mat.ior = eta;
+	mat.metalness = 0;
+	mat.color.setRGB( ...sigmaT.map( ( t, c ) => {
+
+		const reducedS = ( 1 - g ) * sigmaS[ c ];
+		return t > 0 ? dipoleReflectance( reducedS / ( sigmaA[ c ] + reducedS ), eta ) : 0;
+
+	} ) );
+	await applyRoughness( mat, 'roughness', params, 0, ctx );
+
+}
+
+// A conductor's colour: `reflectance`, else normal-incidence Fresnel of `eta`/`k` (under `prefix` for a coated
+// conductor). pbrt's default is copper.
+async function applyConductorColor( mat, params, ctx, prefix, applyAlbedo, setColor ) {
+
+	const refl = await resolveSpectrum( params, 'reflectance', ctx, null );
+	const etaP = params[ `${prefix}eta` ], kP = params[ `${prefix}k` ];
+	const etaNamed = etaP && etaP.type === 'spectrum' && typeof etaP.value[ 0 ] === 'string';
+
+	if ( refl.rgb || refl.texture ) {
+
+		applyAlbedo( refl );
+
+	} else if ( etaP && kP && ! etaNamed ) {
+
+		// Normal-incidence reflectance from complex IOR: ((η-1)²+k²)/((η+1)²+k²).
+		const eta = ( await resolveSpectrum( params, `${prefix}eta`, ctx, [ 0.2, 0.92, 1.1 ] ) ).rgb;
+		const k = ( await resolveSpectrum( params, `${prefix}k`, ctx, [ 3.9, 2.45, 2.14 ] ) ).rgb;
+		const fr = ( n, kk ) => ( ( n - 1 ) ** 2 + kk ** 2 ) / ( ( n + 1 ) ** 2 + kk ** 2 );
+		setColor( [ fr( eta[ 0 ], k[ 0 ] ), fr( eta[ 1 ], k[ 1 ] ), fr( eta[ 2 ], k[ 2 ] ) ] );
+
+	} else if ( etaP ) {
+
+		// Named conductor spectrum → metal albedo table.
+		setColor( ( await resolveSpectrum( params, `${prefix}eta`, ctx, DEFAULT_METAL ) ).rgb || DEFAULT_METAL );
+
+	} else {
+
+		setColor( METAL_ALBEDO.cu ); // pbrt-v4 default conductor is copper
+
+	}
+
+	mat.metalness = 1;
 
 }
 
@@ -193,9 +377,11 @@ export async function buildMaterial( def, ctx ) {
 
 		case 'diffuse': {
 
+			// Lambertian: no dielectric specular layer, which MeshPhysicalMaterial has by default.
 			applyAlbedo( await resolveSpectrum( params, 'reflectance', ctx, [ 0.5, 0.5, 0.5 ] ) );
 			mat.roughness = 1;
 			mat.metalness = 0;
+			mat.specularIntensity = 0;
 			break;
 
 		}
@@ -203,35 +389,19 @@ export async function buildMaterial( def, ctx ) {
 		case 'conductor':
 		case 'metal': {
 
-			const refl = await resolveSpectrum( params, 'reflectance', ctx, null );
-			const etaP = params.eta, kP = params.k;
-			const etaNamed = etaP && etaP.type === 'spectrum' && typeof etaP.value[ 0 ] === 'string';
-
-			if ( refl.rgb || refl.texture ) {
-
-				applyAlbedo( refl );
-
-			} else if ( etaP && kP && ! etaNamed ) {
-
-				// Normal-incidence reflectance from complex IOR: ((η-1)²+k²)/((η+1)²+k²).
-				const eta = ( await resolveSpectrum( params, 'eta', ctx, [ 0.2, 0.92, 1.1 ] ) ).rgb;
-				const k = ( await resolveSpectrum( params, 'k', ctx, [ 3.9, 2.45, 2.14 ] ) ).rgb;
-				const fr = ( n, kk ) => ( ( n - 1 ) ** 2 + kk ** 2 ) / ( ( n + 1 ) ** 2 + kk ** 2 );
-				setColor( [ fr( eta[ 0 ], k[ 0 ] ), fr( eta[ 1 ], k[ 1 ] ), fr( eta[ 2 ], k[ 2 ] ) ] );
-
-			} else if ( etaP ) {
-
-				// Named conductor spectrum → metal albedo table.
-				setColor( ( await resolveSpectrum( params, 'eta', ctx, DEFAULT_METAL ) ).rgb || DEFAULT_METAL );
-
-			} else {
+			await applyConductorColor( mat, params, ctx, '', applyAlbedo, setColor );
+			await applyRoughness( mat, 'roughness', params, 0.1, ctx );
+			break;
 
-				setColor( METAL_ALBEDO.cu ); // pbrt-v4 default conductor is copper
+		}
 
-			}
+		case 'coatedconductor': {
 
-			mat.metalness = 1;
-			mat.roughness = resolveRoughness( params, 0.1 );
+			// A conductor under a dielectric coat; pbrt's roughnesses default to 0 for both.
+			await applyConductorColor( mat, params, ctx, 'conductor.', applyAlbedo, setColor );
+			await applyRoughness( mat, 'roughness', params, 0, ctx, 'conductor.' );
+			mat.clearcoat = 1;
+			await applyRoughness( mat, 'clearcoatRoughness', params, 0, ctx, 'interface.' );
 			break;
 
 		}
@@ -243,7 +413,7 @@ export async function buildMaterial( def, ctx ) {
 			mat.metalness = 0;
 			mat.color.setRGB( 1, 1, 1 );
 			mat.ior = pFloat( params, 'eta', 1.5 );
-			mat.roughness = resolveRoughness( params, 0 );
+			await applyRoughness( mat, 'roughness', params, 0, ctx );
 			mat.thickness = type === 'thindielectric' ? 0 : pFloat( params, 'thickness', 0 );
 			break;
 
@@ -255,18 +425,30 @@ export async function buildMaterial( def, ctx ) {
 			mat.roughness = 0.6;
 			mat.metalness = 0;
 			mat.clearcoat = 1;
-			mat.clearcoatRoughness = resolveRoughness( params, 0 );
+			await applyRoughness( mat, 'clearcoatRoughness', params, 0, ctx );
 			break;
 
 		}
 
 		case 'diffusetransmission': {
 
+			// pbrt reflects R and transmits T, both diffusely and both × `scale`, clamped to [0, 1]; no specular layer.
+			// The engine splits its diffuse lobe by `diffuseTransmission`: reflecting (1 − dt) · base, transmitting
+			// dt · colour. dt = max(T) makes both exact whenever max(R) + max(T) ≤ 1.
+			const scale = pFloat( params, 'scale', 1 );
+			const unit = ( v ) => Math.min( 1, Math.max( 0, scale * v ) );
 			const trans = await resolveSpectrum( params, 'transmittance', ctx, [ 0.25, 0.25, 0.25 ] );
-			applyAlbedo( await resolveSpectrum( params, 'reflectance', ctx, [ 0.25, 0.25, 0.25 ] ) );
-			mat.transmission = trans.rgb ? ( trans.rgb[ 0 ] + trans.rgb[ 1 ] + trans.rgb[ 2 ] ) / 3 : 0.5;
+			const T = trans.rgb ? trans.rgb.map( unit ) : [ 0.5, 0.5, 0.5 ];
+			const dt = Math.min( 0.99, Math.max( ...T ) );
+			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' );
+			mat.diffuseTransmission = dt;
+			mat.diffuseTransmissionColor = new Color().setRGB( ...T.map( ( v ) => ( dt > 0 ? Math.min( 1, v / dt ) : 1 ) ) );
 			mat.roughness = 1;
-			mat.ior = 1.0;
+			mat.metalness = 0;
+			mat.specularIntensity = 0;
 			break;
 
 		}
@@ -292,13 +474,18 @@ export async function buildMaterial( def, ctx ) {
 			// 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 t = Math.max( 0, Math.min( 1, pFloat( params, 'amount', 0.5 ) ) );
+			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;
 
 			if ( defA && defB ) {
 
 				const [ matA, matB ] = await Promise.all( [ buildMaterial( defA, ctx ), buildMaterial( defB, ctx ) ] );
+				// pbrt picks the second material where a texture amount says so; its colours are baked by that
+				// texture (`ctx.bakeMaterialMix`) and the rest is weighed by the texture's mean.
+				const amountP = params.amount;
+				const baked = amountP?.type === 'texture' ? await ctx.bakeMaterialMix?.( matA, matB, amountP.value[ 0 ] ) : null;
+				if ( baked ) t = baked.mean;
 				const lerp = ( a, b ) => a * ( 1 - t ) + b * t;
 				mat.color.lerpColors( matA.color, matB.color, t );
 				mat.roughness = lerp( matA.roughness, matB.roughness );
@@ -309,9 +496,25 @@ export async function buildMaterial( def, ctx ) {
 				mat.clearcoat = lerp( matA.clearcoat ?? 0, matB.clearcoat ?? 0 );
 				mat.clearcoatRoughness = lerp( matA.clearcoatRoughness ?? 0, matB.clearcoatRoughness ?? 0 );
 				mat.emissive.lerpColors( matA.emissive, matB.emissive, t );
+				const dtA = matA.diffuseTransmission ?? 0, dtB = matB.diffuseTransmission ?? 0;
+				if ( dtA > 0 || dtB > 0 ) {
+
+					mat.diffuseTransmission = lerp( dtA, dtB );
+					mat.diffuseTransmissionColor = new Color().lerpColors( matA.diffuseTransmissionColor ?? new Color( 1, 1, 1 ), matB.diffuseTransmissionColor ?? new Color( 1, 1, 1 ), t );
+
+				}
+
 				mat.emissiveIntensity = lerp( matA.emissiveIntensity ?? 0, matB.emissiveIntensity ?? 0 );
-				// Maps can't be lerped — pick the dominant side.
+				// Maps can't be lerped — pick the dominant side, unless the amount's own texture baked them together.
 				mat.map = ( t < 0.5 ? matA.map : matB.map ) || null;
+				mat.normalMap = ( t < 0.5 ? matA.normalMap : matB.normalMap ) || null;
+				if ( baked?.texture ) {
+
+					mat.map = baked.texture;
+					mat.color.setRGB( 1, 1, 1 );
+
+				}
+
 				break;
 
 			}
@@ -322,7 +525,13 @@ export async function buildMaterial( def, ctx ) {
 
 		}
 
-		case 'subsurface':
+		case 'subsurface': {
+
+			await applySubsurface( mat, params, ctx );
+			break;
+
+		}
+
 		case 'hair':
 		case 'measured': {
 
@@ -344,6 +553,9 @@ export async function buildMaterial( def, ctx ) {
 
 	}
 
+	const normalMap = pString( params, 'normalmap', null );
+	if ( normalMap && ctx.resolveNormalMap ) mat.normalMap = await ctx.resolveNormalMap( normalMap );
+
 	mat.roughness = Math.max( 0, Math.min( 1, mat.roughness ) );
 	return mat;