rayzee 7.22.9 → 7.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.22.9",
+  "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/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/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;