rayzee 11.0.0 → 11.1.1

package/dist/{sceneCachePolicy-BSSsKY98.js → sceneCachePolicy-Bk8sI5PZ.js}

@@ -435,7 +435,7 @@ var Y = class {
 			samples: this.samples.slice()
 		};
 	}
-}, X = "11.0.0", Z = 1e4, Q = 15e5;
+}, X = "11.1.1", Z = 1e4, Q = 15e5;
 function $(e, t, n = Z) {
 	return e >= n && t / Q < e / 3;
 }

package/package.json

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

package/src/PathTracerApp.js

@@ -461,6 +461,7 @@ export class PathTracerApp extends RayzeeRenderer {
 
 		this._syncControlsAfterLoad();
 		this.cameraManager.currentCameraIndex = 0;
+		if ( this.cameraManager.cameras.length > 1 ) this.cameraManager.switchCamera( 1 );
 
 	}
 

package/src/Processor/ArchiveCache.js

@@ -16,30 +16,43 @@ export async function archiveKey( kind, file ) {
 /**
  * Decompresses a .tar.gz into storage once, indexing it on the way, and hands back the unpacked
  * .tar as a seekable File. A second call for the same file skips the work.
+ *
+ * With `filter` (and `part`, naming what it keeps) only the entries it keeps are written, end to end, and only they
+ * get offsets in the listing: a 31 GB scene archive need not fit to load the part of it chosen. An unpack of the whole
+ * archive serves any part.
  * @returns {Promise<?{file: File, index: {v:number, listing:Array}, release: function(): void, cached: boolean}>}
  *   null when storage cannot take it — the caller reads the archive the old way.
  */
-export async function unpackTarGz( file, { storage, label = file.name, onProgress = null } ) {
+export async function unpackTarGz( file, { storage, label = file.name, onProgress = null, filter = null, part = null } ) {
 
 	if ( ! storage || typeof DecompressionStream === 'undefined' ) return null;
 
 	const area = storage.area( ENGINE_AREAS.ARCHIVES );
-	const key = await archiveKey( 'gunzip', file );
+	const whole = await archiveKey( 'gunzip', file );
+	let key = whole;
 
-	let entry = await area.open( key );
+	let entry = await area.open( whole );
+	if ( ! entry && filter ) entry = await area.open( key = `${whole}|${part}` );
 	const cached = !! entry;
 
 	if ( ! entry ) {
 
-		const writer = await area.create( key, { label, expectedBytes: file.size * GUESSED_EXPANSION } );
+		// A part's size is known only once its headers are read: a write past the quota falls back below.
+		const writer = await area.create( key, filter ? { label: `${label} (${part})` } : { label, expectedBytes: file.size * GUESSED_EXPANSION } );
 		if ( ! writer ) return null;
 
-		const indexer = createTarIndexer();
+		let out = null;
+		const indexer = createTarIndexer( filter ? { filter, sink: ( bytes ) => out.enqueue( bytes ) } : {} );
 		const tap = new TransformStream( {
+			start( controller ) {
+
+				out = controller;
+
+			},
 			transform( chunk, controller ) {
 
 				indexer.push( chunk );
-				controller.enqueue( chunk );
+				if ( ! filter ) controller.enqueue( chunk );
 
 			},
 		} );

package/src/Processor/ArchiveImporter.js

@@ -129,13 +129,15 @@ export class ArchiveImporter {
 	 * A .tar.gz unpacked to storage, or null to read it the old way (no storage, or no room).
 	 * @private
 	 */
-	async _unpackGzip( file, filename ) {
+	async _unpackGzip( file, filename, element = null ) {
 
+		const chosen = ( Array.isArray( element ) ? element : [ element ] ).filter( Boolean );
 		try {
 
 			return await unpackTarGz( file, {
 				storage: this.loader.storage,
 				label: filename,
+				...( chosen.length ? { filter: elementFilter( chosen ), part: [ ...chosen ].sort().join( ',' ) } : {} ),
 				onProgress: bytes => updateLoading( {
 					isLoading: true, status: `Unpacking archive… ${( bytes / 1e9 ).toFixed( 1 )} GB`, progress: 4
 				} ),
@@ -189,7 +191,7 @@ export class ArchiveImporter {
 
 			if ( kind === 'gzip' ) {
 
-				const unpacked = await this._unpackGzip( file, filename );
+				const unpacked = await this._unpackGzip( file, filename, element );
 				if ( unpacked ) {
 
 					try {
@@ -337,6 +339,7 @@ export class ArchiveImporter {
 					meshCount: built.meshCount, entryPath: built.entryPath, candidates: built.candidates, frames: built.frames,
 					warnings: built.warnings, triangleCount: built.triangleCount, placementCount: built.placementCount,
 					mergedShapes: built.mergedShapes, skippedForBudget: built.skippedForBudget, droppedNoTemplate: built.droppedNoTemplate,
+					render: built.render ?? null,
 				},
 			} );
 
@@ -680,7 +683,10 @@ export class ArchiveImporter {
 		// The light's own orientation and `scale` are already baked into the texture, so the
 		// scene is only correct at rotation 0 / intensity 1 — pinned, whatever the host's defaults.
 		// Without an infinite light pbrt has no environment at all.
-		this.loader.sceneMetadata = { environment: environment?.texture ? { rotation: 0, intensity: 1 } : { enabled: false } };
+		this.loader.sceneMetadata = {
+			environment: environment?.texture ? { rotation: 0, intensity: 1 } : { enabled: false },
+			...( built.render ? { render: { ...built.render } } : {} ),
+		};
 
 		updateLoading( { isLoading: true, status: 'Processing PBRT geometry...', progress: 10 } );
 		await this.loader.onModelLoad( this.loader.targetModel );

package/src/Processor/ArchiveReader.js

@@ -135,9 +135,12 @@ function isZeroBlock( h ) {
  */
 class TarStream {
 
-	constructor( { filter = null, retain = null, byteBudget = DEFAULT_BYTE_BUDGET, onEntry = null } = {} ) {
+	constructor( { filter = null, retain = null, byteBudget = DEFAULT_BYTE_BUDGET, onEntry = null, sink = null } = {} ) {
 
 		this.filter = filter;
+		// Passed each indexed entry's bytes in order: the listing then records offsets into what the sink wrote.
+		this.sink = sink;
+		this._sunk = 0;
 		// Entries that pass `filter` but fail `retain` are indexed, not copied: the listing
 		// records where their bytes live so a caller with a seekable source can read them later.
 		// An uncompressed tar over a File is seekable, which is how a 7 GB archive loads without
@@ -190,6 +193,14 @@ class TarStream {
 			} else {
 
 				const n = Math.min( this._remaining, chunk.length - i );
+				if ( this.sink && this._indexed && this._sinkLeft > 0 ) {
+
+					const take = Math.min( n, this._sinkLeft );
+					this.sink( chunk.subarray( i, i + take ) );
+					this._sinkLeft -= take;
+
+				}
+
 				if ( this._dst && this._copied < this._size ) {
 
 					const take = Math.min( n, this._size - this._copied );
@@ -267,6 +278,13 @@ class TarStream {
 
 		this.listing.push( { path, size } );
 		this._indexed = this.filter ? this.filter( path, size ) : true;
+		if ( this.sink && this._indexed ) {
+
+			this._sinkStart = this._sunk;
+			this._sinkLeft = size;
+			this._sunk += size;
+
+		}
 
 		if ( this._indexed && ! ( this.retain && ! this.retain( path, size ) ) ) {
 
@@ -313,7 +331,7 @@ class TarStream {
 
 		if ( this._indexed && entry ) {
 
-			entry.offset = this._bodyStart;
+			entry.offset = this.sink ? this._sinkStart : this._bodyStart;
 			this._indexed = false;
 
 		}
@@ -503,9 +521,9 @@ export async function indexTarHeaders( source, { onProgress = null } = {} ) {
  * Indexes a tar stream as it goes by — for writing a decompressing archive to disk and knowing
  * where every entry landed without a second pass.
  */
-export function createTarIndexer() {
+export function createTarIndexer( { filter = null, sink = null } = {} ) {
 
-	const tar = new TarStream( { retain: () => false } );
+	const tar = new TarStream( { retain: () => false, filter, sink } );
 	return {
 		push: chunk => tar.push( chunk ),
 		finish: () => {

package/src/Processor/PBRT/PBRTMaterials.js

@@ -9,6 +9,7 @@
  */
 
 import { MeshPhysicalMaterial, Color, DoubleSide } from 'three';
+import { namedScattering, dipoleReflectance, albedoForReflectance } from './PBRTScattering.js';
 
 // Normal-incidence reflectance approximations for pbrt's named conductor spectra.
 const METAL_ALBEDO = {
@@ -168,10 +169,17 @@ async function floatOrMean( params, name, ctx ) {
  * α = √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 remapsRoughness = ( params ) => {
 
 	const remap = params.remaproughness?.value?.[ 0 ];
-	const alpha = ( r ) => ( remap === false || remap === 'false' ? r : Math.sqrt( Math.max( r, 0 ) ) );
+	return remap !== false && remap !== 'false';
+
+};
+
+async function resolveRoughness( params, dflt, ctx, prefix = '' ) {
+
+	const remap = remapsRoughness( params );
+	const alpha = ( r ) => ( remap ? Math.sqrt( Math.max( r, 0 ) ) : r );
 	let a = null;
 	const r = await floatOrMean( params, `${prefix}roughness`, ctx );
 	if ( r !== null ) a = alpha( r );
@@ -187,6 +195,116 @@ async function resolveRoughness( params, dflt, ctx, prefix = '' ) {
 
 }
 
+/**
+ * Sets `target` (`roughness` or `clearcoatRoughness`) as resolveRoughness does, except that a textured roughness becomes
+ * a roughness map with the remap baked in (`ctx.bakeFloatMap`), the value 1 multiplying it.
+ */
+async function applyRoughness( mat, target, params, dflt, ctx, prefix = '' ) {
+
+	const single = params[ `${prefix}roughness` ];
+	const keys = single ? [ `${prefix}roughness` ] : [ `${prefix}uroughness`, `${prefix}vroughness` ].filter( ( key ) => params[ key ] );
+	if ( ctx.bakeFloatMap && keys.some( ( key ) => params[ key ].type === 'texture' ) ) {
+
+		const remap = remapsRoughness( params );
+		const alpha = ( r ) => ( remap ? Math.sqrt( Math.max( r, 0 ) ) : Math.max( r, 0 ) );
+		const map = await ctx.bakeFloatMap( params, keys, ( values ) => Math.sqrt( values.reduce( ( sum, r ) => sum + alpha( r ), 0 ) / values.length ) );
+		if ( map ) {
+
+			mat[ `${target}Map` ] = map;
+			mat[ target ] = 1;
+			return;
+
+		}
+
+	}
+
+	mat[ target ] = await resolveRoughness( params, dflt, ctx, prefix );
+
+}
+
+// A spectrum parameter as one RGB; a texture counts as its mean (`ctx.textureMeanRGB`).
+async function spectrumMean( params, key, ctx, dflt ) {
+
+	const p = params[ key ];
+	if ( p?.type === 'texture' ) return ( await ctx.textureMeanRGB?.( p.value[ 0 ] ) ) ?? dflt;
+	return ( await resolveSpectrum( params, key, ctx, dflt ) ).rgb ?? dflt;
+
+}
+
+// pbrt's default subsurface medium (materials.cpp), mm⁻¹.
+const SUBSURFACE_SIGMA_A = [ 0.0011, 0.0024, 0.014 ];
+const SUBSURFACE_SIGMA_S = [ 2.55, 3.21, 3.77 ];
+
+/**
+ * pbrt's `subsurface` as the engine's random walk under a dielectric boundary of `eta`: σt = σa + σs (times `scale`),
+ * single-scattering albedo σs / σt, mean free path 1 / σt. The coefficients come as pbrt takes them — a named medium
+ * (g 0), `sigma_a` and `sigma_s`, or a `reflectance` and `mfp` (scaled) inverted through the dipole — and default to
+ * pbrt's. The base colour is the reflectance the dipole gives, for what reads it as an albedo.
+ */
+async function applySubsurface( mat, params, ctx ) {
+
+	const eta = pFloat( params, 'eta', 1.33 );
+	const scale = pFloat( params, 'scale', 1 );
+	const scaled = ( rgb ) => rgb.map( ( v ) => Math.max( 0, v * scale ) );
+	let g = pFloat( params, 'g', 0 );
+	let sigmaA, sigmaS;
+
+	const name = pString( params, 'name', '' );
+	const named = name ? namedScattering( name ) : null;
+	if ( name && ! named ) ctx.warn( `subsurface: no medium named "${name}" — using pbrt's default` );
+
+	if ( named ) {
+
+		sigmaA = scaled( named.sigmaA );
+		sigmaS = scaled( named.sigmaS );
+		g = 0;
+
+	} else if ( params.sigma_a && params.sigma_s ) {
+
+		sigmaA = scaled( await spectrumMean( params, 'sigma_a', ctx, SUBSURFACE_SIGMA_A ) );
+		sigmaS = scaled( await spectrumMean( params, 'sigma_s', ctx, SUBSURFACE_SIGMA_S ) );
+
+	} else if ( params.reflectance && ! name ) {
+
+		const reflectance = await spectrumMean( params, 'reflectance', ctx, [ 0.5, 0.5, 0.5 ] );
+		const mfp = scaled( params.mfp ? await spectrumMean( params, 'mfp', ctx, [ 1, 1, 1 ] ) : [ 1, 1, 1 ] );
+		sigmaA = [];
+		sigmaS = [];
+		for ( let c = 0; c < 3; c ++ ) {
+
+			const sigmaT = 1 / Math.max( mfp[ c ], 1e-9 );
+			// The reduced albedo σ′s / ( σa + σ′s ), σ′s = ( 1 − g ) σs, back to σs at this σt.
+			const reduced = albedoForReflectance( reflectance[ c ], eta );
+			sigmaS[ c ] = reduced * sigmaT / ( 1 - g + reduced * g );
+			sigmaA[ c ] = sigmaT - sigmaS[ c ];
+
+		}
+
+	} else {
+
+		sigmaA = scaled( SUBSURFACE_SIGMA_A );
+		sigmaS = scaled( SUBSURFACE_SIGMA_S );
+
+	}
+
+	const sigmaT = sigmaA.map( ( a, c ) => a + sigmaS[ c ] );
+	mat.subsurface = 1;
+	mat.subsurfaceColor = new Color( ...sigmaT.map( ( t, c ) => ( t > 0 ? sigmaS[ c ] / t : 0 ) ) );
+	mat.subsurfaceRadius = sigmaT.map( ( t ) => ( t > 0 ? 1 / t : 1e6 ) );
+	mat.subsurfaceRadiusScale = 1;
+	mat.subsurfaceAnisotropy = Math.max( - 0.99, Math.min( 0.99, g ) );
+	mat.ior = eta;
+	mat.metalness = 0;
+	mat.color.setRGB( ...sigmaT.map( ( t, c ) => {
+
+		const reducedS = ( 1 - g ) * sigmaS[ c ];
+		return t > 0 ? dipoleReflectance( reducedS / ( sigmaA[ c ] + reducedS ), eta ) : 0;
+
+	} ) );
+	await applyRoughness( mat, 'roughness', params, 0, ctx );
+
+}
+
 // A conductor's colour: `reflectance`, else normal-incidence Fresnel of `eta`/`k` (under `prefix` for a coated
 // conductor). pbrt's default is copper.
 async function applyConductorColor( mat, params, ctx, prefix, applyAlbedo, setColor ) {
@@ -272,7 +390,7 @@ export async function buildMaterial( def, ctx ) {
 		case 'metal': {
 
 			await applyConductorColor( mat, params, ctx, '', applyAlbedo, setColor );
-			mat.roughness = await resolveRoughness( params, 0.1, ctx );
+			await applyRoughness( mat, 'roughness', params, 0.1, ctx );
 			break;
 
 		}
@@ -281,9 +399,9 @@ export async function buildMaterial( def, ctx ) {
 
 			// 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.' );
+			await applyRoughness( mat, 'roughness', params, 0, ctx, 'conductor.' );
 			mat.clearcoat = 1;
-			mat.clearcoatRoughness = await resolveRoughness( params, 0, ctx, 'interface.' );
+			await applyRoughness( mat, 'clearcoatRoughness', params, 0, ctx, 'interface.' );
 			break;
 
 		}
@@ -295,7 +413,7 @@ export async function buildMaterial( def, ctx ) {
 			mat.metalness = 0;
 			mat.color.setRGB( 1, 1, 1 );
 			mat.ior = pFloat( params, 'eta', 1.5 );
-			mat.roughness = await resolveRoughness( params, 0, ctx );
+			await applyRoughness( mat, 'roughness', params, 0, ctx );
 			mat.thickness = type === 'thindielectric' ? 0 : pFloat( params, 'thickness', 0 );
 			break;
 
@@ -307,7 +425,7 @@ export async function buildMaterial( def, ctx ) {
 			mat.roughness = 0.6;
 			mat.metalness = 0;
 			mat.clearcoat = 1;
-			mat.clearcoatRoughness = await resolveRoughness( params, 0, ctx );
+			await applyRoughness( mat, 'clearcoatRoughness', params, 0, ctx );
 			break;
 
 		}
@@ -407,7 +525,13 @@ export async function buildMaterial( def, ctx ) {
 
 		}
 
-		case 'subsurface':
+		case 'subsurface': {
+
+			await applySubsurface( mat, params, ctx );
+			break;
+
+		}
+
 		case 'hair':
 		case 'measured': {
 

package/src/Processor/PBRT/PBRTParser.js

@@ -603,15 +603,33 @@ export class PBRTParser {
 				this.ir.film = {
 					xresolution: this._num( params.xresolution, 1280 ),
 					yresolution: this._num( params.yresolution, 720 ),
+					resolutionGiven: Boolean( params.xresolution || params.yresolution ),
 					filename: this._str( params.filename, null )
 				};
 				break;
 
 			}
 
+			// What the scene asks the renderer for; reported, not applied (PBRTSceneBuilder renderRequest).
+			case 'Integrator': {
+
+				this._expectString( 'Integrator type' );
+				const params = this._parseParams();
+				if ( params.maxdepth ) this.ir.integrator = { maxdepth: this._num( params.maxdepth, 5 ) };
+				break;
+
+			}
+
+			case 'Sampler': {
+
+				this._expectString( 'Sampler type' );
+				const params = this._parseParams();
+				if ( params.pixelsamples ) this.ir.sampler = { pixelsamples: this._num( params.pixelsamples, 16 ) };
+				break;
+
+			}
+
 			// Consumed for completeness; not used by the engine.
-			case 'Integrator':
-			case 'Sampler':
 			case 'PixelFilter':
 			case 'Filter':
 			case 'Accelerator':
@@ -759,7 +777,6 @@ export class PBRTParser {
 				// 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,

package/src/Processor/PBRT/PBRTScattering.js

@@ -0,0 +1,93 @@
+/**
+ * Scattering coefficients for pbrt's `subsurface` material: its named media and the inversion from a diffuse
+ * reflectance to the albedo that produces it.
+ */
+
+// pbrt-v4's table (media.cpp): [ σ′s, σa ] in mm⁻¹, from Jensen et al. 2001 and Narasimhan et al. 2006.
+const MEASURED = {
+	'Apple': [[ 2.29, 2.39, 1.97 ], [ 0.0030, 0.0034, 0.046 ]],
+	'Chicken1': [[ 0.15, 0.21, 0.38 ], [ 0.015, 0.077, 0.19 ]],
+	'Chicken2': [[ 0.19, 0.25, 0.32 ], [ 0.018, 0.088, 0.20 ]],
+	'Cream': [[ 7.38, 5.47, 3.15 ], [ 0.0002, 0.0028, 0.0163 ]],
+	'Ketchup': [[ 0.18, 0.07, 0.03 ], [ 0.061, 0.97, 1.45 ]],
+	'Marble': [[ 2.19, 2.62, 3.00 ], [ 0.0021, 0.0041, 0.0071 ]],
+	'Potato': [[ 0.68, 0.70, 0.55 ], [ 0.0024, 0.0090, 0.12 ]],
+	'Skimmilk': [[ 0.70, 1.22, 1.90 ], [ 0.0014, 0.0025, 0.0142 ]],
+	'Skin1': [[ 0.74, 0.88, 1.01 ], [ 0.032, 0.17, 0.48 ]],
+	'Skin2': [[ 1.09, 1.59, 1.79 ], [ 0.013, 0.070, 0.145 ]],
+	'Spectralon': [[ 11.6, 20.4, 14.9 ], [ 0.00, 0.00, 0.00 ]],
+	'Wholemilk': [[ 2.55, 3.21, 3.77 ], [ 0.0011, 0.0024, 0.014 ]],
+	'Lowfat Milk': [[ 0.89187, 1.5136, 2.532 ], [ 0.002875, 0.00575, 0.0115 ]],
+	'Reduced Milk': [[ 2.4858, 3.1669, 4.5214 ], [ 0.0025556, 0.0051111, 0.012778 ]],
+	'Regular Milk': [[ 4.5513, 5.8294, 7.136 ], [ 0.0015333, 0.0046, 0.019933 ]],
+	'Espresso': [[ 0.72378, 0.84557, 1.0247 ], [ 4.7984, 6.5751, 8.8493 ]],
+	'Mint Mocha Coffee': [[ 0.31602, 0.38538, 0.48131 ], [ 3.772, 5.8228, 7.82 ]],
+	'Lowfat Soy Milk': [[ 0.30576, 0.34233, 0.61664 ], [ 0.0014375, 0.0071875, 0.035937 ]],
+	'Regular Soy Milk': [[ 0.59223, 0.73866, 1.4693 ], [ 0.0019167, 0.0095833, 0.065167 ]],
+	'Lowfat Chocolate Milk': [[ 0.64925, 0.83916, 1.1057 ], [ 0.0115, 0.0368, 0.1564 ]],
+	'Regular Chocolate Milk': [[ 1.4585, 2.1289, 2.9527 ], [ 0.010063, 0.043125, 0.14375 ]],
+	'Coke': [[ 8.9053e-05, 8.372e-05, 0 ], [ 0.10014, 0.16503, 0.2468 ]],
+	'Pepsi': [[ 6.1697e-05, 4.2564e-05, 0 ], [ 0.091641, 0.14158, 0.20729 ]],
+	'Sprite': [[ 6.0306e-06, 6.4139e-06, 6.5504e-06 ], [ 0.001886, 0.0018308, 0.0020025 ]],
+	'Gatorade': [[ 0.0024574, 0.003007, 0.0037325 ], [ 0.024794, 0.019289, 0.008878 ]],
+	'Chardonnay': [[ 1.7982e-05, 1.3758e-05, 1.2023e-05 ], [ 0.010782, 0.011855, 0.023997 ]],
+	'White Zinfandel': [[ 1.7501e-05, 1.9069e-05, 1.288e-05 ], [ 0.012072, 0.016184, 0.019843 ]],
+	'Merlot': [[ 2.1129e-05, 0, 0 ], [ 0.11632, 0.25191, 0.29434 ]],
+	'Budweiser Beer': [[ 2.4356e-05, 2.4079e-05, 1.0564e-05 ], [ 0.011492, 0.024911, 0.057786 ]],
+	'Coors Light Beer': [[ 5.0922e-05, 4.301e-05, 0 ], [ 0.006164, 0.013984, 0.034983 ]],
+	'Clorox': [[ 0.0024035, 0.0031373, 0.003991 ], [ 0.0033542, 0.014892, 0.026297 ]],
+	'Apple Juice': [[ 0.00013612, 0.00015836, 0.000227 ], [ 0.012957, 0.023741, 0.052184 ]],
+	'Cranberry Juice': [[ 0.00010402, 0.00011646, 7.8139e-05 ], [ 0.039437, 0.094223, 0.12426 ]],
+	'Grape Juice': [[ 5.382e-05, 0, 0 ], [ 0.10404, 0.23958, 0.29325 ]],
+	'Ruby Grapefruit Juice': [[ 0.011002, 0.010927, 0.011036 ], [ 0.085867, 0.18314, 0.25262 ]],
+	'White Grapefruit Juice': [[ 0.22826, 0.23998, 0.32748 ], [ 0.0138, 0.018831, 0.056781 ]],
+	'Shampoo': [[ 0.0007176, 0.0008303, 0.0009016 ], [ 0.014107, 0.045693, 0.061717 ]],
+	'Strawberry Shampoo': [[ 0.00015671, 0.00015947, 1.518e-05 ], [ 0.01449, 0.05796, 0.075823 ]],
+	'Head & Shoulders Shampoo': [[ 0.023805, 0.028804, 0.034306 ], [ 0.084621, 0.15688, 0.20365 ]],
+	'Lemon Tea Powder': [[ 0.040224, 0.045264, 0.051081 ], [ 2.4288, 4.5757, 7.2127 ]],
+	'Orange Powder': [[ 0.00015617, 0.00017482, 0.0001762 ], [ 0.001449, 0.003441, 0.007863 ]],
+	'Pink Lemonade Powder': [[ 0.00012103, 0.00013073, 0.00012528 ], [ 0.001165, 0.002366, 0.003195 ]],
+	'Cappuccino Powder': [[ 1.8436, 2.5851, 2.1662 ], [ 35.844, 49.547, 61.084 ]],
+	'Salt Powder': [[ 0.027333, 0.032451, 0.031979 ], [ 0.28415, 0.3257, 0.34148 ]],
+	'Sugar Powder': [[ 0.00022272, 0.00025513, 0.000271 ], [ 0.012638, 0.031051, 0.050124 ]],
+	'Suisse Mocha Powder': [[ 2.7979, 3.5452, 4.3365 ], [ 17.502, 27.004, 35.433 ]],
+	'Pacific Ocean Surface Water': [[ 0.0001764, 0.00032095, 0.00019617 ], [ 0.031845, 0.031324, 0.030147 ]],
+};
+
+/** A named medium's `{ sigmaS, sigmaA }` (σ′s with g = 0), or null. */
+export function namedScattering( name ) {
+
+	const entry = MEASURED[ name ];
+	return entry ? { sigmaS: entry[ 0 ].slice(), sigmaA: entry[ 1 ].slice() } : null;
+
+}
+
+/**
+ * Total diffuse reflectance of a half space of reduced albedo α′ and relative index η under the classical dipole
+ * (Jensen et al. 2001): (α′ / 2) (1 + e^(−4/3 A √(3(1 − α′)))) e^(−√(3(1 − α′))).
+ */
+export function dipoleReflectance( albedo, eta ) {
+
+	const fdr = - 1.440 / ( eta * eta ) + 0.710 / eta + 0.668 + 0.0636 * eta;
+	const A = ( 1 + fdr ) / ( 1 - fdr );
+	const s = Math.sqrt( 3 * ( 1 - albedo ) );
+	return albedo / 2 * ( 1 + Math.exp( - 4 / 3 * A * s ) ) * Math.exp( - s );
+
+}
+
+/** The reduced albedo whose dipole reflectance is `reflectance` (pbrt inverts its own table the same way). */
+export function albedoForReflectance( reflectance, eta ) {
+
+	const target = Math.min( Math.max( reflectance, 0 ), dipoleReflectance( 1, eta ) );
+	let lo = 0, hi = 1;
+	for ( let i = 0; i < 48; i ++ ) {
+
+		const mid = ( lo + hi ) / 2;
+		if ( dipoleReflectance( mid, eta ) < target ) lo = mid;
+		else hi = mid;
+
+	}
+
+	return ( lo + hi ) / 2;
+
+}