rayzee 10.0.0 → 11.1.0

package/src/Processor/PBRT/PBRTSceneBuilder.js

@@ -17,17 +17,33 @@
 import { freeNow, resized } from './buffers.js';
 import {
 	Group, Mesh, InstancedMesh, PerspectiveCamera, OrthographicCamera, Matrix4, Vector3, Quaternion,
-	BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute, SphereGeometry,
+	BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute,
 	DataTexture, FloatType, RGBAFormat, LinearFilter, EquirectangularReflectionMapping,
-	SRGBColorSpace, AnimationClip, VectorKeyframeTrack, QuaternionKeyframeTrack,
-	NumberKeyframeTrack, BooleanKeyframeTrack
+	SRGBColorSpace, NoColorSpace, AnimationClip, VectorKeyframeTrack, QuaternionKeyframeTrack,
+	NumberKeyframeTrack, BooleanKeyframeTrack, DirectionalLight, PointLight, SpotLight, FrontSide, DoubleSide,
+	RepeatWrapping
 } from 'three';
-import { buildMaterial, pFloat, pString, resolveSpectrum } from './PBRTMaterials.js';
+import { buildMaterial, pBool, pFloat, pString, resolveSpectrum } from './PBRTMaterials.js';
+import { makeLayer, layerMean, bake, mixOf, srgbToLinear, linearToSRGB, hasAlpha } from './PBRTTextureBake.js';
 import { loopSubdivide } from './LoopSubdivision.js';
 import { octahedralToEquirect } from './EqualAreaOctahedral.js';
 import { tessellateCurve } from './PBRTCurves.js';
 import * as M from './PBRTMath.js';
 
+const LAMP_TYPES = new Set( [ 'distant', 'point', 'spot' ] );
+
+// pbrt scales a light's spectrum to luminance 1 unless it is RGB, so a blackbody of any temperature is equally bright.
+async function lightRGB( params, name, ctx ) {
+
+	const p = params[ name ];
+	if ( p?.type === 'spectrum' && typeof p.value[ 0 ] === 'string' && p.value[ 0 ].startsWith( 'stdillum' ) ) return [ 1, 1, 1 ];
+	const rgb = ( await resolveSpectrum( params, name, ctx, [ 1, 1, 1 ] ) ).rgb || [ 1, 1, 1 ];
+	if ( ! p || p.type === 'rgb' || p.type === 'color' || p.type === 'float' ) return rgb;
+	const y = 0.2126 * rgb[ 0 ] + 0.7152 * rgb[ 1 ] + 0.0722 * rgb[ 2 ];
+	return y > 0 ? rgb.map( v => v / y ) : rgb;
+
+}
+
 const FLIP_Z = [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, - 1, 0, 0, 0, 0, 1 ];
 const MAX_SKY_READBACK = 4096;
 
@@ -75,11 +91,7 @@ const DEFAULT_TRIANGLE_BUDGET = 45_000_000;
 // Placements are their own budget: geometry is shared, but each costs a TLAS leaf and an
 // instance record. isCoastline's 5.09M loaded and rendered at 23 fps.
 const DEFAULT_PLACEMENT_BUDGET = 6_000_000;
-// With the memory spill the triangles and BVH leave the heap as the build goes, so the host
-// passes these instead. The whole 15-part Moana subset (55.7M / 7.0M) loads cold under them, at
-// an 8.1 GB preflight estimate; the preflight, not the budget, refuses anything larger.
-export const SPILL_TRIANGLE_BUDGET = 60_000_000;
-export const SPILL_PLACEMENT_BUDGET = 8_000_000;
+export { SPILL_TRIANGLE_BUDGET, SPILL_PLACEMENT_BUDGET } from '../HostMemory.js';
 // Non-instanced shapes merge into a few large meshes: isPalmRig declares 173,338 of them,
 // and one BufferGeometry + Mesh each measured 3.3 GB — the loader OOM'd before tracing.
 const DEFAULT_MERGE_MIN_SHAPES = 256;
@@ -95,7 +107,7 @@ const DEFAULT_CURVE_SIDES = { flat: 1, ribbon: 1, cylinder: 2 };
 const DEFAULT_CURVE_TOLERANCE = 0.05;
 
 /** Bumped whenever the same scene files build a different graph, so a stored graph is not reused. */
-export const PBRT_BUILD_REVISION = 4;
+export const PBRT_BUILD_REVISION = 9;
 
 function samePlacements( a, b ) {
 
@@ -135,6 +147,357 @@ function pixelsFromDrawable( image, srgb ) {
 
 }
 
+/**
+ * A texture's pixels, for baking: `{ data, width, height, channels: 4, topDown, float }`, or null where this runtime
+ * cannot read them. A DataTexture's rows run bottom up unless it says flipY; a drawable's top down.
+ */
+function texturePixels( texture ) {
+
+	const image = texture?.image;
+	if ( ! image ) return null;
+
+	if ( ArrayBuffer.isView( image.data ) ) {
+
+		return { data: image.data, width: image.width, height: image.height, channels: 4, topDown: texture.flipY === true, float: ! ( image.data instanceof Uint8Array || image.data instanceof Uint8ClampedArray ) };
+
+	}
+
+	const { width, height } = image;
+	if ( ! width || ! height ) return null;
+	let canvas = null;
+	if ( typeof OffscreenCanvas !== 'undefined' ) canvas = new OffscreenCanvas( width, height );
+	else if ( typeof document !== 'undefined' ) {
+
+		canvas = document.createElement( 'canvas' );
+		canvas.width = width;
+		canvas.height = height;
+
+	} else return null;
+
+	try {
+
+		const ctx = canvas.getContext( '2d', { willReadFrequently: true } );
+		if ( ! ctx ) return null;
+		ctx.drawImage( image, 0, 0 );
+		return { data: ctx.getImageData( 0, 0, width, height ).data, width, height, channels: 4, topDown: true, float: false };
+
+	} catch {
+
+		return null;
+
+	}
+
+}
+
+// pbrt's `encoding`: an 8-bit image is sRGB unless it says "linear" (or "gamma g").
+function decoderFor( params ) {
+
+	const encoding = pString( params, 'encoding', 'sRGB' );
+	if ( encoding === 'linear' ) return ( v ) => v;
+	const gamma = /^gamma\s+([\d.]+)$/.exec( encoding );
+	return gamma ? ( v ) => v ** Number( gamma[ 1 ] ) : srgbToLinear;
+
+}
+
+function uvMapping( params ) {
+
+	return {
+		su: pFloat( params, 'uscale', 1 ), sv: pFloat( params, 'vscale', 1 ),
+		du: pFloat( params, 'udelta', 0 ), dv: pFloat( params, 'vdelta', 0 )
+	};
+
+}
+
+function setMapping( texture, { su, sv, du, dv } ) {
+
+	texture.repeat.set( su, sv );
+	texture.offset.set( du, dv );
+
+}
+
+/**
+ * A float image (EXR, HDR, PFM) as 8-bit, the only texel a material map takes here: sRGB-encoded for a colour,
+ * linear for data. Any other texture comes back as it is.
+ */
+function eightBit( texture, { srgb } ) {
+
+	const data = texture?.image?.data;
+	if ( ! ArrayBuffer.isView( data ) || data instanceof Uint8Array || data instanceof Uint8ClampedArray ) return texture;
+
+	const { width, height } = texture.image;
+	const bytes = new Uint8Array( width * height * 4 );
+	const channels = data.length / ( width * height );
+	for ( let i = 0; i < width * height; i ++ ) for ( let c = 0; c < 4; c ++ ) {
+
+		const v = c < channels ? Math.min( 1, Math.max( 0, data[ i * channels + c ] ) ) : 1;
+		bytes[ i * 4 + c ] = Math.round( 255 * ( srgb && c < 3 ? linearToSRGB( v ) : v ) );
+
+	}
+
+	const out = new DataTexture( bytes, width, height, RGBAFormat );
+	out.flipY = texture.flipY;
+	out.colorSpace = srgb ? SRGBColorSpace : NoColorSpace;
+	out.wrapS = out.wrapT = RepeatWrapping;
+	// No archive path: a stored scene keeps these bytes rather than decoding the float file again.
+	out.needsUpdate = true;
+	return out;
+
+}
+
+// A baked image as a texture: bytes bottom row first, sRGB unless a data map, in the uv mapping it was baked in.
+function bakedTexture( { data, width, height, mapping }, { srgb = true } = {} ) {
+
+	const texture = new DataTexture( data, width, height, RGBAFormat );
+	texture.colorSpace = srgb ? SRGBColorSpace : NoColorSpace;
+	texture.wrapS = texture.wrapT = RepeatWrapping;
+	setMapping( texture, mapping );
+	texture.needsUpdate = true;
+	return texture;
+
+}
+
+/**
+ * pbrt's thin lens as the camera's own effects (CameraManager applies them when the camera is chosen): the same
+ * aperture radius in either DOF mode — `dofBlur` for 'look', a full-frame lens and its f-number for 'physical' at one
+ * scene unit a metre — focused by hand at pbrt's distance.
+ */
+function lensEffects( camera, radius, focusDistance ) {
+
+	const ortho = camera.isOrthographicCamera === true;
+	const tanHalf = ortho ? 1 : Math.tan( camera.fov * Math.PI / 360 );
+	const focalLength = ortho ? 50 : 12 / tanHalf;
+	return {
+		enableDOF: true,
+		focusDistance,
+		aperture: focalLength * 0.001 / ( 2 * radius ),
+		focalLength,
+		apertureScale: 1,
+		anamorphicRatio: 1,
+		dofBlur: radius / ( focusDistance * tanHalf ),
+		autoFocusMode: 'manual',
+		afScreenPoint: { x: 0.5, y: 0.5 },
+		orthoHeight: ortho ? ( camera.top - camera.bottom ) / camera.zoom : null,
+	};
+
+}
+
+// What the scene asks the renderer for, where it says: the Integrator's maxdepth, the Sampler's pixelsamples, the Film's
+// resolution — scene metadata's `render`.
+function renderRequest( ir ) {
+
+	const render = {};
+	if ( ir.integrator?.maxdepth > 0 ) render.maxBounces = Math.round( ir.integrator.maxdepth );
+	if ( ir.sampler?.pixelsamples > 0 ) render.samples = Math.round( ir.sampler.pixelsamples );
+	if ( ir.film?.resolutionGiven ) {
+
+		render.width = ir.film.xresolution;
+		render.height = ir.film.yresolution;
+
+	}
+
+	return Object.keys( render ).length ? render : null;
+
+}
+
+const QUADRIC_SEGMENTS = 48; // around a whole turn
+
+// pbrt's quadric parameters, clamped as pbrt clamps them (shapes.h).
+function sphereParams( params ) {
+
+	const radius = pFloat( params, 'radius', 1 );
+	const z0 = pFloat( params, 'zmin', - radius ), z1 = pFloat( params, 'zmax', radius );
+	const clamp = ( z ) => Math.min( radius, Math.max( - radius, z ) );
+	return { radius, zMin: clamp( Math.min( z0, z1 ) ), zMax: clamp( Math.max( z0, z1 ) ), phiMax: phiMaxOf( params ) };
+
+}
+
+function cylinderParams( params ) {
+
+	const z0 = pFloat( params, 'zmin', - 1 ), z1 = pFloat( params, 'zmax', 1 );
+	return { radius: pFloat( params, 'radius', 1 ), zMin: Math.min( z0, z1 ), zMax: Math.max( z0, z1 ), phiMax: phiMaxOf( params ) };
+
+}
+
+function diskParams( params ) {
+
+	return {
+		radius: pFloat( params, 'radius', 1 ), inner: pFloat( params, 'innerradius', 0 ),
+		height: pFloat( params, 'height', 0 ), phiMax: phiMaxOf( params )
+	};
+
+}
+
+const phiMaxOf = ( params ) => Math.min( 360, Math.max( 0, pFloat( params, 'phimax', 360 ) ) ) * Math.PI / 180;
+
+/**
+ * A quadric as pbrt parameterises it: `at( u, v, p, n )` over [0, 1]², u around the z axis to `phiMax`; the uv is
+ * pbrt's own. Triangles face ∂p/∂u × ∂p/∂v, pbrt's normal; a cell edge of no length (a pole, a centre) drops its
+ * triangle.
+ */
+function quadric( phiMax, vSegments, at ) {
+
+	const uSegments = Math.max( 3, Math.ceil( QUADRIC_SEGMENTS * phiMax / ( 2 * Math.PI ) ) );
+	const row = uSegments + 1;
+	const position = new Float32Array( row * ( vSegments + 1 ) * 3 );
+	const normal = new Float32Array( position.length );
+	const uv = new Float32Array( row * ( vSegments + 1 ) * 2 );
+	const p = new Vector3(), n = new Vector3();
+
+	for ( let j = 0; j <= vSegments; j ++ ) for ( let i = 0; i <= uSegments; i ++ ) {
+
+		const k = j * row + i;
+		at( i / uSegments, j / vSegments, p, n );
+		p.toArray( position, k * 3 );
+		n.toArray( normal, k * 3 );
+		uv[ k * 2 ] = i / uSegments;
+		uv[ k * 2 + 1 ] = j / vSegments;
+
+	}
+
+	let extent = 0;
+	for ( let k = 0; k < position.length; k ++ ) extent = Math.max( extent, Math.abs( position[ k ] ) );
+	const apart = ( a, b ) => Math.hypot( position[ a * 3 ] - position[ b * 3 ], position[ a * 3 + 1 ] - position[ b * 3 + 1 ], position[ a * 3 + 2 ] - position[ b * 3 + 2 ] ) > extent * 1e-6;
+	const index = [];
+	for ( let j = 0; j < vSegments; j ++ ) for ( let i = 0; i < uSegments; i ++ ) {
+
+		const a = j * row + i, b = a + 1, c = a + row, d = c + 1;
+		if ( apart( a, b ) ) index.push( a, b, d );
+		if ( apart( c, d ) ) index.push( a, d, c );
+
+	}
+
+	const geometry = new BufferGeometry();
+	geometry.setAttribute( 'position', new Float32BufferAttribute( position, 3 ) );
+	geometry.setAttribute( 'normal', new Float32BufferAttribute( normal, 3 ) );
+	geometry.setAttribute( 'uv', new Float32BufferAttribute( uv, 2 ) );
+	geometry.setIndex( new Uint32BufferAttribute( new Uint32Array( index ), 1 ) );
+	return geometry;
+
+}
+
+// What pbrt calls a shape's area when it scales an area light's `power`: a quadric's in its own space, a mesh's in the
+// scene's (pbrt keeps triangles transformed).
+function shapeArea( shape, geometry ) {
+
+	const params = shape.params;
+	switch ( shape.type ) {
+
+		case 'sphere': {
+
+			const { radius, zMin, zMax, phiMax } = sphereParams( params );
+			return phiMax * radius * ( zMax - zMin );
+
+		}
+
+		case 'cylinder': {
+
+			const { radius, zMin, zMax, phiMax } = cylinderParams( params );
+			return phiMax * radius * ( zMax - zMin );
+
+		}
+
+		case 'disk': {
+
+			const { radius, inner, phiMax } = diskParams( params );
+			return phiMax * 0.5 * ( radius * radius - inner * inner );
+
+		}
+
+	}
+
+	const world = new Matrix4().fromArray( shape.ctm );
+	const position = geometry.getAttribute( 'position' );
+	const index = geometry.index;
+	const count = index ? index.count : position.count;
+	const a = new Vector3(), b = new Vector3(), c = new Vector3();
+	let area = 0;
+	for ( let t = 0; t + 2 < count; t += 3 ) {
+
+		a.fromBufferAttribute( position, index ? index.getX( t ) : t ).applyMatrix4( world );
+		b.fromBufferAttribute( position, index ? index.getX( t + 1 ) : t + 1 ).applyMatrix4( world );
+		c.fromBufferAttribute( position, index ? index.getX( t + 2 ) : t + 2 ).applyMatrix4( world );
+		area += b.sub( a ).cross( c.sub( a ) ).length() / 2;
+
+	}
+
+	return area;
+
+}
+
+const CHECK_TEXELS = 64; // a baked checkerboard's texels along one check
+const BILERP_TEXELS = 64;
+
+// `colorAt( s, t )` (linear RGB) over a w × h grid as sRGB bytes, bottom row first, clamped as pbrt clamps an albedo.
+function rasterize( width, height, colorAt ) {
+
+	const data = new Uint8Array( width * height * 4 );
+	for ( let j = 0; j < height; j ++ ) for ( let i = 0; i < width; i ++ ) {
+
+		const rgb = colorAt( ( i + 0.5 ) / width, ( j + 0.5 ) / height );
+		const o = ( j * width + i ) * 4;
+		for ( let c = 0; c < 3; c ++ ) data[ o + c ] = Math.round( 255 * linearToSRGB( Math.min( 1, Math.max( 0, rgb[ c ] ) ) ) );
+		data[ o + 3 ] = 255;
+
+	}
+
+	return data;
+
+}
+
+// A clone that keeps the engine's own material properties, which three.js's copy() does not know.
+function cloneMaterial( material ) {
+
+	const out = material.clone();
+	for ( const key of Object.keys( material ) ) if ( ! ( key in out ) ) out[ key ] = material[ key ];
+	return out;
+
+}
+
+// pbrt's shape alpha as the engine's blend mode: a ray passes with chance 1 − α, shadow rays too.
+function translucent( material, alpha ) {
+
+	const out = cloneMaterial( material );
+	out.transparent = true;
+	out.opacity = material.opacity * alpha;
+	return out;
+
+}
+
+const sameMapping = ( texture, { su, sv, du, dv } ) =>
+	texture.repeat.x === su && texture.repeat.y === sv && texture.offset.x === du && texture.offset.y === dv;
+
+// An 8-bit image's colour with its alpha decoded as pbrt reads it; null when its alpha is opaque throughout.
+function withDecodedAlpha( pixels, decode ) {
+
+	if ( pixels.float || ! hasAlpha( pixels ) ) return null;
+	const { data, width, height } = pixels;
+	const lut = new Uint8Array( 256 );
+	for ( let v = 0; v < 256; v ++ ) lut[ v ] = Math.round( 255 * Math.min( 1, Math.max( 0, decode( v / 255 ) ) ) );
+
+	const out = new Uint8Array( width * height * 4 );
+	const rowBytes = width * 4;
+	for ( let y = 0; y < height; y ++ ) {
+
+		const src = ( pixels.topDown ? height - 1 - y : y ) * rowBytes, dst = y * rowBytes;
+		for ( let x = 0; x < rowBytes; x += 4 ) {
+
+			out[ dst + x ] = data[ src + x ];
+			out[ dst + x + 1 ] = data[ src + x + 1 ];
+			out[ dst + x + 2 ] = data[ src + x + 2 ];
+			out[ dst + x + 3 ] = lut[ data[ src + x + 3 ] ];
+
+		}
+
+	}
+
+	const texture = new DataTexture( out, width, height, RGBAFormat );
+	texture.colorSpace = SRGBColorSpace;
+	texture.wrapS = texture.wrapT = RepeatWrapping;
+	texture.needsUpdate = true;
+	return texture;
+
+}
+
 /**
  * Names an unreadable texture may have been derived from. Moana binds colour as
  * `"texture reflectance" "el:part_Color"` and leaves `MakeNamedMaterial "el:part"` in the
@@ -192,6 +555,10 @@ export class PBRTSceneBuilder {
 		this._materialBySignature = new Map(); // visual signature -> shared MeshPhysicalMaterial
 		this._noUVMaterials = new Map(); // textured material -> its map-less clone
 		this._plyCache = new Map(); // filename -> Promise<BufferGeometry|null>
+		this._imageCache = new Map(); // filename -> Promise<Texture|null>, decoded once for every named texture
+		this._termCache = new Map(); // texture name + channels -> Promise<{rgb}|{layer, tint?}|null>
+		this._mediumMaterials = new Map(); // material -> Map(medium name -> material with its attenuation)
+		this._alphaMaterials = new Map(); // material -> Map(alpha texture name or #value -> Promise<material>)
 
 	}
 
@@ -249,11 +616,12 @@ export class PBRTSceneBuilder {
 			}
 
 			const shape = ir.shapes[ i ];
-			const [ geometry, sharedMaterial ] = await Promise.all( [
+			const [ geometry, surface ] = await Promise.all( [
 				this._batches ? this._createGeometry( shape ) : this._buildGeometry( shape ),
 				this._getMaterial( shape )
 			] );
 			if ( ! geometry ) continue;
+			const sharedMaterial = shape.areaLight ? this._poweredMaterial( shape, geometry, surface ) : surface;
 
 			// A moving shape needs a node of its own to move.
 			if ( this._batches && ! shape.motion && geometry.getAttribute( 'position' ).count <= MERGE_VERTEX_LIMIT ) {
@@ -308,6 +676,7 @@ export class PBRTSceneBuilder {
 
 		// Infinite light → environment
 		const environment = await this._buildEnvironment( ir.lights );
+		await this._buildLamps( ir.lights, group );
 
 		this._reportUnsupportedLights( ir.lights );
 
@@ -317,6 +686,7 @@ export class PBRTSceneBuilder {
 
 		return {
 			group, camera, environment, animations,
+			render: renderRequest( ir ),
 			report: this.report,
 			meshCount: this.reportedMeshes,
 			triangleCount: this.triangleCount,
@@ -740,7 +1110,7 @@ export class PBRTSceneBuilder {
 		if ( ! material ) {
 
 			this.warn( `${name} (${shape.type}, "${shape.material?.type || 'diffuse'}") has a texture map but no UVs — dropping map, using base color` );
-			material = sharedMaterial.clone();
+			material = cloneMaterial( sharedMaterial );
 			material.map = null;
 			this._noUVMaterials.set( sharedMaterial, material );
 
@@ -933,6 +1303,58 @@ export class PBRTSceneBuilder {
 
 	async _createGeometry( shape ) {
 
+		const geometry = await this._shapeGeometry( shape );
+		return geometry && shape.areaLight && ! pBool( shape.areaLight.params, 'twosided', false ) ? this._facingEmission( shape, geometry ) : geometry;
+
+	}
+
+	/**
+	 * A one-sided area light emits on the side pbrt's surface normal faces: towards the vertex normals where the shape
+	 * has them, else its winding's side, turned over by ReverseOrientation. The engine emits from a triangle's front,
+	 * so a triangle facing the other way is rewound, on an index of its own: the geometry may be shared.
+	 * @private
+	 */
+	_facingEmission( shape, geometry ) {
+
+		const normal = geometry.userData.pbrtNormals ? geometry.getAttribute( 'normal' ) : null;
+		if ( ! normal && ! shape.reverseOrientation ) return geometry;
+
+		const p = geometry.getAttribute( 'position' ).array, n = normal?.array;
+		const src = geometry.index?.array ?? null;
+		const count = src ? src.length : geometry.getAttribute( 'position' ).count;
+		const index = new Uint32Array( count );
+		let flipped = 0;
+
+		for ( let t = 0; t + 2 < count; t += 3 ) {
+
+			const a = src ? src[ t ] : t, b = src ? src[ t + 1 ] : t + 1, c = src ? src[ t + 2 ] : t + 2;
+			let flip = shape.reverseOrientation;
+			if ( n ) {
+
+				const ux = p[ b * 3 ] - p[ a * 3 ], uy = p[ b * 3 + 1 ] - p[ a * 3 + 1 ], uz = p[ b * 3 + 2 ] - p[ a * 3 + 2 ];
+				const vx = p[ c * 3 ] - p[ a * 3 ], vy = p[ c * 3 + 1 ] - p[ a * 3 + 1 ], vz = p[ c * 3 + 2 ] - p[ a * 3 + 2 ];
+				const sx = n[ a * 3 ] + n[ b * 3 ] + n[ c * 3 ], sy = n[ a * 3 + 1 ] + n[ b * 3 + 1 ] + n[ c * 3 + 1 ], sz = n[ a * 3 + 2 ] + n[ b * 3 + 2 ] + n[ c * 3 + 2 ];
+				flip = ( uy * vz - uz * vy ) * sx + ( uz * vx - ux * vz ) * sy + ( ux * vy - uy * vx ) * sz < 0;
+
+			}
+
+			index[ t ] = a;
+			index[ t + 1 ] = flip ? c : b;
+			index[ t + 2 ] = flip ? b : c;
+			if ( flip ) flipped ++;
+
+		}
+
+		if ( flipped === 0 ) return geometry;
+		const oriented = new BufferGeometry();
+		for ( const name in geometry.attributes ) oriented.setAttribute( name, geometry.getAttribute( name ) );
+		oriented.setIndex( new Uint32BufferAttribute( index, 1 ) );
+		return oriented;
+
+	}
+
+	_shapeGeometry( shape ) {
+
 		switch ( shape.type ) {
 
 			case 'trianglemesh': return this._triangleMesh( shape.params );
@@ -942,6 +1364,7 @@ export class PBRTSceneBuilder {
 			case 'plymesh': return this._plyMesh( shape.params );
 			case 'sphere': return this._sphere( shape.params );
 			case 'disk': return this._disk( shape.params );
+			case 'cylinder': return this._cylinder( shape.params );
 			default:
 				this.warn( `shape "${shape.type}" not supported — skipped` );
 				return null;
@@ -963,7 +1386,12 @@ export class PBRTSceneBuilder {
 		geo.setAttribute( 'position', new Float32BufferAttribute( float32( P ), 3 ) );
 
 		const N = params.N?.value;
-		if ( N && N.length === P.length ) geo.setAttribute( 'normal', new Float32BufferAttribute( float32( N ), 3 ) );
+		if ( N && N.length === P.length ) {
+
+			geo.setAttribute( 'normal', new Float32BufferAttribute( float32( N ), 3 ) );
+			geo.userData.pbrtNormals = true;
+
+		}
 
 		const uv = ( params.uv || params.st )?.value;
 		if ( uv && uv.length === ( P.length / 3 ) * 2 ) geo.setAttribute( 'uv', new Float32BufferAttribute( float32( uv ), 2 ) );
@@ -1047,28 +1475,75 @@ export class PBRTSceneBuilder {
 	}
 
 	// Bilinear patch mesh → triangulate each quad (P + indices in quads of 4).
+	/**
+	 * pbrt's bilinear patches as two triangles each: corners p00, p10, p01, p11 (not a ring), facing ∂p/∂u × ∂p/∂v. One
+	 * patch of four points needs no indices. Without uvs a patch takes its own (u, v), so its corners are not shared.
+	 */
 	_bilinearMesh( params ) {
 
 		const P = params.P?.value;
-		const quad = params.indices?.value;
+		const quad = params.indices?.value ?? ( P?.length === 12 ? [ 0, 1, 2, 3 ] : null );
 		if ( ! P || ! quad ) {
 
 			this.warn( 'bilinearmesh missing P/indices' ); return null;
 
 		}
 
-		const tris = [];
-		for ( let i = 0; i + 3 < quad.length; i += 4 ) {
+		const count = P.length / 3;
+		const uv = params.uv?.value?.length === count * 2 ? params.uv.value : null;
+		const N = params.N?.value?.length === count * 3 ? params.N.value : null;
+		const geo = new BufferGeometry();
+
+		if ( uv ) {
+
+			const index = [];
+			for ( let i = 0; i + 3 < quad.length; i += 4 ) {
+
+				const [ a, b, c, d ] = [ quad[ i ], quad[ i + 1 ], quad[ i + 2 ], quad[ i + 3 ] ];
+				index.push( a, b, d, a, d, c );
+
+			}
+
+			geo.setAttribute( 'position', new Float32BufferAttribute( Float32Array.from( P ), 3 ) );
+			geo.setAttribute( 'uv', new Float32BufferAttribute( Float32Array.from( uv ), 2 ) );
+			if ( N ) geo.setAttribute( 'normal', new Float32BufferAttribute( Float32Array.from( N ), 3 ) );
+			geo.setIndex( new Uint32BufferAttribute( new Uint32Array( index ), 1 ) );
+
+		} else {
+
+			const patches = Math.floor( quad.length / 4 );
+			const position = new Float32Array( patches * 12 ), normal = N ? new Float32Array( patches * 12 ) : null;
+			const corners = new Float32Array( patches * 8 ), index = new Uint32Array( patches * 6 );
+			for ( let i = 0; i < patches; i ++ ) {
+
+				for ( let k = 0; k < 4; k ++ ) {
+
+					const v = quad[ i * 4 + k ];
+					for ( let c = 0; c < 3; c ++ ) {
 
-			const [ a, b, c, d ] = [ quad[ i ], quad[ i + 1 ], quad[ i + 2 ], quad[ i + 3 ] ];
-			tris.push( a, b, c, a, c, d );
+						position[ i * 12 + k * 3 + c ] = P[ v * 3 + c ];
+						if ( normal ) normal[ i * 12 + k * 3 + c ] = N[ v * 3 + c ];
+
+					}
+
+					corners[ i * 8 + k * 2 ] = k & 1;
+					corners[ i * 8 + k * 2 + 1 ] = k >> 1;
+
+				}
+
+				index.set( [ 0, 1, 3, 0, 3, 2 ].map( ( k ) => i * 4 + k ), i * 6 );
+
+			}
+
+			geo.setAttribute( 'position', new Float32BufferAttribute( position, 3 ) );
+			geo.setAttribute( 'uv', new Float32BufferAttribute( corners, 2 ) );
+			if ( normal ) geo.setAttribute( 'normal', new Float32BufferAttribute( normal, 3 ) );
+			geo.setIndex( new Uint32BufferAttribute( index, 1 ) );
 
 		}
 
-		const geo = new BufferGeometry();
-		geo.setAttribute( 'position', new Float32BufferAttribute( Float32Array.from( P ), 3 ) );
-		geo.setIndex( tris );
-		geo.computeVertexNormals();
+		if ( N ) geo.userData.pbrtNormals = true;
+		else geo.computeVertexNormals();
 		return geo;
 
 	}
@@ -1100,7 +1575,8 @@ export class PBRTSceneBuilder {
 
 			}
 
-			if ( ! geo.getAttribute( 'normal' ) ) geo.computeVertexNormals();
+			if ( geo.getAttribute( 'normal' ) ) geo.userData.pbrtNormals = true;
+			else geo.computeVertexNormals();
 			return geo;
 
 		} catch ( e ) {
@@ -1114,38 +1590,41 @@ export class PBRTSceneBuilder {
 
 	_sphere( params ) {
 
-		const radius = pFloat( params, 'radius', 1 );
-		return new SphereGeometry( radius, 48, 32 );
+		const { radius, zMin, zMax, phiMax } = sphereParams( params );
+		const thetaMin = Math.acos( zMin / radius ), thetaMax = Math.acos( zMax / radius );
+		return quadric( phiMax, Math.max( 1, Math.ceil( 32 * ( thetaMin - thetaMax ) / Math.PI ) ), ( u, v, p, n ) => {
+
+			const phi = u * phiMax, theta = thetaMin + v * ( thetaMax - thetaMin );
+			n.set( Math.sin( theta ) * Math.cos( phi ), Math.sin( theta ) * Math.sin( phi ), Math.cos( theta ) );
+			p.copy( n ).multiplyScalar( radius );
+
+		} );
+
+	}
+
+	_cylinder( params ) {
+
+		const { radius, zMin, zMax, phiMax } = cylinderParams( params );
+		return quadric( phiMax, 1, ( u, v, p, n ) => {
+
+			const phi = u * phiMax;
+			n.set( Math.cos( phi ), Math.sin( phi ), 0 );
+			p.set( radius * n.x, radius * n.y, zMin + v * ( zMax - zMin ) );
+
+		} );
 
 	}
 
 	_disk( params ) {
 
-		// Approximate as a thin ring/disk in the z=height plane.
-		const radius = pFloat( params, 'radius', 1 );
-		const inner = pFloat( params, 'innerradius', 0 );
-		const h = pFloat( params, 'height', 0 );
-		const seg = 48;
-		const pos = [];
-		const idx = [];
-		for ( let i = 0; i < seg; i ++ ) {
-
-			const a0 = ( i / seg ) * Math.PI * 2;
-			const a1 = ( ( i + 1 ) / seg ) * Math.PI * 2;
-			const base = pos.length / 3;
-			pos.push( Math.cos( a0 ) * inner, Math.sin( a0 ) * inner, h );
-			pos.push( Math.cos( a0 ) * radius, Math.sin( a0 ) * radius, h );
-			pos.push( Math.cos( a1 ) * radius, Math.sin( a1 ) * radius, h );
-			pos.push( Math.cos( a1 ) * inner, Math.sin( a1 ) * inner, h );
-			idx.push( base, base + 1, base + 2, base, base + 2, base + 3 );
+		const { radius, inner, height, phiMax } = diskParams( params );
+		return quadric( phiMax, 1, ( u, v, p, n ) => {
 
-		}
+			const phi = u * phiMax, r = radius - v * ( radius - inner );
+			p.set( r * Math.cos( phi ), r * Math.sin( phi ), height );
+			n.set( 0, 0, 1 );
 
-		const geo = new BufferGeometry();
-		geo.setAttribute( 'position', new Float32BufferAttribute( Float32Array.from( pos ), 3 ) );
-		geo.setIndex( idx );
-		geo.computeVertexNormals();
-		return geo;
+		} );
 
 	}
 
@@ -1153,6 +1632,80 @@ export class PBRTSceneBuilder {
 
 	async _getMaterial( shape ) {
 
+		let material = await this._surfaceMaterial( shape );
+		if ( shape.interior ) material = await this._inMedium( material, shape.interior );
+		return shape.params.alpha ? this._withAlpha( material, shape.params.alpha ) : material;
+
+	}
+
+	/** The material under a shape's `alpha`, one per material and alpha. @private */
+	_withAlpha( material, alpha ) {
+
+		const key = alpha.type === 'texture' ? alpha.value[ 0 ] : `#${alpha.value[ 0 ]}`;
+		let byAlpha = this._alphaMaterials.get( material );
+		if ( ! byAlpha ) this._alphaMaterials.set( material, byAlpha = new Map() );
+		if ( ! byAlpha.has( key ) ) byAlpha.set( key, this._createAlphaMaterial( material, alpha ) );
+		return byAlpha.get( key );
+
+	}
+
+	async _createAlphaMaterial( material, alpha ) {
+
+		if ( alpha.type !== 'texture' ) return alpha.value[ 0 ] < 1 ? translucent( material, alpha.value[ 0 ] ) : material;
+
+		const name = alpha.value[ 0 ];
+		const map = await this._alphaMap( material.map, name );
+		if ( ! map ) {
+
+			this.warn( `shape alpha "${name}" could not be read here — drawn opaque` );
+			return material;
+
+		}
+
+		if ( map.constant !== undefined ) return map.constant < 1 ? translucent( material, map.constant ) : material;
+		const out = cloneMaterial( material );
+		out.map = map;
+		out.transparent = true;
+		return out;
+
+	}
+
+	/**
+	 * The colour map with the float texture `name` in its alpha channel, `{ constant }` when that texture is one value,
+	 * or null when it cannot be read here.
+	 * @private
+	 */
+	async _alphaMap( colorMap, name ) {
+
+		const def = this.ir.namedTextures.get( name );
+		const filename = def?.class === 'imagemap' ? pString( def.params, 'filename', null ) : null;
+		// Most often the alpha is the colour map's own image: its colour stays as it is.
+		if ( filename && colorMap?.userData.pbrtImage === filename && pString( def.params, 'mapping', 'uv' ) === 'uv'
+			&& pFloat( def.params, 'scale', 1 ) === 1 && ! pBool( def.params, 'invert', false ) && sameMapping( colorMap, uvMapping( def.params ) ) ) {
+
+			const pixels = texturePixels( colorMap );
+			const own = pixels && withDecodedAlpha( pixels, decoderFor( def.params ) );
+			if ( own ) {
+
+				setMapping( own, uvMapping( def.params ) );
+				return own;
+
+			}
+
+		}
+
+		const alpha = await this._bakeTerm( name, 1 );
+		if ( ! alpha ) return null;
+		if ( ! alpha.layer ) return { constant: alpha.rgb[ 0 ] };
+		const color = colorMap ? this._textureLayer( colorMap, 3 ) : null;
+		if ( colorMap && ! color ) return null;
+		const baked = bake( [ color ? { layer: color } : { rgb: [ 1, 1, 1 ] }, alpha ], ( [ c ] ) => c, { alphaOf: ( [ , a ] ) => a[ 0 ] } );
+		return baked && bakedTexture( baked );
+
+	}
+
+	async _surfaceMaterial( shape ) {
+
 		// Cache by (material, areaLight) object identity — many shapes share a
 		// NamedMaterial, so this dedupes the build + texture-decode work. Nested
 		// Map keys on the object refs directly (null is a valid key).
@@ -1166,11 +1719,7 @@ export class PBRTSceneBuilder {
 
 		if ( byLight.has( shape.areaLight ) ) return byLight.get( shape.areaLight );
 
-		const ctx = {
-			resolveNamedTexture: ( n ) => this._resolveNamedTexture( n ),
-			namedMaterials: this.ir.namedMaterials,
-			warn: ( m ) => this.warn( m )
-		};
+		const ctx = this._materialContext();
 		const material = await buildMaterial( shape.material, ctx );
 
 		if ( shape.areaLight ) await this._applyAreaLight( material, shape.areaLight, ctx );
@@ -1181,6 +1730,86 @@ export class PBRTSceneBuilder {
 
 	}
 
+	_materialContext() {
+
+		return this._ctx ??= {
+			resolveNamedTexture: ( n ) => this._resolveNamedTexture( n ),
+			namedMaterials: this.ir.namedMaterials,
+			warn: ( m ) => this.warn( m ),
+			floatTextureMean: async ( n ) => {
+
+				const term = await this._bakeTerm( n, 1 );
+				return term ? ( term.layer ? layerMean( term.layer ) : term.rgb[ 0 ] ) : null;
+
+			},
+			bakeMaterialMix: ( a, b, amountName ) => this._bakeMaterialMix( a, b, amountName ),
+			bakeFloatMap: ( params, keys, combine ) => this._floatMap( params, keys, combine ),
+			textureMeanRGB: async ( n ) => {
+
+				const term = await this._bakeTerm( n, 3 );
+				if ( ! term?.layer ) return term?.rgb ?? null;
+				const { data } = term.layer;
+				const sum = [ 0, 0, 0 ];
+				for ( let i = 0; i < data.length; i ++ ) sum[ i % 3 ] += data[ i ];
+				return sum.map( ( v, c ) => v / ( data.length / 3 ) * ( term.tint?.[ c ] ?? 1 ) );
+
+			},
+			resolveNormalMap: async ( filename ) => {
+
+				const image = await this._image( filename );
+				if ( ! image ) return null;
+				const texture = eightBit( image, { srgb: false } );
+				const normalMap = texture === image ? image.clone() : texture;
+				normalMap.colorSpace = NoColorSpace;
+				return normalMap;
+
+			}
+		};
+
+	}
+
+	/**
+	 * Glass filled with a homogeneous medium: what passes straight through it (σt = σa + σs) becomes Beer–Lambert
+	 * attenuation, since the engine traces no scattering inside a solid. A medium in an opaque shape changes nothing.
+	 * @private
+	 */
+	async _inMedium( material, name ) {
+
+		if ( ! ( material.transmission > 0 ) ) return material;
+		let byName = this._mediumMaterials.get( material );
+		if ( ! byName ) this._mediumMaterials.set( material, byName = new Map() );
+		if ( ! byName.has( name ) ) byName.set( name, this._attenuated( material, name ) );
+		return byName.get( name );
+
+	}
+
+	async _attenuated( material, name ) {
+
+		const params = this.ir.media?.get( name );
+		const type = params && pString( params, 'type', '' );
+		if ( type !== 'homogeneous' ) {
+
+			this.warn( params ? `medium "${name}" (${type}) is not supported — "${name}" glass left clear` : `medium "${name}" not defined` );
+			return material;
+
+		}
+
+		if ( params.preset ) this.warn( `medium preset "${pString( params, 'preset', '' )}" is not supported — using sigma_a / sigma_s` );
+		const ctx = this._materialContext();
+		const a = ( await resolveSpectrum( params, 'sigma_a', ctx, [ 1, 1, 1 ] ) ).rgb;
+		const s = ( await resolveSpectrum( params, 'sigma_s', ctx, [ 1, 1, 1 ] ) ).rgb;
+		const scale = pFloat( params, 'scale', 1 );
+		const sigma = [ 0, 1, 2 ].map( ( c ) => ( a[ c ] + s[ c ] ) * scale );
+		const max = Math.max( ...sigma );
+		if ( ! ( max > 0 ) ) return material;
+
+		const variant = cloneMaterial( material );
+		variant.attenuationDistance = 1 / max;
+		variant.attenuationColor.setRGB( ...sigma.map( ( v ) => Math.exp( - v / max ) ) );
+		return this._dedupeMaterial( variant );
+
+	}
+
 	/**
 	 * Collapse materials that render identically onto one instance — an inline `Material` per
 	 * shape is a distinct object every time, so every batch would hold exactly one shape.
@@ -1190,9 +1819,12 @@ export class PBRTSceneBuilder {
 
 		const c = material.color, e = material.emissive;
 		const key = `${c.r},${c.g},${c.b}|${e.r},${e.g},${e.b}|${material.emissiveIntensity}|` +
-			`${material.map ? material.map.uuid : '-'}|${material.roughness}|${material.metalness}|` +
+			`${material.map ? material.map.uuid : '-'}|${material.roughness}|${material.roughnessMap?.uuid ?? '-'}|${material.metalness}|` +
 			`${material.transmission}|${material.ior}|${material.thickness}|` +
-			`${material.clearcoat}|${material.clearcoatRoughness}|${material.opacity}|${material.side}`;
+			`${material.clearcoat}|${material.clearcoatRoughness}|${material.clearcoatRoughnessMap?.uuid ?? '-'}|${material.opacity}|${material.side}|` +
+			`${material.normalMap ? material.normalMap.uuid : '-'}|${material.attenuationDistance}|${material.attenuationColor.toArray()}|` +
+			`${material.specularIntensity}|${material.diffuseTransmission ?? 0}|${material.diffuseTransmissionColor?.toArray() ?? '-'}|` +
+			`${material.subsurface ?? 0}|${material.subsurfaceColor?.toArray() ?? '-'}|${material.subsurfaceRadius ?? '-'}|${material.subsurfaceAnisotropy ?? 0}`;
 
 		const existing = this._materialBySignature.get( key );
 		if ( existing ) return existing;
@@ -1201,13 +1833,31 @@ export class PBRTSceneBuilder {
 
 	}
 
+	/**
+	 * An area light given as `power`: pbrt scales its radiance to that power over this shape's area (both sides of a
+	 * twosided one); an image's mean is not in it, as an emitting image is not supported.
+	 * @private
+	 */
+	_poweredMaterial( shape, geometry, material ) {
+
+		const power = pFloat( shape.areaLight.params, 'power', - 1 );
+		if ( ! ( power > 0 ) ) return material;
+		const area = shapeArea( shape, geometry ) * ( pBool( shape.areaLight.params, 'twosided', false ) ? 2 : 1 );
+		if ( ! ( area > 0 ) ) return material;
+		const out = cloneMaterial( material );
+		out.emissiveIntensity = material.emissiveIntensity * power / ( Math.PI * area );
+		return out;
+
+	}
+
 	async _applyAreaLight( material, areaLight, ctx ) {
 
-		const L = await resolveSpectrum( areaLight.params, 'L', ctx, [ 1, 1, 1 ] );
+		const rgb = await lightRGB( areaLight.params, 'L', ctx );
 		const scale = pFloat( areaLight.params, 'scale', 1 );
-		const rgb = L.rgb || [ 1, 1, 1 ];
 		material.emissive.setRGB( rgb[ 0 ], rgb[ 1 ], rgb[ 2 ] );
 		material.emissiveIntensity = scale;
+		// pbrt's diffuse area light is one-sided unless "twosided" (_facingEmission turns the triangles).
+		material.side = pBool( areaLight.params, 'twosided', false ) ? DoubleSide : FrontSide;
 
 	}
 
@@ -1224,22 +1874,11 @@ export class PBRTSceneBuilder {
 
 		} else if ( def.class === 'imagemap' ) {
 
-			const filename = pString( def.params, 'filename', null );
-			if ( filename ) {
-
-				try {
-
-					const tex = await this.resolveImage( filename );
-					if ( tex ) result = { texture: tex };
-					else this.warn( `image not found for texture "${name}": ${filename}` );
-
-				} catch ( e ) {
+			result = await this._imageMapTexture( name, def );
 
-					this.warn( `failed to load texture "${name}" (${filename}): ${e.message}` );
+		} else if ( def.class === 'mix' ) {
 
-				}
-
-			}
+			result = await this._mixTexture( name, def );
 
 		} else if ( def.class === 'constant' ) {
 
@@ -1247,6 +1886,10 @@ export class PBRTSceneBuilder {
 			if ( v && v.type === 'rgb' ) result = { constant: [ v.value[ 0 ], v.value[ 1 ], v.value[ 2 ] ] };
 			else if ( v ) result = { constant: [ v.value[ 0 ], v.value[ 0 ], v.value[ 0 ] ] };
 
+		} else if ( def.class === 'checkerboard' || def.class === 'bilerp' ) {
+
+			result = await this._proceduralTexture( name, def );
+
 		} else if ( def.class === 'scale' ) {
 
 			// Scale = inner_texture * scale_factor. Resolve the inner (recursively if
@@ -1276,6 +1919,242 @@ export class PBRTSceneBuilder {
 
 	}
 
+	/**
+	 * pbrt's 2D `checkerboard` and `bilerp`, baked: one period of the checks (two each way), or the bilerp over the unit
+	 * square, in the texture's uv mapping. A textured input counts as its mean.
+	 * @private
+	 */
+	async _proceduralTexture( name, def ) {
+
+		const params = def.params;
+		const ctx = this._materialContext();
+		const value = async ( key, 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;
+
+		};
+
+		const mapping = pString( params, 'mapping', 'uv' );
+		if ( mapping !== 'uv' ) this.warn( `texture "${name}": "${mapping}" mapping is not supported — using the mesh's uv` );
+		const { su, sv, du, dv } = uvMapping( params );
+
+		if ( def.class === 'checkerboard' ) {
+
+			if ( pFloat( params, 'dimension', 2 ) !== 2 ) {
+
+				this.warn( `texture "${name}": a 3D checkerboard is not supported` );
+				return null;
+
+			}
+
+			const [ a, b ] = await Promise.all( [ value( 'tex1', [ 1, 1, 1 ] ), value( 'tex2', [ 0, 0, 0 ] ) ] );
+			const n = 2 * CHECK_TEXELS;
+			const data = rasterize( n, n, ( s, t ) => ( ( Math.floor( 2 * s ) + Math.floor( 2 * t ) ) % 2 ? b : a ) );
+			return { texture: bakedTexture( { data, width: n, height: n, mapping: { su: su / 2, sv: sv / 2, du: du / 2, dv: dv / 2 } } ) };
+
+		}
+
+		const [ v00, v01, v10, v11 ] = await Promise.all( [
+			value( 'v00', [ 0, 0, 0 ] ), value( 'v01', [ 1, 1, 1 ] ), value( 'v10', [ 0, 0, 0 ] ), value( 'v11', [ 1, 1, 1 ] )
+		] );
+		const data = rasterize( BILERP_TEXELS, BILERP_TEXELS, ( s, t ) => [ 0, 1, 2 ].map( ( c ) =>
+			( 1 - s ) * ( 1 - t ) * v00[ c ] + s * ( 1 - t ) * v10[ c ] + ( 1 - s ) * t * v01[ c ] + s * t * v11[ c ] ) );
+		return { texture: bakedTexture( { data, width: BILERP_TEXELS, height: BILERP_TEXELS, mapping: { su, sv, du, dv } } ) };
+
+	}
+
+	/** A file's image, decoded once however many named textures read it. @private */
+	_image( filename ) {
+
+		let pending = this._imageCache.get( filename );
+		if ( ! pending ) {
+
+			pending = Promise.resolve().then( () => this.resolveImage( filename ) ).catch( ( e ) => {
+
+				this.warn( `failed to load image ${filename}: ${e.message}` );
+				return null;
+
+			} );
+			this._imageCache.set( filename, pending );
+
+		}
+
+		return pending;
+
+	}
+
+	/**
+	 * An image texture with pbrt's uv mapping; its `scale` becomes the material's tint, except that a scale above 1 or
+	 * `invert` is baked (pbrt clamps an albedo per texel, which a tint cannot).
+	 * @private
+	 */
+	async _imageMapTexture( name, def ) {
+
+		const filename = pString( def.params, 'filename', null );
+		if ( ! filename ) return null;
+		const image = await this._image( filename );
+		if ( ! image ) {
+
+			this.warn( `image not found for texture "${name}": ${filename}` );
+			return null;
+
+		}
+
+		const mapping = pString( def.params, 'mapping', 'uv' );
+		if ( mapping !== 'uv' ) this.warn( `texture "${name}": "${mapping}" mapping is not supported — using the mesh's uv` );
+
+		const scale = pFloat( def.params, 'scale', 1 );
+		if ( scale > 1 || pBool( def.params, 'invert', false ) ) {
+
+			const term = await this._bakeTerm( name, 3 );
+			const baked = term?.layer && bake( [ { ...term, clamp: true } ], ( [ v ] ) => v );
+			if ( baked ) return { texture: bakedTexture( baked ) };
+			this.warn( `texture "${name}": its scale or invert could not be baked here — ignored` );
+
+		}
+
+		const color = eightBit( image, { srgb: true } );
+		const texture = color === image ? image.clone() : color;
+		texture.userData.pbrtImage = filename;
+		setMapping( texture, uvMapping( def.params ) );
+		texture.needsUpdate = true;
+		return scale < 1 ? { texture, constant: [ scale, scale, scale ] } : { texture };
+
+	}
+
+	/**
+	 * A data map (linear, in every channel) of `combine` over float parameters `keys`, constants or textures; null when
+	 * one cannot be read here or all are constants.
+	 * @private
+	 */
+	async _floatMap( params, keys, combine ) {
+
+		const terms = await Promise.all( keys.map( ( key ) => this._paramTerm( params, key, 1, [ 0, 0, 0 ] ) ) );
+		if ( terms.some( ( term ) => ! term ) ) return null;
+		const baked = bake( terms, ( values ) => {
+
+			const v = combine( values.map( ( value ) => value[ 0 ] ) );
+			return [ v, v, v ];
+
+		}, { linear: true } );
+		return baked && bakedTexture( baked, { srgb: false } );
+
+	}
+
+	/** pbrt's `mix` texture, ( 1 − amount ) · tex1 + amount · tex2, baked when any of the three is an image. @private */
+	async _mixTexture( name, def ) {
+
+		const [ a, b, amount ] = await Promise.all( [
+			this._paramTerm( def.params, 'tex1', 3, [ 0, 0, 0 ] ),
+			this._paramTerm( def.params, 'tex2', 3, [ 1, 1, 1 ] ),
+			this._paramTerm( def.params, 'amount', 1, [ 0.5, 0.5, 0.5 ] )
+		] );
+		if ( ! a || ! b || ! amount ) {
+
+			this.warn( `texture "${name}": a "mix" input could not be read here` );
+			return null;
+
+		}
+
+		const unit = ( rgb ) => rgb.map( ( v ) => Math.min( 1, Math.max( 0, v ) ) );
+		const baked = bake( [ { ...a, clamp: true }, { ...b, clamp: true }, amount ], mixOf );
+		return baked ? { texture: bakedTexture( baked ) } : { constant: mixOf( [ unit( a.rgb ), unit( b.rgb ), amount.rgb ] ) };
+
+	}
+
+	/** A texture parameter as a bake term: a constant, or the texture it names. @private */
+	async _paramTerm( params, key, channels, dflt ) {
+
+		const p = params[ key ];
+		if ( ! p ) return { rgb: dflt };
+		if ( p.type === 'texture' ) return this._bakeTerm( p.value[ 0 ], channels );
+		const rgb = ( await resolveSpectrum( params, key, this._materialContext(), dflt ) ).rgb;
+		return rgb ? { rgb } : null;
+
+	}
+
+	/**
+	 * A named texture as pbrt evaluates it, for baking: `{ rgb }` for a constant, `{ layer, tint? }` for an image;
+	 * null when it cannot be read in this runtime.
+	 * @param {string} name
+	 * @param {number} channels - 1 where it is read as a float texture, 3 as a spectrum
+	 * @private
+	 */
+	_bakeTerm( name, channels ) {
+
+		const key = `${name}\0${channels}`;
+		let pending = this._termCache.get( key );
+		if ( ! pending ) this._termCache.set( key, pending = this._createBakeTerm( name, channels ) );
+		return pending;
+
+	}
+
+	async _createBakeTerm( name, channels ) {
+
+		const def = this.ir.namedTextures.get( name );
+		if ( def?.class === 'imagemap' ) {
+
+			if ( pString( def.params, 'mapping', 'uv' ) !== 'uv' ) return null;
+			const filename = pString( def.params, 'filename', null );
+			const pixels = texturePixels( filename && await this._image( filename ) );
+			if ( ! pixels ) return null;
+			return { layer: makeLayer( pixels, {
+				channels, decode: pixels.float ? null : decoderFor( def.params ),
+				scale: pFloat( def.params, 'scale', 1 ), invert: pBool( def.params, 'invert', false ), mapping: uvMapping( def.params )
+			} ) };
+
+		}
+
+		const resolved = await this._resolveNamedTexture( name );
+		if ( ! resolved ) return null;
+		if ( ! resolved.texture ) return resolved.constant ? { rgb: resolved.constant } : null;
+		const layer = this._textureLayer( resolved.texture, channels );
+		return layer ? { layer, tint: resolved.constant ?? null } : null;
+
+	}
+
+	// A texture already built for a material (an image or a bake) as a layer, in the mapping it carries.
+	_textureLayer( texture, channels ) {
+
+		const pixels = texturePixels( texture );
+		if ( ! pixels ) return null;
+		const srgb = ! pixels.float && texture.colorSpace === SRGBColorSpace;
+		return makeLayer( pixels, {
+			channels, decode: pixels.float ? null : ( srgb ? srgbToLinear : ( v ) => v ),
+			mapping: { su: texture.repeat.x, sv: texture.repeat.y, du: texture.offset.x, dv: texture.offset.y }
+		} );
+
+	}
+
+	/**
+	 * A mix material whose amount is a texture: its two materials' colours (map × colour) baked by that texture, and
+	 * the texture's mean to weigh everything else. Null when nothing here can read it.
+	 * @private
+	 */
+	async _bakeMaterialMix( matA, matB, amountName ) {
+
+		const amount = await this._bakeTerm( amountName, 1 );
+		if ( ! amount ) return null;
+		if ( ! amount.layer ) return { mean: amount.rgb[ 0 ], texture: null };
+
+		const mean = layerMean( amount.layer );
+		const term = ( m ) => {
+
+			if ( ! m.map ) return { rgb: m.color.toArray(), clamp: true };
+			const layer = this._textureLayer( m.map, 3 );
+			return layer && { layer, tint: m.color.toArray(), clamp: true };
+
+		};
+
+		const a = term( matA ), b = term( matB );
+		if ( ! a || ! b ) return { mean, texture: null };
+		const baked = bake( [ a, b, amount ], mixOf );
+		return { mean, texture: baked ? bakedTexture( baked ) : null };
+
+	}
+
 	_colorFromLikeNamedMaterial( texName ) {
 
 		for ( const candidate of materialNameCandidates( texName ) ) {
@@ -1297,6 +2176,25 @@ export class PBRTSceneBuilder {
 	async _resolveScaleTexture( name, def ) {
 
 		// pbrt-v4 uses "tex" (the inner texture or constant) and "scale" (the multiplier).
+		if ( def.params.scale?.type === 'texture' ) {
+
+			// A texture multiplier (kroken's bricks: colour × dirt) is baked.
+			const [ inner, factor ] = await Promise.all( [
+				this._paramTerm( def.params, 'tex', 3, [ 1, 1, 1 ] ),
+				this._paramTerm( def.params, 'scale', 1, [ 1, 1, 1 ] )
+			] );
+			const product = ( [ a, f ] ) => [ a[ 0 ] * f[ 0 ], a[ 1 ] * f[ 0 ], a[ 2 ] * f[ 0 ] ];
+			if ( inner && factor ) {
+
+				const baked = bake( [ { ...inner, clamp: true }, factor ], product );
+				return baked ? { texture: bakedTexture( baked ) } : { constant: product( [ inner.rgb, factor.rgb ] ) };
+
+			}
+
+			this.warn( `texture "${name}": its "scale" texture could not be read here — ignored` );
+
+		}
+
 		const innerP = def.params.tex;
 		let inner = null;
 
@@ -1362,6 +2260,8 @@ export class PBRTSceneBuilder {
 		camera.name = 'PBRT Camera';
 		this._poseCamera( camera, cam.cameraToWorld );
 		camera.updateMatrixWorld( true );
+		const lensRadius = pFloat( cam.params, 'lensradius', 0 );
+		if ( lensRadius > 0 ) camera.userData.__rayzeeEffects = lensEffects( camera, lensRadius, pFloat( cam.params, 'focaldistance', 1e6 ) );
 		return camera;
 
 	}
@@ -1500,8 +2400,7 @@ export class PBRTSceneBuilder {
 
 		// Constant-radiance infinite light → tiny float texture (CDF-buildable).
 		const ctx = { resolveNamedTexture: async () => null, warn: ( m ) => this.warn( m ) };
-		const L = await resolveSpectrum( inf.params, 'L', ctx, [ 1, 1, 1 ] );
-		const rgb = ( L.rgb || [ 1, 1, 1 ] ).map( v => v * scale );
+		const rgb = ( await lightRGB( inf.params, 'L', ctx ) ).map( v => v * scale );
 
 		const w = 2, h = 1;
 		const data = new Float32Array( w * h * 4 );
@@ -1523,13 +2422,89 @@ export class PBRTSceneBuilder {
 
 	}
 
+	/**
+	 * `distant`, `point` and `spot` lights as three.js lamps, in the engine's units: a directional lamp's
+	 * intensity is the irradiance it gives (pbrt's L), a point or spot lamp's is 4π × its radiant intensity.
+	 */
+	async _buildLamps( lights, group ) {
+
+		const ctx = { resolveNamedTexture: async () => null, warn: ( m ) => this.warn( m ) };
+		for ( const l of lights ) {
+
+			if ( ! LAMP_TYPES.has( l.type ) ) continue;
+
+			const world = new Matrix4().fromArray( this.convertHandedness ? M.multiply( FLIP_Z, l.ctm ) : l.ctm );
+			const point = ( name, dflt ) => {
+
+				const v = l.params[ name ]?.value;
+				return new Vector3().fromArray( v?.length >= 3 ? v : dflt ).applyMatrix4( world );
+
+			};
+
+			const rgb = await lightRGB( l.params, l.type === 'distant' ? 'L' : 'I', ctx );
+			let scale = pFloat( l.params, 'scale', 1 );
+			const from = point( 'from', [ 0, 0, 0 ] );
+			const to = point( 'to', [ 0, 0, 1 ] );
+			let light;
+			if ( l.type === 'distant' ) {
+
+				const illuminance = pFloat( l.params, 'illuminance', - 1 );
+				if ( illuminance > 0 ) scale *= illuminance;
+				light = new DirectionalLight();
+				light.userData.__luxConverted = true;
+
+			} else if ( l.type === 'point' ) {
+
+				// `power` sets the radiant intensity to power / 4π.
+				const power = pFloat( l.params, 'power', - 1 );
+				scale *= power > 0 ? power : 4 * Math.PI;
+				light = new PointLight();
+				light.userData.__candelaConverted = true;
+
+			} else {
+
+				// pbrt's falloff is smoothstep( cos cone, cos( cone − delta ), cos θ ); the engine's blend is that width over 1 − cos cone.
+				const cone = Math.min( Math.max( pFloat( l.params, 'coneangle', 30 ), 0 ), 90 ) * Math.PI / 180;
+				const delta = Math.min( Math.max( pFloat( l.params, 'conedeltaangle', 5 ) * Math.PI / 180, 0 ), cone );
+				const cosEnd = Math.cos( cone ), cosStart = Math.cos( cone - delta );
+				const power = pFloat( l.params, 'power', - 1 );
+				if ( power > 0 ) scale *= power / ( 2 * Math.PI * ( ( 1 - cosStart ) + ( cosStart - cosEnd ) / 2 ) );
+				scale *= 4 * Math.PI;
+				light = new SpotLight();
+				light.angle = cone;
+				light.penumbra = cosEnd < 1 ? Math.min( ( cosStart - cosEnd ) / ( 1 - cosEnd ), 1 ) : 0;
+				light.userData.__candelaConverted = true;
+
+			}
+
+			const peak = Math.max( rgb[ 0 ], rgb[ 1 ], rgb[ 2 ] );
+			if ( ! ( peak > 0 ) || ! ( scale > 0 ) ) continue;
+			light.color.setRGB( rgb[ 0 ] / peak, rgb[ 1 ] / peak, rgb[ 2 ] / peak );
+			light.intensity = peak * scale;
+			light.name = `pbrt ${l.type}`;
+			light.position.copy( from );
+			light.decay = 2;
+			light.distance = 0;
+			if ( light.target ) {
+
+				light.target.position.subVectors( to, from );
+				light.add( light.target );
+
+			}
+
+			group.add( light );
+
+		}
+
+	}
+
 	_reportUnsupportedLights( lights ) {
 
 		for ( const l of lights ) {
 
-			if ( l.type !== 'infinite' ) {
+			if ( l.type !== 'infinite' && ! LAMP_TYPES.has( l.type ) ) {
 
-				this.warn( `light "${l.type}" not supported (only infinite lights and emissive area lights are mapped)` );
+				this.warn( `light "${l.type}" not supported (only infinite, distant, point and spot lights and emissive area lights are mapped)` );
 
 			}