@unikia/upe-renderer 0.186.110 → 0.187.11

package/examples/jsm/loaders/materialx/MaterialXSurfaceMappings.js

@@ -1,6 +1,6 @@
-import { DoubleSide } from 'three/webgpu';
+import { AddEquation, CustomBlending, DoubleSide, OneFactor, OneMinusSrcAlphaFactor } from 'three/webgpu';
 import { MaterialXLogCodes } from './MaterialXLog.js';
-import { float, color, mul, clamp, vec2, cos, sin, pow, mix, element, transformNormalToView } from 'three/tsl';
+import { Fn, float, vec3, mul, sub, dot, clamp, vec2, cos, sin, pow, mix, element, transformNormalToView, positionLocal, normalLocal, tangentLocal, bitangentLocal } from 'three/tsl';
 
 const mappedStandardSurfaceInputs = new Set( [
 	'base',
@@ -129,6 +129,7 @@ function getConstNumber( node ) {
 		if ( visited.has( cursor ) ) break;
 		visited.add( cursor );
 		if ( typeof cursor.value === 'number' ) return cursor.value;
+		if ( cursor.value && cursor.value.isColor && cursor.value.r === cursor.value.g && cursor.value.g === cursor.value.b ) return cursor.value.r;
 		cursor = cursor.node;
 
 	}
@@ -151,16 +152,17 @@ function isEffectivelyZero( node, epsilon = 1e-6 ) {
 
 }
 
-function isEffectivelyOne( node, epsilon = 1e-6 ) {
+// True when `node` has an authored value that differs from `target` (default 0),
+// i.e. it's worth wiring into the material instead of relying on the default.
+function isMeaningfulNode( node, target = 0 ) {
 
-	return isConstNear( node, 1, epsilon );
+	return hasNodeValue( node ) && isConstNear( node, target ) === false;
 
 }
 
 function isEnabledWeightNode( node ) {
 
-	if ( hasNodeValue( node ) === false ) return false;
-	return isEffectivelyZero( node ) === false;
+	return isMeaningfulNode( node );
 
 }
 
@@ -177,7 +179,7 @@ function setAnisotropy( material, strengthNode, rotationNode ) {
 
 function setTransmissionFlags( material, transmissionNode, opacityNode, allowOpacityTransparency = true ) {
 
-	if ( allowOpacityTransparency && hasNodeValue( opacityNode ) && isEffectivelyOne( opacityNode ) === false ) {
+	if ( allowOpacityTransparency && isMeaningfulNode( opacityNode, 1 ) ) {
 
 		material.transparent = true;
 
@@ -201,95 +203,43 @@ function toAttenuationDistance( distanceNode, hasAttenuationColorInput ) {
 
 }
 
-function buildGltfOpacityNode( alphaNode, alphaModeNode ) {
+// `inputs` includes the nodedef defaults, `authored` only the inputs present in the document.
+function applyStandardSurface( material, inputs, log, nodeName, authored ) {
 
-	const alphaMode = getConstNumber( alphaModeNode );
-	const roundedMode = alphaMode === null ? 2 : Math.round( alphaMode );
-	const alpha = alphaNode ?? float( 1 );
-
-	if ( roundedMode === 0 ) return float( 1 );
-	if ( roundedMode === 1 ) return alpha;
-	return alpha;
-
-}
-
-function applyStandardSurface( material, inputs, log, nodeName ) {
-
-	let colorNode = null;
-	if ( inputs.base && inputs.base_color ) colorNode = mul( inputs.base, inputs.base_color );
-	else if ( inputs.base ) colorNode = inputs.base;
-	else if ( inputs.base_color ) colorNode = inputs.base_color;
-
-	if ( inputs.coat_color ) {
-
-		colorNode = colorNode ? mul( colorNode, inputs.coat_color ) : colorNode;
-
-	}
-
-	const roughnessNode = inputs.specular_roughness;
-	const opacityNode = hasNodeValue( inputs.opacity ) ? element( inputs.opacity, 0 ) : undefined;
-	const transmissionNode = inputs.transmission;
-	const transmissionColorNode = inputs.transmission_color;
-	const transmissionEnabled = isEnabledWeightNode( transmissionNode );
+	const coatEnabled = isEnabledWeightNode( inputs.coat );
 	const sheenEnabled = isEnabledWeightNode( inputs.sheen );
-	const clearcoatEnabled = isEnabledWeightNode( inputs.coat );
-
-	let emissiveNode = inputs.emission;
-	const emissionColorNode = inputs.emission_color;
-	if ( hasNodeValue( emissionColorNode ) ) {
-
-		emissiveNode = emissiveNode ? mul( emissiveNode, emissionColorNode ) : emissionColorNode;
-
-	}
+	const transmissionEnabled = isEnabledWeightNode( inputs.transmission );
+	const thinFilmEnabled = isEnabledWeightNode( inputs.thin_film_thickness );
 
-	const thinFilmThicknessNode = inputs.thin_film_thickness;
-	const thinFilmIorNode = clamp( inputs.thin_film_IOR || float( 1.5 ), float( 1.0 ), float( 2.333 ) );
-	const thinFilmEnabled = isEnabledWeightNode( thinFilmThicknessNode );
-	const transmissionTintNode = hasNodeValue( transmissionColorNode ) ? transmissionColorNode : color( 1, 1, 1 );
+	let colorNode = mul( inputs.base, inputs.base_color );
+	if ( coatEnabled ) colorNode = mul( colorNode, inputs.coat_color );
 
 	if ( transmissionEnabled ) {
 
-		const baseForTransmissionMix = colorNode || color( 0.8, 0.8, 0.8 );
 		// Suppress diffuse/base tint as transmission ramps up.
-		colorNode = mix( baseForTransmissionMix, transmissionTintNode, transmissionNode );
+		colorNode = mix( colorNode, inputs.transmission_color, inputs.transmission );
 
 	}
 
-	material.colorNode = colorNode || color( 0.8, 0.8, 0.8 );
-	if ( hasNodeValue( opacityNode ) && isEffectivelyOne( opacityNode ) === false ) {
+	const opacityNode = element( inputs.opacity, 0 );
 
-		material.opacityNode = opacityNode;
+	material.colorNode = colorNode;
+	material.roughnessNode = inputs.specular_roughness;
+	material.specularColorNode = inputs.specular_color;
 
-	}
-
-	material.roughnessNode = roughnessNode || float( 0.2 );
-	if ( hasNodeValue( inputs.metalness ) && isEffectivelyZero( inputs.metalness ) === false ) {
-
-		material.metalnessNode = inputs.metalness;
-
-	}
-
-	if ( hasNodeValue( inputs.specular ) && isEffectivelyOne( inputs.specular ) === false ) {
-
-		material.specularIntensityNode = inputs.specular;
-
-	}
-
-	material.specularColorNode = inputs.specular_color || color( 1, 1, 1 );
-	const iorNode = inputs.specular_IOR;
-	if ( hasNodeValue( iorNode ) && isConstNear( iorNode, 1.5 ) === false ) {
-
-		material.iorNode = iorNode;
-
-	}
+	if ( isMeaningfulNode( opacityNode, 1 ) ) material.opacityNode = opacityNode;
+	if ( isMeaningfulNode( inputs.metalness ) ) material.metalnessNode = inputs.metalness;
+	if ( isMeaningfulNode( inputs.specular, 1 ) ) material.specularIntensityNode = inputs.specular;
+	if ( isMeaningfulNode( inputs.specular_IOR, 1.5 ) ) material.iorNode = inputs.specular_IOR;
 
 	setAnisotropy( material, inputs.specular_anisotropy, inputs.specular_rotation );
 
 	if ( transmissionEnabled ) {
 
-		material.transmissionNode = transmissionNode;
-		if ( hasNodeValue( transmissionColorNode ) ) material.transmissionColorNode = transmissionColorNode;
-		if ( hasNodeValue( inputs.transmission_depth ) && isEffectivelyZero( inputs.transmission_depth ) === false ) {
+		material.transmissionNode = inputs.transmission;
+		material.transmissionColorNode = inputs.transmission_color;
+
+		if ( isMeaningfulNode( inputs.transmission_depth ) ) {
 
 			material.thicknessNode = inputs.transmission_depth;
 
@@ -305,143 +255,97 @@ function applyStandardSurface( material, inputs, log, nodeName ) {
 
 	if ( thinFilmEnabled ) {
 
-		material.iridescenceThicknessNode = thinFilmThicknessNode;
-		material.iridescenceIORNode = thinFilmIorNode;
 		material.iridescenceNode = float( 1 );
+		material.iridescenceThicknessNode = inputs.thin_film_thickness;
+		material.iridescenceIORNode = clamp( inputs.thin_film_IOR, float( 1.0 ), float( 2.333 ) );
 
 	}
 
-	const sheenColor = inputs.sheen_color || color( 1, 1, 1 );
 	if ( sheenEnabled ) {
 
-		const sheenRoughness = hasNodeValue( inputs.sheen_roughness ) ? inputs.sheen_roughness : float( 0.3 );
-		material.sheenNode = mul( inputs.sheen, sheenColor );
-		material.sheenRoughnessNode = sheenRoughness;
+		material.sheenNode = mul( inputs.sheen, inputs.sheen_color );
+		material.sheenRoughnessNode = inputs.sheen_roughness;
 
 	}
 
-	if ( clearcoatEnabled ) {
+	if ( coatEnabled ) {
 
 		material.clearcoatNode = inputs.coat;
-		if ( hasNodeValue( inputs.coat_roughness ) ) {
-
-			material.clearcoatRoughnessNode = inputs.coat_roughness;
-
-		}
-
-	}
-
-	if ( clearcoatEnabled && hasNodeValue( inputs.coat_normal ) ) {
-
-		material.clearcoatNormalNode = transformNormalToView( inputs.coat_normal );
+		material.clearcoatRoughnessNode = inputs.coat_roughness;
+		if ( hasNodeValue( inputs.coat_normal ) ) material.clearcoatNormalNode = transformNormalToView( inputs.coat_normal );
 
 	}
 
 	if ( hasNodeValue( inputs.normal ) ) material.normalNode = transformNormalToView( inputs.normal );
-	if ( hasNodeValue( emissiveNode ) ) material.emissiveNode = emissiveNode;
+	if ( isEffectivelyZero( inputs.emission ) === false ) material.emissiveNode = mul( inputs.emission, inputs.emission_color );
 
-	setTransmissionFlags( material, transmissionNode, opacityNode );
-	warnIgnoredInputs( inputs, mappedStandardSurfaceInputs, log, 'standard_surface', nodeName );
+	setTransmissionFlags( material, inputs.transmission, opacityNode );
+	warnIgnoredInputs( authored, mappedStandardSurfaceInputs, log, 'standard_surface', nodeName );
 
 }
 
-function applyGltfPbrSurface( material, inputs, log, nodeName ) {
+function applyGltfPbrSurface( material, inputs, log, nodeName, authored ) {
 
+	// alpha_mode: 0 = OPAQUE, 1 = MASK, 2 = BLEND. A connected alpha_mode is treated as BLEND.
 	const alphaModeLiteral = getConstNumber( inputs.alpha_mode );
 	const alphaMode = alphaModeLiteral === null ? 2 : Math.round( alphaModeLiteral );
 	const isAlphaMaskMode = alphaMode === 1;
 	const isAlphaBlendMode = alphaMode === 2;
-	const opacityNode = buildGltfOpacityNode( inputs.alpha, inputs.alpha_mode );
-	const alphaCutoffNode = inputs.alpha_cutoff ?? float( 0.5 );
-	const hasAttenuationColorInput = Object.prototype.hasOwnProperty.call( inputs, 'attenuation_color' );
+	const opacityNode = alphaMode === 0 ? float( 1 ) : inputs.alpha;
+	const hasAttenuationColorInput = hasNodeValue( authored.attenuation_color );
 	const transmissionEnabled = isEnabledWeightNode( inputs.transmission );
 	const clearcoatEnabled = isEnabledWeightNode( inputs.clearcoat );
-	const sheenEnabled = hasNodeValue( inputs.sheen_color ) || isEnabledWeightNode( inputs.sheen_roughness );
+	const sheenEnabled = isMeaningfulNode( inputs.sheen_color ) || isEnabledWeightNode( inputs.sheen_roughness );
 	const iridescenceEnabled = isEnabledWeightNode( inputs.iridescence );
 
-	material.colorNode = inputs.base_color || color( 1, 1, 1 );
-	if ( hasNodeValue( inputs.occlusion ) ) material.aoNode = inputs.occlusion;
-	material.roughnessNode = inputs.roughness || float( 1 );
-	material.metalnessNode = inputs.metallic || float( 1 );
-	if ( hasNodeValue( inputs.specular ) && isEffectivelyOne( inputs.specular ) === false ) {
-
-		material.specularIntensityNode = inputs.specular;
-
-	}
-
-	material.specularColorNode = inputs.specular_color || color( 1, 1, 1 );
-	if ( hasNodeValue( inputs.ior ) && isConstNear( inputs.ior, 1.5 ) === false ) {
-
-		material.iorNode = inputs.ior;
-
-	}
-
-	if ( hasNodeValue( opacityNode ) && isEffectivelyOne( opacityNode ) === false ) {
+	material.colorNode = inputs.base_color;
+	material.roughnessNode = inputs.roughness;
+	material.metalnessNode = inputs.metallic;
+	material.specularColorNode = inputs.specular_color;
+	material.attenuationColorNode = inputs.attenuation_color;
+	material.attenuationDistanceNode = toAttenuationDistance( inputs.attenuation_distance, hasAttenuationColorInput );
 
-		material.opacityNode = opacityNode;
-
-	}
+	if ( isMeaningfulNode( inputs.occlusion, 1 ) ) material.aoNode = inputs.occlusion;
+	if ( isMeaningfulNode( inputs.specular, 1 ) ) material.specularIntensityNode = inputs.specular;
+	if ( isMeaningfulNode( inputs.ior, 1.5 ) ) material.iorNode = inputs.ior;
+	if ( isMeaningfulNode( opacityNode, 1 ) ) material.opacityNode = opacityNode;
 
 	if ( isAlphaMaskMode ) {
 
-		material.alphaTestNode = alphaCutoffNode;
-		const alphaCutoff = getConstNumber( alphaCutoffNode );
+		material.alphaTestNode = inputs.alpha_cutoff;
+		const alphaCutoff = getConstNumber( inputs.alpha_cutoff );
 		if ( alphaCutoff !== null ) material.alphaTest = alphaCutoff;
 
 	}
 
-	if ( transmissionEnabled ) {
-
-		material.transmissionNode = inputs.transmission;
-
-	}
+	if ( transmissionEnabled ) material.transmissionNode = inputs.transmission;
 
 	if ( clearcoatEnabled ) {
 
 		material.clearcoatNode = inputs.clearcoat;
-		if ( hasNodeValue( inputs.clearcoat_roughness ) && isEffectivelyZero( inputs.clearcoat_roughness ) === false ) {
-
-			material.clearcoatRoughnessNode = inputs.clearcoat_roughness;
-
-		}
+		material.clearcoatRoughnessNode = inputs.clearcoat_roughness;
+		if ( hasNodeValue( inputs.clearcoat_normal ) ) material.clearcoatNormalNode = transformNormalToView( inputs.clearcoat_normal );
 
 	}
 
 	if ( sheenEnabled ) {
 
-		const sheenColor = hasNodeValue( inputs.sheen_color ) ? inputs.sheen_color : color( 0, 0, 0 );
-		const sheenRoughness = hasNodeValue( inputs.sheen_roughness ) ? inputs.sheen_roughness : float( 0 );
-		material.sheenRoughnessNode = sheenRoughness;
-		material.sheenNode = sheenColor;
+		material.sheenNode = inputs.sheen_color;
+		material.sheenRoughnessNode = inputs.sheen_roughness;
 
 	}
 
 	if ( iridescenceEnabled ) {
 
 		material.iridescenceNode = inputs.iridescence;
-		if ( hasNodeValue( inputs.iridescence_ior ) && isConstNear( inputs.iridescence_ior, 1.3 ) === false ) {
-
-			material.iridescenceIORNode = inputs.iridescence_ior;
-
-		}
-
-		if ( hasNodeValue( inputs.iridescence_thickness ) && isConstNear( inputs.iridescence_thickness, 100 ) === false ) {
-
-			material.iridescenceThicknessNode = inputs.iridescence_thickness;
-
-		}
+		material.iridescenceIORNode = inputs.iridescence_ior;
+		material.iridescenceThicknessNode = inputs.iridescence_thickness;
 
 	}
 
-	material.attenuationDistanceNode = toAttenuationDistance( inputs.attenuation_distance, hasAttenuationColorInput );
-	material.attenuationColorNode = inputs.attenuation_color || color( 1, 1, 1 );
-	if ( hasNodeValue( inputs.thickness ) ) {
-
-		if ( isEffectivelyZero( inputs.thickness ) === false ) {
+	if ( isMeaningfulNode( inputs.thickness ) ) {
 
-			material.thicknessNode = inputs.thickness;
-
-		}
+		material.thicknessNode = inputs.thickness;
 
 	} else if ( transmissionEnabled ) {
 
@@ -450,184 +354,182 @@ function applyGltfPbrSurface( material, inputs, log, nodeName ) {
 
 	}
 
-	if ( hasNodeValue( inputs.dispersion ) && isEffectivelyZero( inputs.dispersion ) === false ) {
+	if ( isMeaningfulNode( inputs.dispersion ) ) material.dispersionNode = inputs.dispersion;
 
-		material.dispersionNode = inputs.dispersion;
-
-	}
-
-	const anisotropyStrength = inputs.anisotropy_strength;
-	const anisotropyRotation = inputs.anisotropy_rotation;
-	setAnisotropy( material, anisotropyStrength, anisotropyRotation );
+	setAnisotropy( material, inputs.anisotropy_strength, inputs.anisotropy_rotation );
 
 	if ( hasNodeValue( inputs.normal ) ) material.normalNode = transformNormalToView( inputs.normal );
-	if ( hasNodeValue( inputs.clearcoat_normal ) ) {
-
-		material.clearcoatNormalNode = transformNormalToView( inputs.clearcoat_normal );
-
-	}
-
-	if ( hasNodeValue( inputs.emissive ) && hasNodeValue( inputs.emissive_strength ) )
-		material.emissiveNode = mul( inputs.emissive, inputs.emissive_strength );
-	else if ( hasNodeValue( inputs.emissive ) ) material.emissiveNode = inputs.emissive;
+	if ( isEffectivelyZero( inputs.emissive ) === false ) material.emissiveNode = mul( inputs.emissive, inputs.emissive_strength );
 
 	setTransmissionFlags( material, inputs.transmission, opacityNode, isAlphaBlendMode );
-	warnIgnoredInputs( inputs, mappedGltfPbrInputs, log, 'gltf_pbr', nodeName );
+	warnIgnoredInputs( authored, mappedGltfPbrInputs, log, 'gltf_pbr', nodeName );
 
 }
 
-function applyOpenPbrSurface( material, inputs, log, nodeName ) {
+function applyOpenPbrSurface( material, inputs, log, nodeName, authored ) {
 
-	const baseWeight = inputs.base_weight || float( 1 );
-	const baseColor = inputs.base_color || color( 0.8, 0.8, 0.8 );
 	const coatEnabled = isEnabledWeightNode( inputs.coat_weight );
 	const fuzzEnabled = isEnabledWeightNode( inputs.fuzz_weight );
 	const transmissionEnabled = isEnabledWeightNode( inputs.transmission_weight );
 	const thinFilmEnabled = isEnabledWeightNode( inputs.thin_film_weight );
-	material.colorNode = mul( baseWeight, baseColor );
 
-	if ( hasNodeValue( inputs.base_metalness ) && isEffectivelyZero( inputs.base_metalness ) === false ) {
+	material.colorNode = mul( inputs.base_weight, inputs.base_color );
+	material.roughnessNode = inputs.specular_roughness;
+	material.specularColorNode = inputs.specular_color;
 
-		material.metalnessNode = inputs.base_metalness;
+	if ( isMeaningfulNode( inputs.base_metalness ) ) material.metalnessNode = inputs.base_metalness;
+	if ( isMeaningfulNode( inputs.specular_weight, 1 ) ) material.specularIntensityNode = inputs.specular_weight;
+	if ( isMeaningfulNode( inputs.specular_ior, 1.5 ) ) material.iorNode = inputs.specular_ior;
 
-	}
+	setAnisotropy( material, inputs.specular_roughness_anisotropy, float( 0 ) );
 
-	material.roughnessNode = inputs.specular_roughness || float( 0.3 );
-	if ( hasNodeValue( inputs.specular_weight ) && isEffectivelyOne( inputs.specular_weight ) === false ) {
+	if ( coatEnabled ) {
 
-		material.specularIntensityNode = inputs.specular_weight;
+		// Scale the coat weight by the coat's Fresnel reflectance at normal incidence relative
+		// to the fixed F0 of 0.04 that the three.js clearcoat model assumes.
+		const coatF0Node = inputs.coat_ior.sub( float( 1 ) ).div( inputs.coat_ior.add( float( 1 ) ) );
+		const normalizedClearcoatNode = coatF0Node.mul( coatF0Node ).div( float( 0.04 ) );
+		material.clearcoatNode = clamp( inputs.coat_weight.mul( normalizedClearcoatNode ), float( 0 ), float( 1 ) );
+		material.clearcoatRoughnessNode = inputs.coat_roughness;
+		if ( hasNodeValue( inputs.geometry_coat_normal ) ) material.clearcoatNormalNode = transformNormalToView( inputs.geometry_coat_normal );
 
 	}
 
-	material.specularColorNode = inputs.specular_color || color( 1, 1, 1 );
-	const openPbrIorNode = inputs.specular_ior;
-	if ( hasNodeValue( openPbrIorNode ) && isConstNear( openPbrIorNode, 1.5 ) === false ) {
+	if ( fuzzEnabled ) {
 
-		material.iorNode = openPbrIorNode;
+		material.sheenNode = mul( inputs.fuzz_weight, inputs.fuzz_color );
+		material.sheenRoughnessNode = pow( inputs.fuzz_roughness, float( 1.5 ) );
 
 	}
 
-	setAnisotropy( material, inputs.specular_roughness_anisotropy, float( 0 ) );
+	if ( transmissionEnabled ) {
 
-	if ( coatEnabled ) {
+		material.transmissionNode = inputs.transmission_weight;
+		material.attenuationColorNode = inputs.transmission_color;
 
-		const coatWeightNode = inputs.coat_weight || float( 0 );
-		if ( hasNodeValue( inputs.coat_ior ) ) {
+		if ( isMeaningfulNode( inputs.transmission_depth ) ) {
 
-			const coatIorNode = inputs.coat_ior;
-			const coatIorMinusOne = coatIorNode.sub( float( 1 ) );
-			const coatIorPlusOne = coatIorNode.add( float( 1 ) );
-			const coatF0Node = coatIorMinusOne.div( coatIorPlusOne );
-			const normalizedClearcoatNode = coatF0Node.mul( coatF0Node ).div( float( 0.04 ) );
-			material.clearcoatNode = clamp( coatWeightNode.mul( normalizedClearcoatNode ), float( 0 ), float( 1 ) );
+			material.thicknessNode = hasNodeValue( inputs.geometry_thin_walled )
+				? inputs.geometry_thin_walled.select( float( 0 ), inputs.transmission_depth )
+				: inputs.transmission_depth;
+			material.attenuationDistanceNode = inputs.transmission_depth;
 
 		} else {
 
-			material.clearcoatNode = coatWeightNode;
+			// Keep transmissive OpenPBR materials volumetric even when depth is omitted.
+			material.thickness = 1;
 
 		}
 
-		if ( hasNodeValue( inputs.coat_roughness ) && isEffectivelyZero( inputs.coat_roughness ) === false ) {
+		if ( isMeaningfulNode( inputs.transmission_dispersion_scale ) ) {
 
-			material.clearcoatRoughnessNode = inputs.coat_roughness;
+			material.dispersionNode = inputs.transmission_dispersion_scale.mul( float( 20 ) ).div( inputs.transmission_dispersion_abbe_number );
 
 		}
 
-		if ( hasNodeValue( inputs.geometry_coat_normal ) ) {
+	}
 
-			material.clearcoatNormalNode = transformNormalToView( inputs.geometry_coat_normal );
+	if ( isMeaningfulNode( inputs.geometry_opacity, 1 ) ) material.opacityNode = inputs.geometry_opacity;
+	if ( hasNodeValue( inputs.geometry_normal ) ) material.normalNode = transformNormalToView( inputs.geometry_normal );
 
-		}
+	if ( thinFilmEnabled ) {
+
+		material.iridescenceNode = inputs.thin_film_weight;
+		// OpenPBR thin film thickness is in micrometers, three.js expects nanometers.
+		material.iridescenceThicknessNode = inputs.thin_film_thickness.mul( float( 1000 ) );
+		material.iridescenceIORNode = inputs.thin_film_ior;
 
 	}
 
-	const fuzzWeight = inputs.fuzz_weight || float( 0 );
-	const fuzzColor = inputs.fuzz_color || color( 1, 1, 1 );
-	if ( fuzzEnabled ) {
+	if ( isEffectivelyZero( inputs.emission_luminance ) === false ) material.emissiveNode = mul( inputs.emission_color, inputs.emission_luminance );
 
-		material.sheenNode = mul( fuzzWeight, fuzzColor );
-		if ( hasNodeValue( inputs.fuzz_roughness ) ) {
+	if ( isMeaningfulNode( inputs.geometry_opacity, 1 ) ) material.transparent = true;
+	if ( transmissionEnabled ) material.transparent = true;
 
-			material.sheenRoughnessNode = pow( inputs.fuzz_roughness, float( 1.5 ) );
+	setTransmissionFlags( material, inputs.transmission_weight, inputs.geometry_opacity );
+	warnIgnoredInputs( authored, mappedOpenPbrInputs, log, 'open_pbr_surface', nodeName );
 
-		}
+}
 
-	}
+// <displacement> maps onto vertex displacement like MeshStandardMaterial.displacementMap:
+// scalar displacement moves along the normal, vector displacement is authored in
+// (dPdu, dPdv, N) tangent space. `inputTypes` tells the two nodedefs apart.
+function applyDisplacement( material, inputs, log, nodeName, authored, inputTypes = {} ) {
 
-	if ( transmissionEnabled ) {
+	const displacementNode = inputs.displacement;
+	if ( ! hasNodeValue( displacementNode ) || isEffectivelyZero( displacementNode ) ) return;
 
-		material.transmissionNode = inputs.transmission_weight;
-		if ( hasNodeValue( inputs.transmission_color ) ) material.attenuationColorNode = inputs.transmission_color;
+	const scaleNode = hasNodeValue( inputs.scale ) ? inputs.scale : float( 1 );
+	let offsetNode;
 
-	}
+	if ( inputTypes.displacement === 'vector3' ) {
 
-	const transmissionDepthNode = inputs.transmission_depth;
-	if ( transmissionEnabled && hasNodeValue( transmissionDepthNode ) && isEffectivelyZero( transmissionDepthNode ) === false ) {
+		const vector = vec3( displacementNode ).mul( scaleNode );
 
-		material.thicknessNode = hasNodeValue( inputs.geometry_thin_walled )
-			? inputs.geometry_thin_walled.select( float( 0 ), transmissionDepthNode )
-			: transmissionDepthNode;
-		material.attenuationDistanceNode = transmissionDepthNode;
+		// tangentLocal/bitangentLocal need a tangent attribute; without one the
+		// bitangent is NaN, so fall back to displacing along the normal only.
+		offsetNode = Fn( ( builder ) => {
 
-	} else if ( transmissionEnabled ) {
+			if ( builder.geometry.hasAttribute( 'tangent' ) ) {
 
-		// Keep transmissive OpenPBR materials volumetric even when depth is omitted.
-		material.thickness = 1;
+				return tangentLocal.mul( vector.x ).add( bitangentLocal.mul( vector.y ) ).add( normalLocal.mul( vector.z ) );
 
-	}
+			}
 
-	const transmissionDispersionAbbe = inputs.transmission_dispersion_abbe_number || float( 20 );
-	if ( transmissionEnabled && hasNodeValue( inputs.transmission_dispersion_scale ) && isEffectivelyZero( inputs.transmission_dispersion_scale ) === false ) {
+			return normalLocal.normalize().mul( vector.z );
 
-		material.dispersionNode = inputs.transmission_dispersion_scale.mul( float( 20 ) ).div( transmissionDispersionAbbe );
+		} )();
 
-	}
+	} else {
 
-	if ( hasNodeValue( inputs.geometry_opacity ) && isEffectivelyOne( inputs.geometry_opacity ) === false ) {
-
-		material.opacityNode = inputs.geometry_opacity;
+		offsetNode = normalLocal.normalize().mul( float( displacementNode ).mul( scaleNode ) );
 
 	}
 
-	if ( hasNodeValue( inputs.geometry_normal ) ) material.normalNode = transformNormalToView( inputs.geometry_normal );
-
-	if ( thinFilmEnabled ) {
+	material.positionNode = positionLocal.add( offsetNode );
 
-		material.iridescenceNode = inputs.thin_film_weight;
-		if ( hasNodeValue( inputs.thin_film_thickness ) && isConstNear( inputs.thin_film_thickness, 0.5 ) === false ) {
-
-			material.iridescenceThicknessNode = inputs.thin_film_thickness.mul( float( 1000 ) );
+}
 
-		}
+const mappedSurfaceUnlitInputs = new Set( [ 'emission', 'emission_color', 'transmission', 'transmission_color', 'opacity' ] );
 
-		if ( hasNodeValue( inputs.thin_film_ior ) && isConstNear( inputs.thin_film_ior, 1.4 ) === false ) {
+// <surface_unlit> renders without lighting (MeshBasicNodeMaterial). MaterialX computes
+// color = emission * emission_color * opacity and transparency = mix( 1, transmission * transmission_color, opacity ),
+// and the result is color + transparency * background: blending ( One, OneMinusSrcAlpha ) with
+// alpha = 1 - transparency. A colored transmission becomes grey, since blending has one alpha.
+function applySurfaceUnlit( material, inputs, log, nodeName, authored ) {
 
-			material.iridescenceIORNode = inputs.thin_film_ior;
+	const emission = inputs.emission;
+	const emissionColor = inputs.emission_color;
+	const opacity = inputs.opacity;
 
-		}
+	material.colorNode = mul( mul( emissionColor, emission ), opacity );
 
-	}
+	if ( isMeaningfulNode( inputs.opacity, 1 ) || isEnabledWeightNode( inputs.transmission ) ) {
 
-	const emissionColor = hasNodeValue( inputs.emission_color ) ? inputs.emission_color : color( 1, 1, 1 );
-	const emissionLuminance = hasNodeValue( inputs.emission_luminance ) ? inputs.emission_luminance : float( 0 );
-	if ( isEffectivelyZero( emissionLuminance ) === false ) {
+		const transmission = inputs.transmission;
+		const transmissionColor = inputs.transmission_color;
+		const transparency = mix( vec3( 1, 1, 1 ), mul( transmissionColor, transmission ), opacity );
 
-		material.emissiveNode = mul( emissionColor, emissionLuminance );
+		material.opacityNode = sub( 1, dot( transparency, vec3( 1 / 3, 1 / 3, 1 / 3 ) ) );
+		material.transparent = true;
+		// The color is already multiplied by the opacity.
+		material.blending = CustomBlending;
+		material.blendEquation = AddEquation;
+		material.blendSrc = OneFactor;
+		material.blendDst = OneMinusSrcAlphaFactor;
 
 	}
 
-	if ( hasNodeValue( inputs.geometry_opacity ) && isEffectivelyOne( inputs.geometry_opacity ) === false ) material.transparent = true;
-	if ( transmissionEnabled ) material.transparent = true;
-
-	setTransmissionFlags( material, inputs.transmission_weight, inputs.geometry_opacity );
-	warnIgnoredInputs( inputs, mappedOpenPbrInputs, log, 'open_pbr_surface', nodeName );
+	warnIgnoredInputs( authored, mappedSurfaceUnlitInputs, log, 'surface_unlit', nodeName );
 
 }
 
 const MaterialXSurfaceMappings = {
+	surface_unlit: applySurfaceUnlit,
 	standard_surface: applyStandardSurface,
 	gltf_pbr: applyGltfPbrSurface,
 	open_pbr_surface: applyOpenPbrSurface,
+	displacement: applyDisplacement,
 };
 
 const surfaceMapperRegistry = new Map( Object.entries( MaterialXSurfaceMappings ).map( ( [ category, apply ] ) => [
@@ -655,6 +557,8 @@ export {
 	applyStandardSurface,
 	applyGltfPbrSurface,
 	applyOpenPbrSurface,
+	applyDisplacement,
+	applySurfaceUnlit,
 	mappedStandardSurfaceInputs,
 	mappedGltfPbrInputs,
 	mappedOpenPbrInputs,