rayzee 10.0.0 → 11.0.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

@@ -65,6 +65,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 +151,74 @@ 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.
+ */
+async function resolveRoughness( params, dflt, ctx, prefix = '' ) {
+
+	const remap = params.remaproughness?.value?.[ 0 ];
+	const alpha = ( r ) => ( remap === false || remap === 'false' ? r : Math.sqrt( Math.max( r, 0 ) ) );
+	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 ) );
+
+}
+
+// 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 ) {
 
-	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;
+		// 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 +259,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 +271,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 );
+			mat.roughness = await resolveRoughness( 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 );
+			mat.roughness = await resolveRoughness( params, 0, ctx, 'conductor.' );
+			mat.clearcoat = 1;
+			mat.clearcoatRoughness = await resolveRoughness( params, 0, ctx, 'interface.' );
 			break;
 
 		}
@@ -243,7 +295,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 );
+			mat.roughness = await resolveRoughness( params, 0, ctx );
 			mat.thickness = type === 'thindielectric' ? 0 : pFloat( params, 'thickness', 0 );
 			break;
 
@@ -255,18 +307,30 @@ export async function buildMaterial( def, ctx ) {
 			mat.roughness = 0.6;
 			mat.metalness = 0;
 			mat.clearcoat = 1;
-			mat.clearcoatRoughness = resolveRoughness( params, 0 );
+			mat.clearcoatRoughness = await resolveRoughness( 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 +356,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 +378,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;
 
 			}
@@ -344,6 +429,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;
 

package/src/Processor/PBRT/PBRTParser.js

@@ -111,6 +111,7 @@ export class PBRTParser {
 			instanceCount: 0,
 			skippedInstances: 0,
 			objects: new Map(),
+			media: new Map(),
 			transformTimes: { start: 0, end: 1 },
 			hasMotion: false,
 			warnings: []
@@ -122,14 +123,13 @@ export class PBRTParser {
 		this.activeTransform = BOTH;
 		this._ctmSource = null;
 		this._ctmValue = null;
-		this.state = { material: null, areaLight: null, reverseOrientation: false };
+		this.state = { material: null, areaLight: null, reverseOrientation: false, interior: null };
 		this.attributeStack = [];
 		this.transformStack = [];
 		this.coordSystems = new Map();
 
 		// Object capture (ObjectBegin/End)
 		this.currentObject = null; // name being captured, or null
-		this.objectBeginCTM = null; // CTM frame at ObjectBegin
 
 		// Directory stack for resolving nested Includes
 		this.dirStack = [ '' ];
@@ -275,7 +275,8 @@ export class PBRTParser {
 			activeTransform: this.activeTransform,
 			material: this.state.material,
 			areaLight: this.state.areaLight,
-			reverseOrientation: this.state.reverseOrientation
+			reverseOrientation: this.state.reverseOrientation,
+			interior: this.state.interior
 		} );
 
 	}
@@ -287,7 +288,7 @@ export class PBRTParser {
 		this.ctm = s.ctm;
 		this.ctmEnd = s.ctmEnd;
 		this.activeTransform = s.activeTransform;
-		this.state = { material: s.material, areaLight: s.areaLight, reverseOrientation: s.reverseOrientation };
+		this.state = { material: s.material, areaLight: s.areaLight, reverseOrientation: s.reverseOrientation, interior: s.interior };
 
 	}
 
@@ -624,7 +625,7 @@ export class PBRTParser {
 				this.ctm = M.identity();
 				this.ctmEnd = null;
 				this.activeTransform = BOTH;
-				this.state = { material: null, areaLight: null, reverseOrientation: false };
+				this.state = { material: null, areaLight: null, reverseOrientation: false, interior: null };
 				break;
 			case 'WorldEnd': break; // legacy v3
 
@@ -673,14 +674,21 @@ export class PBRTParser {
 
 			case 'MediumInterface': {
 
-				// up to two strings (inside/outside)
-				if ( this._peek() && this._peek().type === TokenType.STRING ) this._next();
-				if ( this._peek() && this._peek().type === TokenType.STRING ) this._next();
+				// "interior" "exterior"; a single name is both. Only the interior colours a shape.
+				const interior = this._peek()?.type === TokenType.STRING ? this._next().value : '';
+				if ( this._peek()?.type === TokenType.STRING ) this._next();
+				this.state.interior = interior || null;
 				break;
 
 			}
 
-			case 'MakeNamedMedium': this._skipNamedAndParams(); break;
+			case 'MakeNamedMedium': {
+
+				const mediumName = this._expectString( 'MakeNamedMedium name' );
+				this.ir.media.set( mediumName, this._parseParams() );
+				break;
+
+			}
 
 			// ── materials ──
 			case 'Material': {
@@ -748,13 +756,18 @@ export class PBRTParser {
 
 				const type = this._expectString( 'Shape type' );
 				const params = this._parseParams();
+				// pbrt: a shape of alpha 0 is never hit, and an area light on it emits nothing.
+				const alpha = params.alpha;
+				if ( alpha?.type === 'float' && alpha.value[ 0 ] <= 0 ) break;
+				if ( alpha && ! ( alpha.type === 'float' && alpha.value[ 0 ] >= 1 ) ) this._warnOnce( 'alpha', 'shape "alpha" between 0 and 1, or as a texture, is not supported — drawn opaque' );
 				const shape = {
 					type,
 					params,
 					ctm: this._ctmSnapshot(),
 					material: this.state.material,
 					areaLight: this.state.areaLight,
-					reverseOrientation: this.state.reverseOrientation
+					reverseOrientation: this.state.reverseOrientation,
+					interior: this.state.interior
 				};
 				const end = this.currentObject === null ? this._ctmEndSnapshot() : null;
 				if ( end ) shape.ctmEnd = end;
@@ -776,7 +789,6 @@ export class PBRTParser {
 				// pbrt implicitly pushes graphics state.
 				this._pushGraphicsState();
 				this.currentObject = objName;
-				this.objectBeginCTM = this.ctm.slice();
 				if ( ! this.ir.objects.has( objName ) ) this.ir.objects.set( objName, [] );
 				break;
 
@@ -785,7 +797,6 @@ export class PBRTParser {
 			case 'ObjectEnd': {
 
 				this.currentObject = null;
-				this.objectBeginCTM = null;
 				this._popGraphicsState();
 				break;
 
@@ -824,8 +835,8 @@ export class PBRTParser {
 
 		if ( this.currentObject !== null ) {
 
-			// Store relative to the ObjectBegin frame so instances can re-place it.
-			shape.relativeCTM = M.multiply( M.invert( this.objectBeginCTM ), shape.ctm );
+			// pbrt keeps a template shape's whole transform and puts each placement's on top of it,
+			// whatever the transform was at ObjectBegin (kroken defines under one and places at Identity).
 			this.ir.objects.get( this.currentObject ).push( shape );
 
 		} else {
@@ -880,7 +891,7 @@ export class PBRTParser {
 
 		if ( ! this.instanceIncludes || this.currentObject !== null ) return null;
 		if ( this.ctmEnd !== null || this.activeTransform !== BOTH || this.state.areaLight ) return null;
-		return `${dir}\0${path}\0${this._stateId( this.state.material )}\0${this.state.reverseOrientation}`;
+		return `${dir}\0${path}\0${this._stateId( this.state.material )}\0${this.state.reverseOrientation}\0${this.state.interior}`;
 
 	}
 
@@ -902,7 +913,8 @@ export class PBRTParser {
 			attributes: this.attributeStack.length,
 			transforms: this.transformStack.length,
 			material: this.state.material,
-			reverseOrientation: this.state.reverseOrientation
+			reverseOrientation: this.state.reverseOrientation,
+			interior: this.state.interior
 		};
 
 	}
@@ -912,7 +924,8 @@ export class PBRTParser {
 		return this._effects === before.effects && this.ctmEnd === null && this.activeTransform === BOTH &&
 			sameMatrix( this.ctm, before.ctm ) && this.attributeStack.length === before.attributes &&
 			this.transformStack.length === before.transforms && this.state.material === before.material &&
-			this.state.areaLight === null && this.state.reverseOrientation === before.reverseOrientation;
+			this.state.areaLight === null && this.state.reverseOrientation === before.reverseOrientation &&
+			this.state.interior === before.interior;
 
 	}