rayzee 5.0.2 → 5.1.1

package/src/TSL/BVHTraversal.js

@@ -25,7 +25,6 @@ import {
 	array,
 } from 'three/tsl';
 
-import { struct } from './structProxy.js';
 import { Ray, HitInfo } from './Struct.js';
 import { getDatafromStorageBuffer, MATERIAL_SLOTS } from './Common.js';
 import { RandomPointInCircle } from './Random.js';
@@ -34,14 +33,6 @@ import { RandomPointInCircle } from './Random.js';
 // STRUCTS
 // ================================================================================
 
-// Combined visibility data structure
-export const VisibilityData = struct( {
-	visible: 'bool',
-	side: 'int',
-	transparent: 'bool',
-	opacity: 'float'
-} );
-
 // ================================================================================
 // CONSTANTS
 // ================================================================================
@@ -52,6 +43,20 @@ const BVH_STRIDE = 4;
 const TRI_STRIDE = 8;
 const HUGE_VAL = 1e8;
 
+// Per-mesh visibility buffer (set by ShaderBuilder before graph construction)
+let _meshVisibilityBuffer = null;
+
+/**
+ * Set the per-mesh visibility storage buffer node.
+ * Must be called before the shader graph is constructed (i.e., before setupCompute).
+ * @param {StorageNode} buffer - TSL storage node indexed by meshIndex
+ */
+export function setMeshVisibilityBuffer( buffer ) {
+
+	_meshVisibilityBuffer = buffer;
+
+}
+
 // ================================================================================
 // STACK HELPERS (Native WGSL array via TSL ArrayNode)
 // ================================================================================
@@ -127,48 +132,17 @@ const fastRayAABBDst = wgslFn( `
 // VISIBILITY FUNCTIONS
 // ================================================================================
 
-// Fetch all visibility data in 2 reads
-export const getVisibilityData = Fn( ( [ materialIndex, materialBuffer ] ) => {
+// Side culling — 1 buffer read (slot 10 only)
+// Per-mesh visibility handled at BLAS-pointer level; material visibility always 1.
+export const passesSideCulling = Fn( ( [ materialIndex, rayDirection, normal, materialBuffer ] ) => {
 
-	// Read visibility flag from slot 4
-	const visData = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 4 ), int( MATERIAL_SLOTS ) );
-	// Read side and transparency data from slot 10
 	const sideData = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 10 ), int( MATERIAL_SLOTS ) );
-
-	return VisibilityData( {
-		visible: visData.g.greaterThan( 0.5 ),
-		opacity: sideData.r,
-		side: int( sideData.g ),
-		transparent: sideData.b.greaterThan( 0.5 ),
-	} );
-
-} );
-
-// Fast visibility check using material texture
-export const isTriangleVisible = Fn( ( [ materialIndex, materialBuffer ] ) => {
-
-	const visData = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 4 ), int( MATERIAL_SLOTS ) );
-	return visData.g.greaterThan( 0.5 );
-
-} );
-
-// Complete visibility check with side culling
-export const isMaterialVisibleOptimized = wgslFn( `
-	fn isMaterialVisibleOptimized( visible: bool, side: i32, rayDirection: vec3f, normal: vec3f ) -> bool {
-		if ( !visible ) { return false; }
-		let rayDotNormal = dot( rayDirection, normal );
-		let doubleSide = side == 2;
-		let frontSide  = side == 0 && rayDotNormal < -0.0001f;
-		let backSide   = side == 1 && rayDotNormal > 0.0001f;
-		return doubleSide || frontSide || backSide;
-	}
-` );
-
-// Single visibility check with combined data fetch
-export const isMaterialVisible = Fn( ( [ materialIndex, rayDirection, normal, materialBuffer ] ) => {
-
-	const vis = VisibilityData.wrap( getVisibilityData( materialIndex, materialBuffer ) );
-	return isMaterialVisibleOptimized( { visible: vis.visible, side: vis.side, rayDirection, normal } );
+	const side = int( sideData.g );
+	const rayDotNormal = rayDirection.dot( normal );
+	const doubleSide = side.equal( int( 2 ) );
+	const frontSide = side.equal( int( 0 ) ).and( rayDotNormal.lessThan( - 0.0001 ) );
+	const backSide = side.equal( int( 1 ) ).and( rayDotNormal.greaterThan( 0.0001 ) );
+	return doubleSide.or( frontSide ).or( backSide );
 
 } );
 
@@ -269,28 +243,23 @@ export const traverseBVH = Fn( ( [
 
 						const matIdx = int( uvData2.z );
 
-						// Early material rejection
-						If( isTriangleVisible( matIdx, materialBuffer ), () => {
+						// Interpolate normal
+						const w = float( 1.0 ).sub( u ).sub( v );
+						const normal = normalize( nA.mul( w ).add( nB.mul( u ) ).add( nC.mul( v ) ) ).toVar();
 
-							// Interpolate normal
-							const w = float( 1.0 ).sub( u ).sub( v );
-							const normal = normalize( nA.mul( w ).add( nB.mul( u ) ).add( nC.mul( v ) ) ).toVar();
+						// Side culling check (per-mesh visibility handled at BLAS-pointer level)
+						If( passesSideCulling( matIdx, rayDirection, normal, materialBuffer ), () => {
 
-							// Full material visibility check (culling etc)
-							If( isMaterialVisible( matIdx, rayDirection, normal, materialBuffer ), () => {
-
-								closestHit.didHit.assign( true );
-								closestHit.dst.assign( t );
-								closestHit.normal.assign( normal );
-								closestHit.materialIndex.assign( matIdx );
-								closestHit.meshIndex.assign( int( uvData2.w ) );
-
-								// Defer hitPoint + UV computation to post-traversal
-								closestTriIdx.assign( triIndex );
-								closestU.assign( u );
-								closestV.assign( v );
+							closestHit.didHit.assign( true );
+							closestHit.dst.assign( t );
+							closestHit.normal.assign( normal );
+							closestHit.materialIndex.assign( matIdx );
+							closestHit.meshIndex.assign( int( uvData2.w ) );
 
-							} );
+							// Defer hitPoint + UV computation to post-traversal
+							closestTriIdx.assign( triIndex );
+							closestU.assign( u );
+							closestV.assign( v );
 
 						} );
 
@@ -299,7 +268,7 @@ export const traverseBVH = Fn( ( [
 				} );
 
 				// If we found a very close hit, we can terminate early
-				If( closestHit.didHit.and( closestHit.dst.lessThan( 0.001 ) ), () => {
+				If( closestHit.didHit.and( closestHit.dst.lessThan( 1e-6 ) ), () => {
 
 					Break();
 
@@ -308,13 +277,34 @@ export const traverseBVH = Fn( ( [
 			} ).Else( () => {
 
 				// BLAS-pointer leaf (marker -2) — push BLAS root node onto stack
+				// nodeData0: [blasRootNodeIndex, meshIndex, 0, -2]
 				const blasRoot = int( nodeData0.x ).toVar();
-				If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
 
-					stack.element( stackPtr ).assign( blasRoot );
-					stackPtr.addAssign( 1 );
+				if ( _meshVisibilityBuffer ) {
 
-				} );
+					// Per-mesh visibility check — skip entire BLAS if mesh is hidden
+					// getDatafromStorageBuffer( buffer, stride=1, sampleIndex=meshIdx, dataOffset=0 )
+					const meshIdx = int( nodeData0.y ).toVar();
+					const meshVis = getDatafromStorageBuffer( _meshVisibilityBuffer, int( 1 ), meshIdx, int( 0 ) ).x;
+
+					If( meshVis.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				} else {
+
+					// No visibility buffer — push unconditionally (original behavior)
+					If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				}
 
 			} );
 
@@ -390,7 +380,7 @@ export const traverseBVHShadow = Fn( ( [
 	ray,
 	bvhBuffer,
 	triangleBuffer,
-	materialBuffer,
+	_materialBuffer, // eslint-disable-line no-unused-vars -- kept for call-site compatibility
 	maxShadowDist,
 ] ) => {
 
@@ -448,25 +438,21 @@ export const traverseBVHShadow = Fn( ( [
 
 					If( triResult.w.greaterThan( 0.5 ), () => {
 
+						// Per-mesh visibility handled at BLAS-pointer level — accept any hit
 						const uvData2 = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 7 ), int( TRI_STRIDE ) );
-						const matIdx = int( uvData2.z );
-
-						If( isTriangleVisible( matIdx, materialBuffer ), () => {
-
-							closestHit.didHit.assign( true );
-							closestHit.dst.assign( triResult.x );
-							closestHit.materialIndex.assign( matIdx );
-							closestHit.meshIndex.assign( int( uvData2.w ) );
 
-							// Compute hit point and geometric normal -- required for transmissive
-							// Fresnel in traceShadowRay (cosThetaI needs a real normal, not vec3(0))
-							closestHit.hitPoint.assign( ray.origin.add( ray.direction.mul( triResult.x ) ) );
-							closestHit.normal.assign( normalize( cross( pB.sub( pA ), pC.sub( pA ) ) ) );
+						closestHit.didHit.assign( true );
+						closestHit.dst.assign( triResult.x );
+						closestHit.materialIndex.assign( int( uvData2.z ) );
+						closestHit.meshIndex.assign( int( uvData2.w ) );
 
-							// Shadow ray only needs any hit — skip remaining triangles in leaf
-							Break();
+						// Compute hit point and geometric normal -- required for transmissive
+						// Fresnel in traceShadowRay (cosThetaI needs a real normal, not vec3(0))
+						closestHit.hitPoint.assign( ray.origin.add( ray.direction.mul( triResult.x ) ) );
+						closestHit.normal.assign( normalize( cross( pB.sub( pA ), pC.sub( pA ) ) ) );
 
-						} );
+						// Shadow ray only needs any hit — skip remaining triangles in leaf
+						Break();
 
 					} );
 
@@ -475,13 +461,34 @@ export const traverseBVHShadow = Fn( ( [
 			} ).Else( () => {
 
 				// BLAS-pointer leaf (marker -2) — push BLAS root node onto stack
+				// nodeData0: [blasRootNodeIndex, meshIndex, 0, -2]
 				const blasRoot = int( nodeData0.x ).toVar();
-				If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
 
-					stack.element( stackPtr ).assign( blasRoot );
-					stackPtr.addAssign( 1 );
+				if ( _meshVisibilityBuffer ) {
 
-				} );
+					// Per-mesh visibility check — skip entire BLAS if mesh is hidden
+					// getDatafromStorageBuffer( buffer, stride=1, sampleIndex=meshIdx, dataOffset=0 )
+					const meshIdx = int( nodeData0.y ).toVar();
+					const meshVis = getDatafromStorageBuffer( _meshVisibilityBuffer, int( 1 ), meshIdx, int( 0 ) ).x;
+
+					If( meshVis.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				} else {
+
+					// No visibility buffer — push unconditionally (original behavior)
+					If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				}
 
 			} );
 

package/src/TSL/Common.js

@@ -353,7 +353,6 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 		attenuationColor: data3.rgb,
 		attenuationDistance: data3.a,
 		dispersion: data4.r,
-		visible: data4.g,
 		sheen: data4.b,
 		sheenRoughness: data4.a,
 		sheenColor: data5.rgb,

package/src/TSL/Debugger.js

@@ -356,7 +356,8 @@ export const TraceDebugMode = Fn( ( [
 			const bounceDir = cosineWeightedSample( { N: normalA, xi } ).toVar();
 
 			// Trace secondary ray from the hit point (offset along normal to avoid self-intersection)
-			const bounceOrigin = hitInfo.hitPoint.add( normalA.mul( 0.001 ) ).toVar();
+			const debugEps = max( float( 1e-4 ), length( hitInfo.hitPoint ).mul( 1e-6 ) );
+			const bounceOrigin = hitInfo.hitPoint.add( normalA.mul( debugEps ) ).toVar();
 			const bounceRay = Ray( { origin: bounceOrigin, direction: bounceDir } );
 
 			const bounceHit = HitInfo.wrap( traverseBVH(

package/src/TSL/LightsCore.js

@@ -257,7 +257,7 @@ export const intersectAreaLight = Fn( ( [ light, rayOrigin, rayDirection ] ) =>
 		const t = dot( light.position.sub( rayOrigin ), normal ).mul( invDenom ).toVar();
 
 		// Skip intersections behind the ray
-		If( t.greaterThan( 0.001 ), () => {
+		If( t.greaterThan( 1e-5 ), () => {
 
 			// Optimized rectangle test using vector rejection
 			const hitPoint = rayOrigin.add( rayDirection.mul( t ) );

package/src/TSL/LightsDirect.js

@@ -142,8 +142,9 @@ export const traceShadowRay = Fn( ( [
 			} );
 
 			// Continue ray past transmissive surface
-			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( 0.001 ) ) );
-			remainingDist.subAssign( shadowHit.dst.add( 0.001 ) );
+			const transEps = max( float( 1e-5 ), length( shadowHit.hitPoint ).mul( 1e-6 ) );
+			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( transEps ) ) );
+			remainingDist.subAssign( shadowHit.dst.add( transEps ) );
 
 		} ).ElseIf( shadowMaterial.transparent, () => {
 
@@ -158,8 +159,9 @@ export const traceShadowRay = Fn( ( [
 			} );
 
 			// Continue ray past transparent surface
-			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( 0.001 ) ) );
-			remainingDist.subAssign( shadowHit.dst.add( 0.001 ) );
+			const alphaEps = max( float( 1e-5 ), length( shadowHit.hitPoint ).mul( 1e-6 ) );
+			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( alphaEps ) ) );
+			remainingDist.subAssign( shadowHit.dst.add( alphaEps ) );
 
 		} ).Else( () => {
 
@@ -257,7 +259,7 @@ export const estimateLightImportance = Fn( ( [ light, hitPoint, normal, material
 
 		If( lightFacing.greaterThan( 0.0 ), () => {
 
-			const solidAngle = light.area.div( max( distSq, 0.1 ) );
+			const solidAngle = light.area.div( max( distSq, 1e-4 ) );
 			const power = light.intensity.mul( dot( light.color, REC709_LUMINANCE_COEFFICIENTS ) ).mul( light.area );
 
 			// Material-aware weighting
@@ -659,7 +661,7 @@ export const calculatePointLightContribution = Fn( ( [
 			const rayOffset = calculateRayOffset( hitPoint, normal, material );
 			const rayOrigin = hitPoint.add( rayOffset );
 
-			const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.sub( 0.001 ), rngState );
+			const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.mul( 0.999 ), rngState );
 
 			If( visibility.greaterThan( 0.0 ), () => {
 
@@ -711,7 +713,7 @@ export const calculateSpotLightContribution = Fn( ( [
 				const rayOffset = calculateRayOffset( hitPoint, normal, material );
 				const rayOrigin = hitPoint.add( rayOffset );
 
-				const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.sub( 0.001 ), rngState );
+				const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.mul( 0.999 ), rngState );
 
 				If( visibility.greaterThan( 0.0 ), () => {
 

package/src/TSL/LightsSampling.js

@@ -71,6 +71,7 @@ import {
 	calculatePointLightImportance,
 	calculateSpotLightImportance,
 	traceShadowRay,
+	calculateRayOffset,
 } from './LightsDirect.js';
 
 import { traverseBVHShadow } from './BVHTraversal.js';
@@ -940,7 +941,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 ] ) => {
 
 	const totalContribution = vec3( 0.0 ).toVar();
-	const rayOrigin = hitPoint.add( hitNormal.mul( 0.001 ) ).toVar();
+	const rayOrigin = hitPoint.add( calculateRayOffset( hitPoint, hitNormal, material ) ).toVar();
 
 	// Early exit for highly emissive surfaces
 	If( material.emissiveIntensity.lessThanEqual( 10.0 ), () => {
@@ -1041,7 +1042,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 				If( NoL.greaterThan( 0.0 ).and( lightImportance.mul( NoL ).greaterThan( importanceThreshold ) ).and( isDirectionValid( { direction: lightSample.direction, surfaceNormal: hitNormal } ) ), () => {
 
-					const shadowDistance = min( lightSample.distance.sub( 0.001 ), float( 1000.0 ) ).toVar();
+					const shadowDistance = min( lightSample.distance.mul( 0.999 ), float( 1000.0 ) ).toVar();
 					const visibility = traceShadowRay(
 						rayOrigin, lightSample.direction, shadowDistance, rngState,
 						traverseBVHShadow,

package/src/TSL/PathTracerCore.js

@@ -880,7 +880,8 @@ export const Trace = Fn( ( [
 			// For transmission: offset along the old ray direction to push through the surface
 			const reflectOffsetDir = select( interaction.entering, N, N.negate() );
 			const offsetDir = select( interaction.didReflect, reflectOffsetDir, rayDirection );
-			rayOrigin.assign( hitInfo.hitPoint.add( offsetDir.mul( 0.001 ) ) );
+			const bounceEps = max( float( 1e-4 ), length( hitInfo.hitPoint ).mul( 1e-6 ) );
+			rayOrigin.assign( hitInfo.hitPoint.add( offsetDir.mul( bounceEps ) ) );
 			rayDirection.assign( interaction.direction );
 
 			stateIsPrimaryRay.assign( tslBool( false ) );
@@ -1054,7 +1055,7 @@ export const Trace = Fn( ( [
 
 						const rayOffset = calculateRayOffset( hitInfo.hitPoint, N, material );
 						const rayOrigin = hitInfo.hitPoint.add( rayOffset );
-						const shadowDist = emissiveSample.distance.sub( 0.001 );
+						const shadowDist = emissiveSample.distance.mul( 0.999 );
 						const visibility = traceShadowRayWrapped( rayOrigin, emissiveSample.direction, shadowDist, rngState );
 
 						If( visibility.greaterThan( 0.0 ), () => {
@@ -1137,7 +1138,7 @@ export const Trace = Fn( ( [
 		throughput.mulAssign( indirectResult.throughput );
 
 		// Prepare for next bounce
-		rayOrigin.assign( hitInfo.hitPoint.add( N.mul( 0.001 ) ) );
+		rayOrigin.assign( hitInfo.hitPoint.add( calculateRayOffset( hitInfo.hitPoint, N, material ) ) );
 		rayDirection.assign( indirectResult.direction );
 		prevBouncePdf.assign( indirectResult.combinedPdf );
 

package/src/TSL/Struct.js

@@ -30,7 +30,6 @@ export const RayTracingMaterial = struct( {
 	alphaMode: 'int', // 0: OPAQUE, 1: MASK, 2: BLEND
 	side: 'int',
 	depthWrite: 'int',
-	visible: 'bool',
 	albedoMapIndex: 'int',
 	emissiveMapIndex: 'int',
 	normalMapIndex: 'int',

package/src/managers/EnvironmentManager.js

@@ -312,7 +312,7 @@ export class EnvironmentManager {
 			const startTime = performance.now();
 			const textureForCDF = this.scene.environment;
 
-			if ( ! textureForCDF.image || ! textureForCDF.image.data ) {
+			if ( ! textureForCDF.image ) {
 
 				this._updateCDFStorageBuffers();
 				this.uniforms.set( 'envTotalSum', 0.0 );

package/src/managers/MaterialDataManager.js

@@ -229,7 +229,6 @@ export class MaterialDataManager {
 				break;
 			case 'attenuationDistance': data[ stride + 15 ] = value; break;
 			case 'dispersion': data[ stride + 16 ] = value; break;
-			case 'visible': data[ stride + 17 ] = value; break;
 			case 'sheen': data[ stride + 18 ] = value; break;
 			case 'sheenRoughness': data[ stride + 19 ] = value; break;
 			case 'sheenColor':
@@ -378,7 +377,7 @@ export class MaterialDataManager {
 
 		data[ stride + 15 ] = materialData.attenuationDistance ?? Infinity;
 		data[ stride + 16 ] = materialData.dispersion ?? 0;
-		data[ stride + 17 ] = materialData.visible ?? 1;
+		data[ stride + 17 ] = 1; // Reserved slot (per-mesh visibility handled at BLAS-pointer level)
 		data[ stride + 18 ] = materialData.sheen ?? 0;
 		data[ stride + 19 ] = materialData.sheenRoughness ?? 1;