rayzee 9.4.1 → 9.5.0

package/src/Processor/PBRT/PBRTMaterials.js

@@ -65,6 +65,13 @@ export function pString( params, name, dflt ) {
 
 }
 
+export function pBool( params, name, dflt ) {
+
+	const v = params[ name ]?.value?.[ 0 ];
+	return v === undefined ? dflt : v === true || v === 'true';
+
+}
+
 /**
  * Resolve a spectrum/color/float-valued parameter to an RGB triple and/or a
  * texture. Returns `{ rgb, texture }` — exactly one is typically non-null.
@@ -144,15 +151,74 @@ function namedMetalKey( s ) {
 
 }
 
-/** Roughness from `roughness` or anisotropic `uroughness`/`vroughness`. */
-function resolveRoughness( params, dflt ) {
+// A float parameter's value, or a float texture's mean (`ctx.floatTextureMean`); null when absent or unreadable.
+async function floatOrMean( params, name, ctx ) {
+
+	const p = params[ name ];
+	if ( ! p ) return null;
+	if ( typeof p.value[ 0 ] === 'number' ) return p.value[ 0 ];
+	if ( p.type === 'texture' ) return ( await ctx.floatTextureMean?.( p.value[ 0 ] ) ) ?? null;
+	return null;
+
+}
+
+/**
+ * The engine's roughness for pbrt's `roughness` or anisotropic `uroughness`/`vroughness` (their α averaged), under
+ * `prefix` for a layer (`conductor.`, `interface.`); a textured roughness counts as its mean. pbrt-v4 takes GGX
+ * α = √roughness (`remaproughness`, the default) or α = roughness; the engine's GGX takes α = roughness². Passing
+ * pbrt's number through made `remaproughness false` 0.1 an α of 0.01, a near mirror. `dflt` is the engine's.
+ */
+async function resolveRoughness( params, dflt, ctx, prefix = '' ) {
+
+	const remap = params.remaproughness?.value?.[ 0 ];
+	const alpha = ( r ) => ( remap === false || remap === 'false' ? r : Math.sqrt( Math.max( r, 0 ) ) );
+	let a = null;
+	const r = await floatOrMean( params, `${prefix}roughness`, ctx );
+	if ( r !== null ) a = alpha( r );
+	else {
+
+		const u = await floatOrMean( params, `${prefix}uroughness`, ctx );
+		const v = await floatOrMean( params, `${prefix}vroughness`, ctx );
+		if ( u !== null ) a = v !== null ? ( alpha( u ) + alpha( v ) ) / 2 : alpha( u );
+
+	}
+
+	return a === null ? dflt : Math.sqrt( Math.max( a, 0 ) );
+
+}
+
+// A conductor's colour: `reflectance`, else normal-incidence Fresnel of `eta`/`k` (under `prefix` for a coated
+// conductor). pbrt's default is copper.
+async function applyConductorColor( mat, params, ctx, prefix, applyAlbedo, setColor ) {
+
+	const refl = await resolveSpectrum( params, 'reflectance', ctx, null );
+	const etaP = params[ `${prefix}eta` ], kP = params[ `${prefix}k` ];
+	const etaNamed = etaP && etaP.type === 'spectrum' && typeof etaP.value[ 0 ] === 'string';
+
+	if ( refl.rgb || refl.texture ) {
+
+		applyAlbedo( refl );
+
+	} else if ( etaP && kP && ! etaNamed ) {
+
+		// Normal-incidence reflectance from complex IOR: ((η-1)²+k²)/((η+1)²+k²).
+		const eta = ( await resolveSpectrum( params, `${prefix}eta`, ctx, [ 0.2, 0.92, 1.1 ] ) ).rgb;
+		const k = ( await resolveSpectrum( params, `${prefix}k`, ctx, [ 3.9, 2.45, 2.14 ] ) ).rgb;
+		const fr = ( n, kk ) => ( ( n - 1 ) ** 2 + kk ** 2 ) / ( ( n + 1 ) ** 2 + kk ** 2 );
+		setColor( [ fr( eta[ 0 ], k[ 0 ] ), fr( eta[ 1 ], k[ 1 ] ), fr( eta[ 2 ], k[ 2 ] ) ] );
+
+	} else if ( etaP ) {
 
-	if ( params.roughness && typeof params.roughness.value[ 0 ] === 'number' ) return params.roughness.value[ 0 ];
-	const u = pFloat( params, 'uroughness', null );
-	const v = pFloat( params, 'vroughness', null );
-	if ( u !== null && v !== null ) return ( u + v ) / 2;
-	if ( u !== null ) return u;
-	return dflt;
+		// Named conductor spectrum → metal albedo table.
+		setColor( ( await resolveSpectrum( params, `${prefix}eta`, ctx, DEFAULT_METAL ) ).rgb || DEFAULT_METAL );
+
+	} else {
+
+		setColor( METAL_ALBEDO.cu ); // pbrt-v4 default conductor is copper
+
+	}
+
+	mat.metalness = 1;
 
 }
 
@@ -193,9 +259,11 @@ export async function buildMaterial( def, ctx ) {
 
 		case 'diffuse': {
 
+			// Lambertian: no dielectric specular layer, which MeshPhysicalMaterial has by default.
 			applyAlbedo( await resolveSpectrum( params, 'reflectance', ctx, [ 0.5, 0.5, 0.5 ] ) );
 			mat.roughness = 1;
 			mat.metalness = 0;
+			mat.specularIntensity = 0;
 			break;
 
 		}
@@ -203,35 +271,19 @@ export async function buildMaterial( def, ctx ) {
 		case 'conductor':
 		case 'metal': {
 
-			const refl = await resolveSpectrum( params, 'reflectance', ctx, null );
-			const etaP = params.eta, kP = params.k;
-			const etaNamed = etaP && etaP.type === 'spectrum' && typeof etaP.value[ 0 ] === 'string';
-
-			if ( refl.rgb || refl.texture ) {
-
-				applyAlbedo( refl );
-
-			} else if ( etaP && kP && ! etaNamed ) {
-
-				// Normal-incidence reflectance from complex IOR: ((η-1)²+k²)/((η+1)²+k²).
-				const eta = ( await resolveSpectrum( params, 'eta', ctx, [ 0.2, 0.92, 1.1 ] ) ).rgb;
-				const k = ( await resolveSpectrum( params, 'k', ctx, [ 3.9, 2.45, 2.14 ] ) ).rgb;
-				const fr = ( n, kk ) => ( ( n - 1 ) ** 2 + kk ** 2 ) / ( ( n + 1 ) ** 2 + kk ** 2 );
-				setColor( [ fr( eta[ 0 ], k[ 0 ] ), fr( eta[ 1 ], k[ 1 ] ), fr( eta[ 2 ], k[ 2 ] ) ] );
-
-			} else if ( etaP ) {
-
-				// Named conductor spectrum → metal albedo table.
-				setColor( ( await resolveSpectrum( params, 'eta', ctx, DEFAULT_METAL ) ).rgb || DEFAULT_METAL );
-
-			} else {
+			await applyConductorColor( mat, params, ctx, '', applyAlbedo, setColor );
+			mat.roughness = await resolveRoughness( params, 0.1, ctx );
+			break;
 
-				setColor( METAL_ALBEDO.cu ); // pbrt-v4 default conductor is copper
+		}
 
-			}
+		case 'coatedconductor': {
 
-			mat.metalness = 1;
-			mat.roughness = resolveRoughness( params, 0.1 );
+			// A conductor under a dielectric coat; pbrt's roughnesses default to 0 for both.
+			await applyConductorColor( mat, params, ctx, 'conductor.', applyAlbedo, setColor );
+			mat.roughness = await resolveRoughness( params, 0, ctx, 'conductor.' );
+			mat.clearcoat = 1;
+			mat.clearcoatRoughness = await resolveRoughness( params, 0, ctx, 'interface.' );
 			break;
 
 		}
@@ -243,7 +295,7 @@ export async function buildMaterial( def, ctx ) {
 			mat.metalness = 0;
 			mat.color.setRGB( 1, 1, 1 );
 			mat.ior = pFloat( params, 'eta', 1.5 );
-			mat.roughness = resolveRoughness( params, 0 );
+			mat.roughness = await resolveRoughness( params, 0, ctx );
 			mat.thickness = type === 'thindielectric' ? 0 : pFloat( params, 'thickness', 0 );
 			break;
 
@@ -255,18 +307,30 @@ export async function buildMaterial( def, ctx ) {
 			mat.roughness = 0.6;
 			mat.metalness = 0;
 			mat.clearcoat = 1;
-			mat.clearcoatRoughness = resolveRoughness( params, 0 );
+			mat.clearcoatRoughness = await resolveRoughness( params, 0, ctx );
 			break;
 
 		}
 
 		case 'diffusetransmission': {
 
+			// pbrt reflects R and transmits T, both diffusely and both × `scale`, clamped to [0, 1]; no specular layer.
+			// The engine splits its diffuse lobe by `diffuseTransmission`: reflecting (1 − dt) · base, transmitting
+			// dt · colour. dt = max(T) makes both exact whenever max(R) + max(T) ≤ 1.
+			const scale = pFloat( params, 'scale', 1 );
+			const unit = ( v ) => Math.min( 1, Math.max( 0, scale * v ) );
 			const trans = await resolveSpectrum( params, 'transmittance', ctx, [ 0.25, 0.25, 0.25 ] );
-			applyAlbedo( await resolveSpectrum( params, 'reflectance', ctx, [ 0.25, 0.25, 0.25 ] ) );
-			mat.transmission = trans.rgb ? ( trans.rgb[ 0 ] + trans.rgb[ 1 ] + trans.rgb[ 2 ] ) / 3 : 0.5;
+			const T = trans.rgb ? trans.rgb.map( unit ) : [ 0.5, 0.5, 0.5 ];
+			const dt = Math.min( 0.99, Math.max( ...T ) );
+			const refl = await resolveSpectrum( params, 'reflectance', ctx, [ 0.25, 0.25, 0.25 ] );
+			const base = ( v ) => Math.min( 1, unit( v ) / ( 1 - dt ) );
+			applyAlbedo( { texture: refl.texture, rgb: refl.rgb ? refl.rgb.map( base ) : ( refl.texture ? [ 1, 1, 1 ].map( base ) : null ) } );
+			if ( trans.texture ) ctx.warn( 'diffusetransmission: a textured "transmittance" is not supported — using 0.5' );
+			mat.diffuseTransmission = dt;
+			mat.diffuseTransmissionColor = new Color().setRGB( ...T.map( ( v ) => ( dt > 0 ? Math.min( 1, v / dt ) : 1 ) ) );
 			mat.roughness = 1;
-			mat.ior = 1.0;
+			mat.metalness = 0;
+			mat.specularIntensity = 0;
 			break;
 
 		}
@@ -292,13 +356,18 @@ export async function buildMaterial( def, ctx ) {
 			// instead of warning per shape. Recursive: mix-in-mix terminates as the
 			// chain bottoms out at a non-mix.
 			const matNames = params.materials?.value || [];
-			const t = Math.max( 0, Math.min( 1, pFloat( params, 'amount', 0.5 ) ) );
+			let t = Math.max( 0, Math.min( 1, pFloat( params, 'amount', 0.5 ) ) );
 			const defA = matNames[ 0 ] ? ctx.namedMaterials?.get( matNames[ 0 ] ) : null;
 			const defB = matNames[ 1 ] ? ctx.namedMaterials?.get( matNames[ 1 ] ) : null;
 
 			if ( defA && defB ) {
 
 				const [ matA, matB ] = await Promise.all( [ buildMaterial( defA, ctx ), buildMaterial( defB, ctx ) ] );
+				// pbrt picks the second material where a texture amount says so; its colours are baked by that
+				// texture (`ctx.bakeMaterialMix`) and the rest is weighed by the texture's mean.
+				const amountP = params.amount;
+				const baked = amountP?.type === 'texture' ? await ctx.bakeMaterialMix?.( matA, matB, amountP.value[ 0 ] ) : null;
+				if ( baked ) t = baked.mean;
 				const lerp = ( a, b ) => a * ( 1 - t ) + b * t;
 				mat.color.lerpColors( matA.color, matB.color, t );
 				mat.roughness = lerp( matA.roughness, matB.roughness );
@@ -309,9 +378,25 @@ export async function buildMaterial( def, ctx ) {
 				mat.clearcoat = lerp( matA.clearcoat ?? 0, matB.clearcoat ?? 0 );
 				mat.clearcoatRoughness = lerp( matA.clearcoatRoughness ?? 0, matB.clearcoatRoughness ?? 0 );
 				mat.emissive.lerpColors( matA.emissive, matB.emissive, t );
+				const dtA = matA.diffuseTransmission ?? 0, dtB = matB.diffuseTransmission ?? 0;
+				if ( dtA > 0 || dtB > 0 ) {
+
+					mat.diffuseTransmission = lerp( dtA, dtB );
+					mat.diffuseTransmissionColor = new Color().lerpColors( matA.diffuseTransmissionColor ?? new Color( 1, 1, 1 ), matB.diffuseTransmissionColor ?? new Color( 1, 1, 1 ), t );
+
+				}
+
 				mat.emissiveIntensity = lerp( matA.emissiveIntensity ?? 0, matB.emissiveIntensity ?? 0 );
-				// Maps can't be lerped — pick the dominant side.
+				// Maps can't be lerped — pick the dominant side, unless the amount's own texture baked them together.
 				mat.map = ( t < 0.5 ? matA.map : matB.map ) || null;
+				mat.normalMap = ( t < 0.5 ? matA.normalMap : matB.normalMap ) || null;
+				if ( baked?.texture ) {
+
+					mat.map = baked.texture;
+					mat.color.setRGB( 1, 1, 1 );
+
+				}
+
 				break;
 
 			}
@@ -344,6 +429,9 @@ export async function buildMaterial( def, ctx ) {
 
 	}
 
+	const normalMap = pString( params, 'normalmap', null );
+	if ( normalMap && ctx.resolveNormalMap ) mat.normalMap = await ctx.resolveNormalMap( normalMap );
+
 	mat.roughness = Math.max( 0, Math.min( 1, mat.roughness ) );
 	return mat;
 

package/src/Processor/PBRT/PBRTParser.js

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