rayzee 6.3.0 → 6.4.0

package/package.json

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

package/src/Processor/AssetLoader.js

@@ -1,5 +1,6 @@
 import { Box3, Vector3, RectAreaLight, Color, FloatType, LinearFilter, EquirectangularReflectionMapping,
-	TextureLoader, Mesh, MeshStandardMaterial, MeshPhysicalMaterial, CircleGeometry, Points, PointsMaterial, LoadingManager, EventDispatcher
+	TextureLoader, Texture, SRGBColorSpace, RepeatWrapping, Mesh, MeshStandardMaterial, MeshPhysicalMaterial,
+	CircleGeometry, Points, PointsMaterial, LoadingManager, EventDispatcher
 } from 'three';
 import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
 import { HDRLoader } from 'three/addons/loaders/HDRLoader.js';
@@ -12,6 +13,7 @@ import { unzipSync, strFromU8 } from 'three/addons/libs/fflate.module.js';
 import { disposeObjectFromMemory, updateLoading } from './utils';
 import { BuildTimer } from './BuildTimer.js';
 import { getAssetConfig } from '../AssetConfig.js';
+import { loadPBRTScene, pickEntryPath } from './PBRT/index.js';
 
 // Define supported file formats
 const SUPPORTED_FORMATS = {
@@ -314,6 +316,10 @@ export class AssetLoader extends EventDispatcher {
 
 			const arrayBuffer = await this.readFileAsArrayBuffer( file );
 			const zip = unzipSync( new Uint8Array( arrayBuffer ) );
+
+			// A pbrt scene archive takes priority — it owns its own geometry/texture refs.
+			if ( pickEntryPath( zip ) ) return await this.loadPBRTFromZip( zip, filename );
+
 			const result = await this.processObjMtlPairsInZip( zip, filename );
 			if ( result ) return result;
 			return await this.findAndLoadModelFromZip( zip, filename );
@@ -327,6 +333,150 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
+	/**
+	 * Loads a pbrt-v4 scene from an unzipped archive. Parses the entry .pbrt
+	 * (following Include/Import), builds a THREE.Group, sets the infinite light
+	 * as the scene environment, and runs the standard onModelLoad pipeline.
+	 * @param {Object<string, Uint8Array>} zip - unzipped entries (path → bytes)
+	 * @param {string} filename - original archive name (for display/events)
+	 */
+	async loadPBRTFromZip( zip, filename ) {
+
+		updateLoading( { isLoading: true, status: 'Parsing PBRT scene...', progress: 5 } );
+
+		// Geometry decoder — reuse the cached PLYLoader (pbrt leans on .ply meshes).
+		if ( ! this.loaderCache.ply ) {
+
+			const { PLYLoader } = await import( 'three/examples/jsm/loaders/PLYLoader.js' );
+			this.loaderCache.ply = new PLYLoader();
+
+		}
+
+		const plyParser = ( buf ) => this.loaderCache.ply.parse( buf );
+
+		// Texture maps — decode by extension (pbrt uses .png/.jpg but also .exr/.hdr/.tga).
+		const imageFromBytes = ( bytes, fname ) => this._pbrtTextureFromBytes( bytes, fname );
+
+		// Infinite-light maps → HDR/EXR/LDR via the shared environment decoder.
+		const envFromBytes = async ( bytes, fname ) => {
+
+			const ext = fname.split( '.' ).pop().toLowerCase();
+			const url = URL.createObjectURL( new Blob( [ bytes ] ) );
+			try {
+
+				return await this.loadEnvironmentByExtension( url, ext );
+
+			} finally {
+
+				URL.revokeObjectURL( url );
+
+			}
+
+		};
+
+		const { group, environment, report, warnings, entryPath } = await loadPBRTScene( {
+			vfs: zip, plyParser, imageFromBytes, envFromBytes
+		} );
+
+		// Diagnostics — surface what each mesh resolved to (helps debug black/wrong materials).
+		if ( report && report.length && typeof console.table === 'function' ) {
+
+			console.groupCollapsed( `PBRT loader: ${report.length} mesh(es) from "${entryPath}"` );
+			console.table( report );
+			console.groupEnd();
+
+		}
+
+		if ( warnings && warnings.length ) {
+
+			console.warn( `PBRT loader: ${warnings.length} warning(s) parsing "${entryPath}"` );
+			warnings.forEach( w => console.warn( '  •', w ) );
+
+		}
+
+		// Infinite light → scene environment (CDF is built later in loadSceneData).
+		if ( environment?.texture ) {
+
+			environment.texture.generateMipmaps = true;
+			this.applyEnvironmentToScene( environment.texture );
+
+		}
+
+		group.name = entryPath || filename;
+		this.releaseTargetModel();
+		this.targetModel = group;
+
+		updateLoading( { isLoading: true, status: 'Processing PBRT geometry...', progress: 10 } );
+		await this.onModelLoad( this.targetModel );
+
+		this.dispatchEvent( { type: 'load', model: group, filename: `${entryPath} (from ZIP)` } );
+		return group;
+
+	}
+
+	/**
+	 * Decodes a pbrt texture map from raw bytes, picking a decoder by extension.
+	 * ImageBitmap can't handle EXR/HDR/TGA, which pbrt scenes use freely.
+	 * @param {Uint8Array} bytes
+	 * @param {string} fname
+	 * @returns {Promise<import('three').Texture>}
+	 */
+	async _pbrtTextureFromBytes( bytes, fname ) {
+
+		const ext = fname.split( '.' ).pop().toLowerCase();
+		let tex;
+
+		if ( ext === 'exr' || ext === 'hdr' ) {
+
+			const loader = ext === 'hdr'
+				? ( this.loaderCache.hdr || ( this.loaderCache.hdr = new HDRLoader().setDataType( FloatType ) ) )
+				: ( this.loaderCache.exr || ( this.loaderCache.exr = new EXRLoader().setDataType( FloatType ) ) );
+			tex = await this._loadViaObjectURL( loader, bytes );
+			// HDR/EXR maps are linear — leave colorSpace as the loader set it.
+
+		} else if ( ext === 'tga' ) {
+
+			if ( ! this.loaderCache.tga ) {
+
+				const { TGALoader } = await import( 'three/examples/jsm/loaders/TGALoader.js' );
+				this.loaderCache.tga = new TGALoader();
+
+			}
+
+			tex = await this._loadViaObjectURL( this.loaderCache.tga, bytes );
+			tex.colorSpace = SRGBColorSpace;
+
+		} else {
+
+			// png / jpg / webp / gif / bmp
+			const bitmap = await createImageBitmap( new Blob( [ bytes ] ) );
+			tex = new Texture( bitmap );
+			tex.colorSpace = SRGBColorSpace;
+
+		}
+
+		tex.wrapS = tex.wrapT = RepeatWrapping;
+		tex.needsUpdate = true;
+		return tex;
+
+	}
+
+	/** Decode bytes through a three loader's loadAsync via a transient object URL. */
+	async _loadViaObjectURL( loader, bytes ) {
+
+		const url = URL.createObjectURL( new Blob( [ bytes ] ) );
+		try {
+
+			return await loader.loadAsync( url );
+
+		} finally {
+
+			URL.revokeObjectURL( url );
+
+		}
+
+	}
+
 	async processObjMtlPairsInZip( zip, filename ) {
 
 		const objFiles = [];

package/src/Processor/PBRT/PBRTMaterials.js

@@ -0,0 +1,350 @@
+/**
+ * Translate pbrt-v4 materials and textures to THREE.MeshPhysicalMaterial.
+ *
+ * pbrt's BxDF model (diffuse / conductor / dielectric / coateddiffuse / ...) is
+ * mapped onto the Disney-style parameters the engine reads off a
+ * MeshPhysicalMaterial (see GeometryExtractor.createMaterialObject). The mapping
+ * is intentionally lossy — spectral data, measured BRDFs, and layered BxDFs are
+ * approximated to RGB. Anything unrecognized falls back to a neutral diffuse.
+ */
+
+import { MeshPhysicalMaterial, Color, DoubleSide } from 'three';
+
+// Normal-incidence reflectance approximations for pbrt's named conductor spectra.
+const METAL_ALBEDO = {
+	au: [ 1.0, 0.78, 0.34 ], gold: [ 1.0, 0.78, 0.34 ],
+	cu: [ 0.95, 0.64, 0.54 ], copper: [ 0.95, 0.64, 0.54 ],
+	ag: [ 0.97, 0.96, 0.91 ], silver: [ 0.97, 0.96, 0.91 ],
+	al: [ 0.91, 0.92, 0.92 ], aluminium: [ 0.91, 0.92, 0.92 ], aluminum: [ 0.91, 0.92, 0.92 ],
+	mgo: [ 0.9, 0.9, 0.9 ], tio2: [ 0.9, 0.9, 0.9 ]
+};
+
+const DEFAULT_METAL = [ 0.92, 0.92, 0.92 ];
+
+/** Crude blackbody-temperature → linear RGB (Planckian locus approximation). */
+function blackbodyToRGB( kelvin ) {
+
+	const t = Math.max( 1000, Math.min( 40000, kelvin ) ) / 100;
+	let r, g, b;
+
+	if ( t <= 66 ) {
+
+		r = 255;
+		g = 99.47 * Math.log( t ) - 161.12;
+
+	} else {
+
+		r = 329.7 * Math.pow( t - 60, - 0.1332 );
+		g = 288.12 * Math.pow( t - 60, - 0.0755 );
+
+	}
+
+	if ( t >= 66 ) b = 255;
+	else if ( t <= 19 ) b = 0;
+	else b = 138.52 * Math.log( t - 10 ) - 305.04;
+
+	const clamp = v => Math.max( 0, Math.min( 255, v ) ) / 255;
+	// sRGB → approx linear
+	return [ clamp( r ) ** 2.2, clamp( g ) ** 2.2, clamp( b ) ** 2.2 ];
+
+}
+
+// ── param accessors ────────────────────────────────────────────────
+
+export function pFloat( params, name, dflt ) {
+
+	const p = params[ name ];
+	return p && typeof p.value[ 0 ] === 'number' ? p.value[ 0 ] : dflt;
+
+}
+
+export function pString( params, name, dflt ) {
+
+	const p = params[ name ];
+	return p && typeof p.value[ 0 ] === 'string' ? p.value[ 0 ] : dflt;
+
+}
+
+/**
+ * Resolve a spectrum/color/float-valued parameter to an RGB triple and/or a
+ * texture. Returns `{ rgb, texture }` — exactly one is typically non-null.
+ * @returns {Promise<{rgb:number[]|null, texture:import('three').Texture|null}>}
+ */
+export async function resolveSpectrum( params, name, ctx, dfltRGB = null ) {
+
+	const p = params[ name ];
+	if ( ! p ) return { rgb: dfltRGB, texture: null };
+
+	// Reference to a named texture.
+	if ( p.type === 'texture' ) {
+
+		const texName = p.value[ 0 ];
+		const tex = await ctx.resolveNamedTexture( texName );
+		if ( tex && tex.texture ) return { rgb: tex.constant ?? null, texture: tex.texture };
+		if ( tex && tex.constant ) return { rgb: tex.constant, texture: null };
+		ctx.warn( `texture "${texName}" could not be resolved` );
+		return { rgb: dfltRGB, texture: null };
+
+	}
+
+	if ( p.type === 'rgb' || p.type === 'color' ) {
+
+		return { rgb: [ p.value[ 0 ], p.value[ 1 ], p.value[ 2 ] ], texture: null };
+
+	}
+
+	if ( p.type === 'float' ) {
+
+		const v = p.value[ 0 ];
+		return { rgb: [ v, v, v ], texture: null };
+
+	}
+
+	if ( p.type === 'blackbody' ) {
+
+		return { rgb: blackbodyToRGB( p.value[ 0 ] ), texture: null };
+
+	}
+
+	if ( p.type === 'spectrum' ) {
+
+		// Named spectrum (e.g. "metal-Au-eta") or sampled [lambda val ...].
+		if ( typeof p.value[ 0 ] === 'string' ) {
+
+			const key = namedMetalKey( p.value[ 0 ] );
+			if ( key && METAL_ALBEDO[ key ] ) return { rgb: METAL_ALBEDO[ key ].slice(), texture: null };
+			ctx.warn( `named spectrum "${p.value[ 0 ]}" approximated to gray` );
+			return { rgb: [ 0.5, 0.5, 0.5 ], texture: null };
+
+		}
+
+		// Sampled spectrum → average value as gray (coarse).
+		let sum = 0, count = 0;
+		for ( let i = 1; i < p.value.length; i += 2 ) {
+
+			sum += p.value[ i ]; count ++;
+
+		}
+
+		const v = count ? sum / count : 0.5;
+		return { rgb: [ v, v, v ], texture: null };
+
+	}
+
+	return { rgb: dfltRGB, texture: null };
+
+}
+
+function namedMetalKey( s ) {
+
+	const m = s.toLowerCase().match( /metal-([a-z]+)/ );
+	if ( m ) return m[ 1 ];
+	for ( const k of Object.keys( METAL_ALBEDO ) ) if ( s.toLowerCase().includes( k ) ) return k;
+	return null;
+
+}
+
+/** Roughness from `roughness` or anisotropic `uroughness`/`vroughness`. */
+function resolveRoughness( params, 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;
+
+}
+
+/**
+ * Build a MeshPhysicalMaterial from a pbrt material definition.
+ * @param {{type:string, params:object}} def
+ * @param {object} ctx - { resolveNamedTexture, warn }
+ * @returns {Promise<MeshPhysicalMaterial>}
+ */
+export async function buildMaterial( def, ctx ) {
+
+	const type = def?.type || 'diffuse';
+	const params = def?.params || {};
+	const mat = new MeshPhysicalMaterial( { side: DoubleSide, roughness: 1, metalness: 0 } );
+
+	const setColor = ( rgb ) => {
+
+		if ( rgb ) mat.color.setRGB( rgb[ 0 ], rgb[ 1 ], rgb[ 2 ] );
+
+	};
+
+	// Apply a resolved reflectance to the base color + map. A `scale` texture
+	// yields BOTH an rgb tint and a texture — keep the tint as color so three
+	// multiplies map×color. A plain imagemap (no tint) neutralizes color to white.
+	const applyAlbedo = ( refl ) => {
+
+		setColor( refl.rgb );
+		if ( refl.texture ) {
+
+			mat.map = refl.texture;
+			if ( ! refl.rgb ) mat.color.setRGB( 1, 1, 1 );
+
+		}
+
+	};
+
+	switch ( type ) {
+
+		case 'diffuse': {
+
+			applyAlbedo( await resolveSpectrum( params, 'reflectance', ctx, [ 0.5, 0.5, 0.5 ] ) );
+			mat.roughness = 1;
+			mat.metalness = 0;
+			break;
+
+		}
+
+		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 {
+
+				setColor( METAL_ALBEDO.cu ); // pbrt-v4 default conductor is copper
+
+			}
+
+			mat.metalness = 1;
+			mat.roughness = resolveRoughness( params, 0.1 );
+			break;
+
+		}
+
+		case 'dielectric':
+		case 'thindielectric': {
+
+			mat.transmission = 1;
+			mat.metalness = 0;
+			mat.color.setRGB( 1, 1, 1 );
+			mat.ior = pFloat( params, 'eta', 1.5 );
+			mat.roughness = resolveRoughness( params, 0 );
+			mat.thickness = type === 'thindielectric' ? 0 : pFloat( params, 'thickness', 0 );
+			break;
+
+		}
+
+		case 'coateddiffuse': {
+
+			applyAlbedo( await resolveSpectrum( params, 'reflectance', ctx, [ 0.5, 0.5, 0.5 ] ) );
+			mat.roughness = 0.6;
+			mat.metalness = 0;
+			mat.clearcoat = 1;
+			mat.clearcoatRoughness = resolveRoughness( params, 0 );
+			break;
+
+		}
+
+		case 'diffusetransmission': {
+
+			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;
+			mat.roughness = 1;
+			mat.ior = 1.0;
+			break;
+
+		}
+
+		case 'interface':
+		case 'none':
+		case '': {
+
+			// Medium boundary with no surface scattering — render as clear passthrough.
+			mat.transmission = 1;
+			mat.ior = 1.0;
+			mat.roughness = 0;
+			mat.color.setRGB( 1, 1, 1 );
+			break;
+
+		}
+
+		case 'mix': {
+
+			// pbrt blends two named materials by `amount`. Without a real layered BxDF
+			// we lerp the two resolved MeshPhysicalMaterials' scalar/color properties
+			// — physically loose but visually faithful, and crucially silent on success
+			// instead of warning per shape. Recursive: mix-in-mix terminates as the
+			// chain bottoms out at a non-mix.
+			const matNames = params.materials?.value || [];
+			const 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 ) ] );
+				const lerp = ( a, b ) => a * ( 1 - t ) + b * t;
+				mat.color.lerpColors( matA.color, matB.color, t );
+				mat.roughness = lerp( matA.roughness, matB.roughness );
+				mat.metalness = lerp( matA.metalness, matB.metalness );
+				mat.ior = lerp( matA.ior ?? 1.5, matB.ior ?? 1.5 );
+				mat.transmission = lerp( matA.transmission ?? 0, matB.transmission ?? 0 );
+				mat.thickness = lerp( matA.thickness ?? 0, matB.thickness ?? 0 );
+				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 );
+				mat.emissiveIntensity = lerp( matA.emissiveIntensity ?? 0, matB.emissiveIntensity ?? 0 );
+				// Maps can't be lerped — pick the dominant side.
+				mat.map = ( t < 0.5 ? matA.map : matB.map ) || null;
+				break;
+
+			}
+
+			ctx.warn( `material "mix" — could not resolve inner materials [${matNames.join( ', ' )}], falling back to diffuse` );
+			mat.color.set( new Color( 0.6, 0.6, 0.6 ) );
+			break;
+
+		}
+
+		case 'subsurface':
+		case 'hair':
+		case 'measured': {
+
+			ctx.warn( `material "${type}" not supported — using diffuse approximation` );
+			const refl = await resolveSpectrum( params, 'reflectance', ctx, [ 0.5, 0.5, 0.5 ] );
+			setColor( refl.rgb );
+			mat.roughness = 1;
+			break;
+
+		}
+
+		default: {
+
+			ctx.warn( `unknown material "${type}" — using neutral diffuse` );
+			mat.color.set( new Color( 0.6, 0.6, 0.6 ) );
+			break;
+
+		}
+
+	}
+
+	mat.roughness = Math.max( 0, Math.min( 1, mat.roughness ) );
+	return mat;
+
+}

package/src/Processor/PBRT/PBRTMath.js

@@ -0,0 +1,173 @@
+/**
+ * Minimal 4x4 matrix math for the pbrt CTM stack.
+ *
+ * Matrices are flat 16-element arrays in COLUMN-MAJOR order, identical to
+ * THREE.Matrix4.elements (element index = col*4 + row). This lets the scene
+ * builder do `new Matrix4().fromArray(ctm)` with no conversion.
+ *
+ * pbrt's `Transform [16]` directive supplies values that, after pbrt's internal
+ * transpose, are exactly column-major — so they map straight onto this layout.
+ *
+ * Pure JS so the parser stays Three.js-free and unit-testable.
+ */
+
+export function identity() {
+
+	return [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ];
+
+}
+
+/** Matrix product a*b (applies b first, then a, to a column vector). */
+export function multiply( a, b ) {
+
+	const a11 = a[ 0 ], a21 = a[ 1 ], a31 = a[ 2 ], a41 = a[ 3 ];
+	const a12 = a[ 4 ], a22 = a[ 5 ], a32 = a[ 6 ], a42 = a[ 7 ];
+	const a13 = a[ 8 ], a23 = a[ 9 ], a33 = a[ 10 ], a43 = a[ 11 ];
+	const a14 = a[ 12 ], a24 = a[ 13 ], a34 = a[ 14 ], a44 = a[ 15 ];
+
+	const b11 = b[ 0 ], b21 = b[ 1 ], b31 = b[ 2 ], b41 = b[ 3 ];
+	const b12 = b[ 4 ], b22 = b[ 5 ], b32 = b[ 6 ], b42 = b[ 7 ];
+	const b13 = b[ 8 ], b23 = b[ 9 ], b33 = b[ 10 ], b43 = b[ 11 ];
+	const b14 = b[ 12 ], b24 = b[ 13 ], b34 = b[ 14 ], b44 = b[ 15 ];
+
+	return [
+		a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41,
+		a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41,
+		a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41,
+		a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41,
+
+		a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42,
+		a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42,
+		a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42,
+		a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42,
+
+		a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43,
+		a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43,
+		a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43,
+		a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43,
+
+		a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44,
+		a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44,
+		a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44,
+		a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44
+	];
+
+}
+
+export function translate( x, y, z ) {
+
+	return [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1 ];
+
+}
+
+export function scale( x, y, z ) {
+
+	return [ x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1 ];
+
+}
+
+/** Axis-angle rotation. `angle` is in DEGREES (pbrt convention). */
+export function rotate( angle, x, y, z ) {
+
+	const len = Math.hypot( x, y, z ) || 1;
+	x /= len; y /= len; z /= len;
+
+	const rad = angle * Math.PI / 180;
+	const c = Math.cos( rad ), s = Math.sin( rad ), t = 1 - c;
+
+	const m00 = t * x * x + c, m01 = t * x * y - s * z, m02 = t * x * z + s * y;
+	const m10 = t * x * y + s * z, m11 = t * y * y + c, m12 = t * y * z - s * x;
+	const m20 = t * x * z - s * y, m21 = t * y * z + s * x, m22 = t * z * z + c;
+
+	return [
+		m00, m10, m20, 0,
+		m01, m11, m21, 0,
+		m02, m12, m22, 0,
+		0, 0, 0, 1
+	];
+
+}
+
+function sub( a, b ) {
+
+	return [ a[ 0 ] - b[ 0 ], a[ 1 ] - b[ 1 ], a[ 2 ] - b[ 2 ] ];
+
+}
+
+function cross( a, b ) {
+
+	return [
+		a[ 1 ] * b[ 2 ] - a[ 2 ] * b[ 1 ],
+		a[ 2 ] * b[ 0 ] - a[ 0 ] * b[ 2 ],
+		a[ 0 ] * b[ 1 ] - a[ 1 ] * b[ 0 ]
+	];
+
+}
+
+function normalize( a ) {
+
+	const len = Math.hypot( a[ 0 ], a[ 1 ], a[ 2 ] ) || 1;
+	return [ a[ 0 ] / len, a[ 1 ] / len, a[ 2 ] / len ];
+
+}
+
+/**
+ * Builds the camera-to-world matrix from a pbrt LookAt (eye, look, up).
+ * pbrt uses a left-handed camera basis: +z is the viewing direction.
+ * Columns: [ right, newUp, dir, eye ].
+ */
+export function lookAtCameraToWorld( eye, look, up ) {
+
+	const dir = normalize( sub( look, eye ) );
+	const right = normalize( cross( normalize( up ), dir ) );
+	const newUp = cross( dir, right );
+
+	return [
+		right[ 0 ], right[ 1 ], right[ 2 ], 0,
+		newUp[ 0 ], newUp[ 1 ], newUp[ 2 ], 0,
+		dir[ 0 ], dir[ 1 ], dir[ 2 ], 0,
+		eye[ 0 ], eye[ 1 ], eye[ 2 ], 1
+	];
+
+}
+
+/** General 4x4 inverse (column-major in/out). Returns identity if singular. */
+export function invert( m ) {
+
+	const n11 = m[ 0 ], n21 = m[ 1 ], n31 = m[ 2 ], n41 = m[ 3 ];
+	const n12 = m[ 4 ], n22 = m[ 5 ], n32 = m[ 6 ], n42 = m[ 7 ];
+	const n13 = m[ 8 ], n23 = m[ 9 ], n33 = m[ 10 ], n43 = m[ 11 ];
+	const n14 = m[ 12 ], n24 = m[ 13 ], n34 = m[ 14 ], n44 = m[ 15 ];
+
+	const t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44;
+	const t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44;
+	const t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44;
+	const t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
+
+	const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
+	if ( det === 0 ) return identity();
+	const idet = 1 / det;
+
+	return [
+		t11 * idet,
+		( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * idet,
+		( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * idet,
+		( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * idet,
+
+		t12 * idet,
+		( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * idet,
+		( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * idet,
+		( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * idet,
+
+		t13 * idet,
+		( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * idet,
+		( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * idet,
+		( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * idet,
+
+		t14 * idet,
+		( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * idet,
+		( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * idet,
+		( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * idet
+	];
+
+}