rayzee 7.22.8 → 7.23.0

package/package.json

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

package/src/EngineDefaults.js

@@ -524,6 +524,11 @@ export const MATERIAL_DATA_LAYOUT = {
 
 };
 
+// glTF/three.js spell "no volume absorption" as attenuationDistance = Infinity, while the GPU
+// contract is `> 0 = on` (calculateBeerLawAbsorption). Every writer into ATTENUATION_DISTANCE
+// collapses both spellings to 0 so no shader divides by Inf.
+export const normalizeAttenuationDistance = d => ( Number.isFinite( d ) && d > 0 ? d : 0 );
+
 // BVH node leaf markers
 export const BVH_LEAF_MARKERS = {
 	TRIANGLE_LEAF: - 1, // Leaf containing triangle references

package/src/PathTracerApp.js

@@ -2104,6 +2104,18 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/**
+	 * Read back the scalar material property the shader is actually using.
+	 * @param {number} materialIndex
+	 * @param {string} property
+	 * @returns {number|undefined}
+	 */
+	getMaterialProperty( materialIndex, property ) {
+
+		return this.stages.pathTracer?.materialData.getMaterialProperty( materialIndex, property );
+
+	}
+
 	setMaterialProperty( materialIndex, property, value ) {
 
 		this.stages.pathTracer?.materialData.updateMaterialProperty( materialIndex, property, value );

package/src/Processor/GeometryExtractor.js

@@ -373,20 +373,12 @@ export class GeometryExtractor {
 		const materialType = this.getMaterialType( material );
 		const legacyMapping = this.mapLegacyMaterialToPhysical( material, materialType );
 
-		// Determine if material should be treated as dielectric or metallic
+		// A transmissive surface is a dielectric interface whose IOR drives refraction, so it wins
+		// over the metal Fresnel hack: glTF defaults metallicFactor to 1, which otherwise stamps
+		// 2.5 onto water/glass authored as MeshStandardMaterial.
+		const isTransmissive = ( material.transmission ?? 0.0 ) > 0.0;
 		const isMetallic = ( material.metalness ?? legacyMapping.metalness ?? 0.0 ) > 0.1;
-
-		// Set appropriate IOR based on material type
-		let defaultIOR = defaults.ior;
-		if ( isMetallic ) {
-
-			defaultIOR = 2.5; // Typical metallic IOR
-
-		} else if ( material.transmission > 0.0 ) {
-
-			defaultIOR = 1.5; // Glass-like for transmissive materials
-
-		}
+		const defaultIOR = ( isMetallic && ! isTransmissive ) ? 2.5 : defaults.ior;
 
 		// Handle color conversion for different material types
 		let baseColor = material.color || new Color( 0xffffff );

package/src/Processor/TextureCreator.js

@@ -1,5 +1,5 @@
 import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace, RepeatWrapping } from "three";
-import { TEXTURE_CONSTANTS, MEMORY_CONSTANTS, DEFAULT_TEXTURE_MATRIX, MATERIAL_DATA_LAYOUT } from '../EngineDefaults.js';
+import { TEXTURE_CONSTANTS, MEMORY_CONSTANTS, DEFAULT_TEXTURE_MATRIX, MATERIAL_DATA_LAYOUT, normalizeAttenuationDistance } from '../EngineDefaults.js';
 import TexturesWorker from './Workers/TexturesWorker.js?worker&inline';
 
 // Canvas pooling for efficient reuse of canvas elements
@@ -948,7 +948,7 @@ export class TextureCreator {
 				// Slot 0: shadow core (ior, transmission, thickness, emissiveIntensity)
 				mat.ior, 					mat.transmission, 			mat.thickness, 				mat.emissiveIntensity,
 				// Slot 1: shadow (attenuationColor, attenuationDistance)
-				mat.attenuationColor.r, 	mat.attenuationColor.g, 	mat.attenuationColor.b, 	mat.attenuationDistance,
+				mat.attenuationColor.r, 	mat.attenuationColor.g, 	mat.attenuationColor.b, 	normalizeAttenuationDistance( mat.attenuationDistance ),
 				// Slot 2: shadow + culling (opacity, side, transparent, alphaTest)
 				mat.opacity, 				mat.side, 					mat.transparent, 			mat.alphaTest,
 				// Slot 3: shadow (alphaMode, depthWrite, normalScale)

package/src/Stages/NormalDepth.js

@@ -8,7 +8,7 @@ import { Ray, HitInfo, RayTracingMaterial, UVCache } from '../TSL/Struct.js';
 import { traverseBVH } from '../TSL/BVHTraversal.js';
 import { cameraRayDirection } from '../TSL/CameraRay.js';
 import { getMaterial } from '../TSL/Common.js';
-import { computeUVCache, processNormal, processBump, buildBucketTextureNodes, refreshBucketTextureNodes, setMaterialBucketTextures } from '../TSL/TextureSampling.js';
+import { computeUVCache, processNormal, processBump, triangleUVTangent, buildBucketTextureNodes, refreshBucketTextureNodes, setMaterialBucketTextures } from '../TSL/TextureSampling.js';
 
 /**
  * NormalDepth — primary-ray G-buffer for SVGF gates.
@@ -263,7 +263,16 @@ export class NormalDepth extends RenderStage {
 						getMaterial( hit.materialIndex, matStorage )
 					).toVar();
 					const uvCache = UVCache.wrap( computeUVCache( hit.uv, material ) ).toVar();
-					const mapped = processNormal( hit.normal, material, uvCache ).toVar();
+					// Same UV tangent frame the Shade kernel uses, or the aux normal disagrees
+					// with the shading normal it is supposed to guide the denoiser with.
+					const uvTangent = vec4( 0.0 ).toVar();
+					If( material.normalMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+						uvTangent.assign( triangleUVTangent( triStorage, hit.triangleIndex, hit.normal, material.normalTransform ) );
+
+					} );
+
+					const mapped = processNormal( hit.normal, material, uvCache, uvTangent ).toVar();
 					shadingNormal.assign( processBump( mapped, material, uvCache ) );
 
 				} );

package/src/TSL/Debugger.js

@@ -202,7 +202,7 @@ export const TraceDebugMode = Fn( ( [
 
 			// Sample all textures to get emissive
 			const matSamples = MaterialSamples.wrap( sampleAllMaterialTextures(
-				material, hitInfo.uv, hitInfo.normal,
+				material, hitInfo.uv, hitInfo.normal, vec4( 0.0 ),
 			) ).toVar();
 
 			const emissiveColor = matSamples.emissive.toVar();
@@ -246,7 +246,7 @@ export const TraceDebugMode = Fn( ( [
 
 			// Get material-mapped normal (same as what's used in main shader)
 			const matSamples = MaterialSamples.wrap( sampleAllMaterialTextures(
-				material, hitInfo.uv, hitInfo.normal,
+				material, hitInfo.uv, hitInfo.normal, vec4( 0.0 ),
 			) ).toVar();
 
 			const worldNormal = normalize( matSamples.normal );
@@ -292,7 +292,7 @@ export const TraceDebugMode = Fn( ( [
 			const material = RayTracingMaterial.wrap( getMaterial( hitInfo.materialIndex, materialBuffer ) ).toVar();
 
 			const matSamples = MaterialSamples.wrap( sampleAllMaterialTextures(
-				material, hitInfo.uv, hitInfo.normal,
+				material, hitInfo.uv, hitInfo.normal, vec4( 0.0 ),
 			) ).toVar();
 
 			const objectColor = matSamples.albedo.rgb;
@@ -318,7 +318,7 @@ export const TraceDebugMode = Fn( ( [
 			// Get primary surface material
 			const material = RayTracingMaterial.wrap( getMaterial( hitInfo.materialIndex, materialBuffer ) ).toVar();
 			const matSamples = MaterialSamples.wrap( sampleAllMaterialTextures(
-				material, hitInfo.uv, hitInfo.normal,
+				material, hitInfo.uv, hitInfo.normal, vec4( 0.0 ),
 			) ).toVar();
 
 			const albedoA = matSamples.albedo.rgb;
@@ -364,7 +364,7 @@ export const TraceDebugMode = Fn( ( [
 				// Bounce hit surface B — evaluate its contribution
 				const materialB = RayTracingMaterial.wrap( getMaterial( bounceHit.materialIndex, materialBuffer ) ).toVar();
 				const matSamplesB = MaterialSamples.wrap( sampleAllMaterialTextures(
-					materialB, bounceHit.uv, bounceHit.normal,
+					materialB, bounceHit.uv, bounceHit.normal, vec4( 0.0 ),
 				) ).toVar();
 
 				// Emissive contribution from surface B

package/src/TSL/MaterialTransmission.js

@@ -141,57 +141,16 @@ export const sampleWavelengthForDispersion = Fn( ( [ baseIOR, dispersionStrength
 // ABSORPTION
 // ================================================================================
 
-// Apply Beer's law absorption
+// Beer-Lambert transmittance over pathLength. attenuationDistance <= 0 (or non-finite,
+// normalized to 0 by MaterialDataManager) means "no absorption".
 export const calculateBeerLawAbsorption = /*@__PURE__*/ wgslFn( `
-	fn calculateBeerLawAbsorption( attenuationColor: vec3f, attenuationDistance: f32, thickness: f32 ) -> vec3f {
+	fn calculateBeerLawAbsorption( attenuationColor: vec3f, attenuationDistance: f32, pathLength: f32 ) -> vec3f {
 		if ( attenuationDistance <= 0.0f ) { return vec3f( 1.0f ); }
-		// Convert RGB attenuation color to absorption coefficients
 		let absorption = -log( max( attenuationColor, vec3f( 0.001f ) ) ) / attenuationDistance;
-		// Apply Beer's law
-		return exp( -absorption * thickness );
+		return exp( -absorption * pathLength );
 	}
 ` );
 
-// ================================================================================
-// SHADOW TRANSMITTANCE
-// ================================================================================
-
-export const calculateShadowTransmittance = Fn( ( [ rayDir, normal, material, entering ] ) => {
-
-	const n1 = select( entering, float( 1.0 ), material.ior ).toVar();
-	const n2 = select( entering, material.ior, float( 1.0 ) ).toVar();
-
-	const cosThetaI = abs( dot( normal, rayDir ) );
-	const sinThetaT2 = n1.mul( n1 ).div( n2.mul( n2 ) ).mul( float( 1.0 ).sub( cosThetaI.mul( cosThetaI ) ) );
-
-	// Handle total internal reflection
-	const result = float( 0.0 ).toVar();
-
-	If( sinThetaT2.lessThanEqual( 1.0 ), () => {
-
-		// Calculate Fresnel reflectance
-		const F0 = iorToFresnel0( n2, n1 );
-		const Fr = fresnelSchlickFloat( cosThetaI, F0 );
-
-		// Base transmission: what gets through after Fresnel reflection
-		const baseTransmission = float( 1.0 ).sub( Fr ).mul( material.transmission ).toVar();
-
-		// Apply Beer's law absorption for exiting rays
-		If( entering.not().and( material.attenuationDistance.greaterThan( 0.0 ) ), () => {
-
-			const absorption = calculateBeerLawAbsorption( { attenuationColor: material.attenuationColor, attenuationDistance: material.attenuationDistance, thickness: material.thickness } );
-			baseTransmission.assign( baseTransmission.mul( absorption.x.add( absorption.y ).add( absorption.z ).div( 3.0 ) ) );
-
-		} );
-
-		result.assign( clamp( baseTransmission, 0.0, 1.0 ) );
-
-	} );
-
-	return result;
-
-} );
-
 // ================================================================================
 // MICROFACET TRANSMISSION
 // ================================================================================

package/src/TSL/ShadeKernel.js

@@ -17,7 +17,7 @@ import {
 import { sampleEnvironment, sampleEquirectProbability, sampleEquirect, groundProjectedEnvDir } from './Environment.js';
 import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial } from './Common.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
-import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, getTransformedUV } from './TextureSampling.js';
+import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, getTransformedUV, triangleUVTangent } from './TextureSampling.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import { calculateDirectLightingUnified, calculateMaterialPDF } from './LightsSampling.js';
 import { traceShadowRay, calculateRayOffset } from './LightsDirect.js';
@@ -616,8 +616,17 @@ export function buildShadeKernel( params ) {
 			}
 		);
 
+		// Normal-map tangent frame. Only paid for when there is a normal map: the arbitrary
+		// cross(up, N) fallback inside processNormal is what runs otherwise.
+		const uvTangent = vec4( 0.0 ).toVar();
+		If( material.normalMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+			uvTangent.assign( triangleUVTangent( triangleBuffer, int( hitTriIdx ), N, material.normalTransform ) );
+
+		} );
+
 		const matSamples = MaterialSamples.wrap( sampleAllMaterialTextures(
-			material, samplingUV, N,
+			material, samplingUV, N, uvTangent,
 		) ).toVar();
 
 		// DDFA: snapshot the UNCLAMPED roughness (before the min-0.05 clamp below) for the specular↔diffuse

package/src/TSL/TextureSampling.js

@@ -1,4 +1,4 @@
-import { Fn, wgslFn, float, vec2, vec3, vec4, int, If, normalize, cross, abs, atan, mix, clamp, texture, textureSize } from 'three/tsl';
+import { Fn, wgslFn, float, vec2, vec3, vec4, int, If, normalize, cross, dot, length, sign, abs, atan, mix, clamp, texture, textureSize } from 'three/tsl';
 import { DataArrayTexture, LinearFilter } from 'three';
 
 import {
@@ -6,6 +6,7 @@ import {
 	MaterialSamples,
 	ExtMapResult,
 } from './Struct.js';
+import { getDatafromStorageBuffer } from './Common.js';
 import { TEXTURE_CONSTANTS } from '../EngineDefaults.js';
 
 // ================================================================================
@@ -382,7 +383,80 @@ export const processMetalnessRoughness = Fn( ( [ material, uvCache ] ) => {
 
 } );
 
-export const processNormal = Fn( ( [ geometryNormal, material, uvCache ] ) => {
+// (t[1][1], t[0][1]) — the row of the inverse 2x2 linear part that maps dP/du onto dP/du',
+// up to the determinant, which drops out under the normalize that follows.
+const uvTransformJacobian = /*@__PURE__*/ wgslFn( `
+	fn uvTransformJacobian( t: mat3x3f ) -> vec2f {
+		return vec2f( t[1][1], t[0][1] );
+	}
+` );
+
+/**
+ * Build the UV tangent for one triangle, as vec4( T.xyz, handedness ).
+ *
+ * Returned in the *transformed* UV space of `transform`, since that is the space the normal
+ * map is sampled in — the inverse of the transform's 2x2 linear part maps dP/du back onto
+ * dP/du'. A pure repeat/scale leaves the direction alone; a rotated transform does not.
+ * w == 0 signals a degenerate parameterisation, which processNormal treats as "no frame".
+ *
+ * @param {Node} triangleBuffer packed triangle storage (8 vec4 stride)
+ * @param {Node} triIndex       absolute triangle index
+ * @param {Node} geometryNormal shading-space normal, for the handedness test
+ * @param {Node} transform      the normal map's mat3 UV transform
+ */
+export const triangleUVTangent = Fn( ( [ triangleBuffer, triIndex, geometryNormal, transform ] ) => {
+
+	const S = int( 8 );
+	const pA = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 0 ), S ).xyz;
+	const e1 = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 1 ), S ).xyz.sub( pA );
+	const e2 = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 2 ), S ).xyz.sub( pA );
+
+	const uvAB = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 6 ), S );
+	const uvC = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 7 ), S ).xy;
+	const d1 = uvAB.zw.sub( uvAB.xy );
+	const d2 = uvC.sub( uvAB.xy );
+
+	const det = d1.x.mul( d2.y ).sub( d1.y.mul( d2.x ) );
+	const result = vec4( 0.0 ).toVar();
+
+	If( abs( det ).greaterThan( 1e-12 ), () => {
+
+		const r = float( 1.0 ).div( det );
+		const T = e1.mul( d2.y ).sub( e2.mul( d1.y ) ).mul( r ).toVar();
+		const B = e2.mul( d1.x ).sub( e1.mul( d2.x ) ).mul( r ).toVar();
+
+		// Re-express in the map's transformed UV space (inverse of the 2x2 linear part).
+		const uvJ = uvTransformJacobian( { t: transform } );
+		const Tt = T.mul( uvJ.x ).sub( B.mul( uvJ.y ) ).toVar();
+
+		If( length( Tt ).greaterThan( 1e-12 ), () => {
+
+			T.assign( Tt );
+
+		} );
+
+		If( length( T ).greaterThan( 1e-12 ), () => {
+
+			result.assign( vec4( normalize( T ), sign( dot( cross( geometryNormal, T ), B ) ) ) );
+
+		} );
+
+	} );
+
+	return result;
+
+} );
+
+/**
+ * Per-triangle tangent frame from the UV parameterisation.
+ *
+ * `uvTangent` is vec4( T.xyz, handedness ); w == 0 means "no usable frame" (degenerate or
+ * missing UVs) and falls back to the arbitrary cross(up, N) frame. A frame unrelated to the
+ * texture's U axis rotates the whole perturbation: on a vertical fluted-glass panel the
+ * arbitrary frame comes out 90 deg off, so the rib normals tilt up/down instead of across
+ * the ribs.
+ */
+export const processNormal = Fn( ( [ geometryNormal, material, uvCache, uvTangent ] ) => {
 
 	const result = geometryNormal.toVar();
 
@@ -393,10 +467,25 @@ export const processNormal = Fn( ( [ geometryNormal, material, uvCache ] ) => {
 		normalMap.x.mulAssign( material.normalScale.x );
 		normalMap.y.assign( normalMap.y.negate().mul( material.normalScale.x ) );
 
-		// Fast TBN construction
-		const up = abs( geometryNormal.z ).lessThan( 0.999 ).select( vec3( 0.0, 0.0, 1.0 ), vec3( 1.0, 0.0, 0.0 ) );
-		const tangent = normalize( cross( up, geometryNormal ) );
-		const bitangent = cross( geometryNormal, tangent );
+		const tangent = vec3( 0.0 ).toVar();
+		const handedness = float( 1.0 ).toVar();
+
+		// Gram-Schmidt against the interpolated normal, which is not exactly triangle-planar.
+		const perp = uvTangent.xyz.sub( geometryNormal.mul( dot( geometryNormal, uvTangent.xyz ) ) ).toVar();
+
+		If( abs( uvTangent.w ).greaterThan( 0.5 ).and( length( perp ).greaterThan( 1e-6 ) ), () => {
+
+			tangent.assign( normalize( perp ) );
+			handedness.assign( uvTangent.w );
+
+		} ).Else( () => {
+
+			const up = abs( geometryNormal.z ).lessThan( 0.999 ).select( vec3( 0.0, 0.0, 1.0 ), vec3( 1.0, 0.0, 0.0 ) );
+			tangent.assign( normalize( cross( up, geometryNormal ) ) );
+
+		} );
+
+		const bitangent = cross( geometryNormal, tangent ).mul( handedness );
 
 		result.assign( normalize(
 			tangent.mul( normalMap.x ).add( bitangent.mul( normalMap.y ) ).add( geometryNormal.mul( normalMap.z ) )
@@ -563,7 +652,7 @@ export const processEmissive = Fn( ( [ material, uvCache ] ) => {
 // MAIN BATCHED SAMPLING FUNCTION
 // ================================================================================
 
-export const sampleAllMaterialTextures = Fn( ( [ material, uv, geometryNormal ] ) => {
+export const sampleAllMaterialTextures = Fn( ( [ material, uv, geometryNormal, uvTangent ] ) => {
 
 	const albedo = vec4( 0.0 ).toVar();
 	const emissive = vec3( 0.0 ).toVar();
@@ -591,7 +680,7 @@ export const sampleAllMaterialTextures = Fn( ( [ material, uv, geometryNormal ]
 		metalness.assign( metalRough.x );
 		roughness.assign( metalRough.y );
 
-		const currentNormal = processNormal( geometryNormal, material, uvCache ).toVar();
+		const currentNormal = processNormal( geometryNormal, material, uvCache, uvTangent ).toVar();
 		normal.assign( processBump( currentNormal, material, uvCache ) );
 
 		emissive.assign( processEmissive( material, uvCache ) );

package/src/managers/MaterialDataManager.js

@@ -9,7 +9,7 @@
 
 import { StorageInstancedBufferAttribute } from 'three/webgpu';
 import { storage } from 'three/tsl';
-import { MATERIAL_DATA_LAYOUT as M, TRIANGLE_DATA_LAYOUT as T } from '../EngineDefaults.js';
+import { MATERIAL_DATA_LAYOUT as M, TRIANGLE_DATA_LAYOUT as T, normalizeAttenuationDistance } from '../EngineDefaults.js';
 import { createLogger, fmt } from '../utils/Logger.js';
 
 const log = createLogger( 'material' );
@@ -23,6 +23,32 @@ const TRI_BLOCKER_OFFSET = T.NORMAL_A_OFFSET + 3; // nA.w in shader (opaque-bloc
 // Material properties that affect the shadow-ray opaque-blocker flag.
 const BLOCKER_PROPS = new Set( [ 'transmission', 'transparent', 'opacity', 'alphaMode' ] );
 
+// Scalar slots readable via getMaterialProperty().
+const SCALAR_PROPERTY_OFFSETS = {
+	ior: M.IOR,
+	transmission: M.TRANSMISSION,
+	thickness: M.THICKNESS,
+	emissiveIntensity: M.EMISSIVE_INTENSITY,
+	attenuationDistance: M.ATTENUATION_DISTANCE,
+	opacity: M.OPACITY,
+	alphaTest: M.ALPHA_TEST,
+	metalness: M.METALNESS,
+	roughness: M.ROUGHNESS,
+	clearcoat: M.CLEARCOAT,
+	clearcoatRoughness: M.CLEARCOAT_ROUGHNESS,
+	dispersion: M.DISPERSION,
+	sheen: M.SHEEN,
+	sheenRoughness: M.SHEEN_ROUGHNESS,
+	specularIntensity: M.SPECULAR_INTENSITY,
+	iridescence: M.IRIDESCENCE,
+	iridescenceIOR: M.IRIDESCENCE_IOR,
+	subsurface: M.SUBSURFACE,
+	subsurfaceRadiusScale: M.SUBSURFACE_RADIUS_SCALE,
+	subsurfaceAnisotropy: M.SUBSURFACE_ANISOTROPY,
+	anisotropy: M.ANISOTROPY,
+	anisotropyRotation: M.ANISOTROPY_ROTATION, // radians, unlike the degrees hosts usually show
+};
+
 export class MaterialDataManager {
 
 	/**
@@ -179,6 +205,28 @@ export class MaterialDataManager {
 
 	// ===== MATERIAL PROPERTY UPDATES =====
 
+	/**
+	 * Read back a scalar material property from the storage buffer — the value the shader
+	 * actually uses. Hosts need this because the engine resolves defaults the three.js
+	 * material never carries (e.g. IOR on a MeshStandardMaterial), so a UI that falls back
+	 * to its own default displays a number the renderer is not using.
+	 * @param {number} materialIndex
+	 * @param {string} property
+	 * @returns {number|undefined} undefined if unavailable or not a scalar slot
+	 */
+	getMaterialProperty( materialIndex, property ) {
+
+		const data = this.materialStorageAttr?.array;
+		if ( ! data ) return undefined;
+
+		const offset = SCALAR_PROPERTY_OFFSETS[ property ];
+		if ( offset === undefined ) return undefined;
+
+		const index = materialIndex * M.FLOATS_PER_MATERIAL + offset;
+		return index < data.length ? data[ index ] : undefined;
+
+	}
+
 	/**
 	 * Update a single material property in the storage buffer.
 	 * @param {number} materialIndex
@@ -253,7 +301,7 @@ export class MaterialDataManager {
 				}
 
 				break;
-			case 'attenuationDistance': data[ stride + M.ATTENUATION_DISTANCE ] = value; break;
+			case 'attenuationDistance': data[ stride + M.ATTENUATION_DISTANCE ] = normalizeAttenuationDistance( value ); break;
 			case 'dispersion': data[ stride + M.DISPERSION ] = value; break;
 			case 'sheen': data[ stride + M.SHEEN ] = value; break;
 			case 'sheenRoughness': data[ stride + M.SHEEN_ROUGHNESS ] = value; break;
@@ -446,7 +494,7 @@ export class MaterialDataManager {
 
 		}
 
-		data[ stride + M.ATTENUATION_DISTANCE ] = materialData.attenuationDistance ?? Infinity;
+		data[ stride + M.ATTENUATION_DISTANCE ] = normalizeAttenuationDistance( materialData.attenuationDistance );
 		data[ stride + M.DISPERSION ] = materialData.dispersion ?? 0;
 		data[ stride + M.VISIBLE ] = 1; // Reserved slot (per-mesh visibility handled at BLAS-pointer level)
 		data[ stride + M.SHEEN ] = materialData.sheen ?? 0;