rayzee 5.4.1 → 5.4.3

package/src/managers/MaterialDataManager.js

@@ -9,9 +9,16 @@
 
 import { StorageInstancedBufferAttribute } from 'three/webgpu';
 import { storage } from 'three/tsl';
-import { TEXTURE_CONSTANTS, MATERIAL_DATA_LAYOUT as M } from '../EngineDefaults.js';
+import { MATERIAL_DATA_LAYOUT as M, TRIANGLE_DATA_LAYOUT as T } from '../EngineDefaults.js';
 
 const PIXELS_PER_MATERIAL = M.SLOTS_PER_MATERIAL;
+// Per-triangle float offsets used by _patchTriangleSideForMaterial / _patchTriangleBlockerForMaterial.
+const TRI_MAT_IDX_OFFSET = T.UV_C_MAT_OFFSET + 2; // uvData2.z in shader
+const TRI_SIDE_OFFSET = T.NORMAL_C_OFFSET + 3; // normalCData.w in shader
+const TRI_BLOCKER_OFFSET = T.NORMAL_A_OFFSET + 3; // nA.w in shader (opaque-blocker fast path)
+
+// Material properties that affect the shadow-ray opaque-blocker flag.
+const BLOCKER_PROPS = new Set( [ 'transmission', 'transparent', 'opacity', 'alphaMode' ] );
 
 export class MaterialDataManager {
 
@@ -41,7 +48,7 @@ export class MaterialDataManager {
 
 		/**
 		 * Optional callbacks set by the owning stage.
-		 * @type {{ onReset?: Function, onFeaturesChanged?: Function }}
+		 * @type {{ onReset?: Function, onFeaturesChanged?: Function, getTriangleData?: Function, onTriangleDataChanged?: Function }}
 		 */
 		this.callbacks = {};
 
@@ -275,7 +282,11 @@ export class MaterialDataManager {
 			case 'clearcoat': data[ stride + M.CLEARCOAT ] = value; break;
 			case 'clearcoatRoughness': data[ stride + M.CLEARCOAT_ROUGHNESS ] = value; break;
 			case 'opacity': data[ stride + M.OPACITY ] = value; break;
-			case 'side': data[ stride + M.SIDE ] = value; break;
+			case 'side': data[ stride + M.SIDE ] = value;
+				// Side is also mirrored into per-triangle data (NORMAL_C.w) so BVH
+				// traversal can do side culling without reading the material buffer.
+				this._patchTriangleSideForMaterial( materialIndex, value );
+				break;
 			case 'transparent': data[ stride + M.TRANSPARENT ] = value; break;
 			case 'alphaTest': data[ stride + M.ALPHA_TEST ] = value; break;
 			case 'alphaMode': data[ stride + M.ALPHA_MODE ] = value; break;
@@ -304,6 +315,13 @@ export class MaterialDataManager {
 
 		this.materialStorageAttr.needsUpdate = true;
 
+		// Recompute triangle-data opaque-blocker flag when any input to it changes.
+		if ( BLOCKER_PROPS.has( property ) ) {
+
+			this._recomputeOpaqueBlockerForMaterial( materialIndex );
+
+		}
+
 		const featureProperties = [ 'transmission', 'clearcoat', 'sheen', 'iridescence', 'dispersion', 'transparent', 'opacity', 'alphaTest' ];
 		if ( featureProperties.includes( property ) ) {
 
@@ -414,6 +432,10 @@ export class MaterialDataManager {
 		data[ stride + M.CLEARCOAT_ROUGHNESS ] = materialData.clearcoatRoughness ?? 0;
 		data[ stride + M.OPACITY ] = materialData.opacity ?? 1;
 		data[ stride + M.SIDE ] = materialData.side ?? 0;
+		// Mirror side into per-triangle data so BVH traversal avoids a material-buffer read.
+		this._patchTriangleSideForMaterial( materialIndex, materialData.side ?? 0 );
+		// Recompute shadow-ray opaque-blocker flag (reads alphaMode/transparent/transmission/opacity from buffer).
+		this._recomputeOpaqueBlockerForMaterial( materialIndex );
 		data[ stride + M.TRANSPARENT ] = materialData.transparent ?? 0;
 		data[ stride + M.ALPHA_TEST ] = materialData.alphaTest ?? 0;
 		data[ stride + M.ALPHA_MODE ] = materialData.alphaMode ?? 0;
@@ -657,6 +679,74 @@ export class MaterialDataManager {
 
 	}
 
+	/**
+	 * Rewrite the per-triangle `side` flag (NORMAL_C.w) for every triangle whose
+	 * materialIndex matches. Linear over triangles because there's no reverse
+	 * index — side edits are a rare UI action so the scan cost is acceptable.
+	 * @private
+	 */
+	/**
+	 * Re-derive the shadow-ray opaque-blocker flag for a material from its
+	 * current buffer values and patch NORMAL_A.w on every matching triangle.
+	 * Kept in sync with the blocker definition in GeometryExtractor.
+	 * @private
+	 */
+	_recomputeOpaqueBlockerForMaterial( materialIndex ) {
+
+		const matBuf = this.materialStorageAttr?.array;
+		if ( ! matBuf ) return;
+
+		const matStride = materialIndex * M.FLOATS_PER_MATERIAL;
+		const alphaMode = matBuf[ matStride + M.ALPHA_MODE ] | 0;
+		const transparent = matBuf[ matStride + M.TRANSPARENT ] | 0;
+		const transmission = matBuf[ matStride + M.TRANSMISSION ] || 0;
+		const opacity = matBuf[ matStride + M.OPACITY ] ?? 1;
+		const isOpaqueBlocker = ( alphaMode === 0 && transparent === 0 && transmission === 0 && opacity >= 1 ) ? 1.0 : 0.0;
+
+		this._patchTriangleFlagForMaterial( materialIndex, TRI_BLOCKER_OFFSET, isOpaqueBlocker );
+
+	}
+
+	/**
+	 * Generic helper: patch a single per-triangle float at `triOffset` for every
+	 * triangle whose materialIndex matches, then fire onTriangleDataChanged.
+	 * @private
+	 */
+	_patchTriangleFlagForMaterial( materialIndex, triOffset, value ) {
+
+		const triInfo = this.callbacks.getTriangleData?.();
+		const triData = triInfo?.array;
+		const triCount = triInfo?.count | 0;
+		if ( ! triData || triCount === 0 ) return;
+
+		const stride = T.FLOATS_PER_TRIANGLE;
+		let patched = 0;
+		for ( let i = 0; i < triCount; i ++ ) {
+
+			const base = i * stride;
+			if ( triData[ base + TRI_MAT_IDX_OFFSET ] === materialIndex ) {
+
+				triData[ base + triOffset ] = value;
+				patched ++;
+
+			}
+
+		}
+
+		if ( patched > 0 && this.callbacks.onTriangleDataChanged ) {
+
+			this.callbacks.onTriangleDataChanged();
+
+		}
+
+	}
+
+	_patchTriangleSideForMaterial( materialIndex, sideValue ) {
+
+		this._patchTriangleFlagForMaterial( materialIndex, TRI_SIDE_OFFSET, sideValue );
+
+	}
+
 	// ===== DISPOSAL =====
 
 	dispose() {