rayzee 7.22.9 → 7.23.1

package/package.json

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

@@ -63,6 +63,21 @@ const _appsByCanvas = new WeakMap();
 
 const log = createLogger( 'engine' );
 
+/**
+ * Attaches the device-lost handler at module scope so the reaction closure captures only
+ * `holder` — an arrow written inside a method would share that method's context and pin
+ * the app through `this`. See _initRenderer().
+ */
+function attachDeviceLostHandler( device, holder ) {
+
+	device.lost.then( ( info ) => {
+
+		if ( holder.app ) holder.app._handleDeviceLost( info );
+
+	} );
+
+}
+
 export class PathTracerApp extends EventDispatcher {
 
 	/**
@@ -169,6 +184,8 @@ export class PathTracerApp extends EventDispatcher {
 		this._trackedListeners = [];
 		this._disposed = false;
 		this._deviceLost = false;
+		this._gpuDevice = null;
+		this._deviceLostHolder = null;
 
 		// Deterministic-render mode — see setDeterministicMode()
 		this._deterministic = false;
@@ -539,6 +556,24 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		// Value of a WeakMap keyed by a canvas that outlives us: without this the whole
+		// disposed graph stays reachable until another app claims the same canvas.
+		if ( this.canvas && _appsByCanvas.get( this.canvas ) === this ) _appsByCanvas.delete( this.canvas );
+
+		if ( this._gpuDevice ) {
+
+			this._gpuDevice.onuncapturederror = null;
+			this._gpuDevice = null;
+
+		}
+
+		if ( this._deviceLostHolder ) {
+
+			this._deviceLostHolder.app = null;
+			this._deviceLostHolder = null;
+
+		}
+
 		disposeRenderer( this.renderer );
 		this.renderer = null;
 
@@ -2104,6 +2139,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 );
@@ -2307,15 +2354,21 @@ export class PathTracerApp extends EventDispatcher {
 		// Detect GPU device loss (dGPU/iGPU switch, driver reset, TDR watchdog on heavy
 		// compute). Without this the rAF loop keeps calling render() on a dead device,
 		// spewing errors forever. reason 'destroyed' during dispose() is intentional teardown.
+		//
+		// Neither handler may outlive dispose() still holding this app. The device itself does
+		// outlive it: three's RenderObjects.dispose() drops its chain maps without disposing
+		// the render objects, and its Textures manager leaves a listener on every module-level
+		// texture singleton, so backend and device stay reachable for the page's lifetime. A
+		// handler capturing `this` therefore pinned the whole app graph — ~120 MiB of triangle,
+		// BVH and CPU-side texture data per create/dispose cycle. `lost` is a pending promise
+		// whose reaction cannot be unregistered, so it reads the app out of a holder that
+		// dispose() empties; `onuncapturederror` is cleared there directly.
 		const gpuDevice = this.renderer.backend?.device;
 		if ( gpuDevice?.lost ) {
 
-			gpuDevice.lost.then( ( info ) => {
-
-				if ( this._disposed ) return;
-				this._handleDeviceLost( info );
-
-			} );
+			this._gpuDevice = gpuDevice;
+			this._deviceLostHolder = { app: this };
+			attachDeviceLostHandler( gpuDevice, this._deviceLostHolder );
 			gpuDevice.onuncapturederror = ( event ) => log.error( 'WebGPU uncaptured error:', event.error );
 
 		}

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/Processor/utils.js

@@ -1,6 +1,10 @@
 import { SphereGeometry, Mesh, MeshPhysicalMaterial, Group, Object3D, Color, Vector3, ShaderMaterial, Vector2, Matrix4, GLSL3 } from 'three';
+import { QuadMesh } from 'three/webgpu';
 import { EngineEvents } from '../EngineEvents.js';
 
+/** Every QuadMesh in the realm shares this one geometry (module-level in three). */
+const _sharedQuadGeometry = /*@__PURE__*/ new QuadMesh( null ).geometry;
+
 let _statusCallback = null;
 
 /**
@@ -130,6 +134,18 @@ export function disposeRenderer( renderer ) {
 	renderer.dispose();
 	renderer._canvasTarget = null;
 
+	// Three.js 0.185: `RenderObjects.dispose()` drops its chain maps without disposing the
+	// render objects, so each one leaves behind the 'dispose' listener it registered on its
+	// geometry. Full-screen passes render a QuadMesh, and every QuadMesh in the realm shares
+	// one module-level geometry — so that listener list grows by one entry per renderer and
+	// keeps RenderObject → RenderObjects → Bindings → Backend → GPUDevice reachable for the
+	// page's lifetime. The chain maps are WeakMaps, so this list is the only handle on them.
+	//
+	// Clearing it also drops entries belonging to live renderers, which is safe: the
+	// singleton geometry is never disposed, so none of these listeners can ever fire.
+	const quadDisposeListeners = _sharedQuadGeometry._listeners?.dispose;
+	if ( quadDisposeListeners ) quadDisposeListeners.length = 0;
+
 }
 
 export function disposeObjectFromMemory( object, exeptions = [] ) {

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;