rayzee 5.1.1 → 5.3.0

package/src/TSL/Common.js

@@ -5,6 +5,7 @@ import {
 	MaterialClassification,
 	MISStrategy,
 	RayTracingMaterial,
+	ShadowMaterial,
 } from './Struct.js';
 
 export const PI = 3.14159;
@@ -16,7 +17,11 @@ export const MIN_CLEARCOAT_ROUGHNESS = 0.089;
 export const MAX_ROUGHNESS = 1.0;
 export const MIN_PDF = 0.001;
 export const REC709_LUMINANCE_COEFFICIENTS = vec3( 0.2126, 0.7152, 0.0722 );
-export const MATERIAL_SLOTS = 27;
+import { MATERIAL_DATA_LAYOUT } from '../EngineDefaults.js';
+
+export const MATERIAL_SLOTS = MATERIAL_DATA_LAYOUT.SLOTS_PER_MATERIAL;
+export const MATERIAL_SLOT = MATERIAL_DATA_LAYOUT.SLOT;
+const S = MATERIAL_SLOT;
 
 // XYZ to sRGB color space conversion matrix
 export const XYZ_TO_REC709 = mat3(
@@ -313,33 +318,33 @@ export const arrayToMat3 = wgslFn( `
 
 export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 
-	const data0 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 0 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data1 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 1 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data2 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 2 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data3 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 3 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data4 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 4 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data5 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 5 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data6 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 6 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data7 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 7 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data8 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 8 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data9 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 9 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data10 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 10 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data11 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 11 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data12 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 12 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data13 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 13 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data14 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 14 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data15 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 15 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data16 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 16 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data17 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 17 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data18 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 18 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data19 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 19 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data20 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 20 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data21 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 21 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data22 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 22 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data23 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 23 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data24 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 24 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data25 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 25 ), int( MATERIAL_SLOTS ) ).toVar();
-	const data26 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 26 ), int( MATERIAL_SLOTS ) ).toVar();
+	const data0 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.COLOR_METALNESS ), int( MATERIAL_SLOTS ) ).toVar();
+	const data1 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EMISSIVE_ROUGHNESS ), int( MATERIAL_SLOTS ) ).toVar();
+	const data2 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.IOR_TRANSMISSION ), int( MATERIAL_SLOTS ) ).toVar();
+	const data3 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ATTENUATION ), int( MATERIAL_SLOTS ) ).toVar();
+	const data4 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.DISPERSION_SHEEN ), int( MATERIAL_SLOTS ) ).toVar();
+	const data5 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.SHEEN_COLOR ), int( MATERIAL_SLOTS ) ).toVar();
+	const data6 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.SPECULAR ), int( MATERIAL_SLOTS ) ).toVar();
+	const data7 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.IRIDESCENCE ), int( MATERIAL_SLOTS ) ).toVar();
+	const data8 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.MAP_INDICES_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data9 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.MAP_INDICES_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data10 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.OPACITY_ALPHA ), int( MATERIAL_SLOTS ) ).toVar();
+	const data11 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ALPHA_MODE ), int( MATERIAL_SLOTS ) ).toVar();
+	const data12 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.BUMP_DISPLACEMENT ), int( MATERIAL_SLOTS ) ).toVar();
+	const data13 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ALBEDO_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data14 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ALBEDO_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data15 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.NORMAL_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data16 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.NORMAL_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data17 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ROUGHNESS_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data18 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ROUGHNESS_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data19 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.METALNESS_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data20 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.METALNESS_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data21 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EMISSIVE_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data22 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EMISSIVE_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data23 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.BUMP_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data24 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.BUMP_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data25 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.DISPLACEMENT_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data26 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.DISPLACEMENT_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
 
 	return RayTracingMaterial( {
 		color: vec4( data0.rgb, 1.0 ),
@@ -390,6 +395,35 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 
 } );
 
+// ── Shadow material thin reader (7 slot reads instead of 27) ─────────────
+// Only fetches fields needed by traceShadowRay: alpha, transmission, attenuation, albedo transform.
+
+export const getShadowMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
+
+	const data2 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.IOR_TRANSMISSION ), int( MATERIAL_SLOTS ) ).toVar();
+	const data3 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ATTENUATION ), int( MATERIAL_SLOTS ) ).toVar();
+	const data8 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.MAP_INDICES_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data10 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.OPACITY_ALPHA ), int( MATERIAL_SLOTS ) ).toVar();
+	const data11 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ALPHA_MODE ), int( MATERIAL_SLOTS ) ).toVar();
+	const data13 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ALBEDO_TRANSFORM_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data14 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.ALBEDO_TRANSFORM_B ), int( MATERIAL_SLOTS ) ).toVar();
+
+	return ShadowMaterial( {
+		color: vec4( 1.0 ), // Shadow path never samples full textures; color.a is always 1.0
+		ior: data2.r,
+		transmission: data2.g,
+		attenuationColor: data3.rgb,
+		attenuationDistance: data3.a,
+		albedoMapIndex: int( data8.r ),
+		opacity: data10.r,
+		transparent: data10.b,
+		alphaTest: data10.a,
+		alphaMode: int( data11.r ),
+		albedoTransform: arrayToMat3( { data1: data13, data2: data14 } ),
+	} );
+
+} );
+
 // ── Edge-stopping weight (normal + depth) ──────────────────────────────────
 // Used by ASVGF and SSRC for temporal/spatial reprojection edge-stopping.
 

package/src/TSL/Debugger.js

@@ -356,8 +356,7 @@ 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 debugEps = max( float( 1e-4 ), length( hitInfo.hitPoint ).mul( 1e-6 ) );
-			const bounceOrigin = hitInfo.hitPoint.add( normalA.mul( debugEps ) ).toVar();
+			const bounceOrigin = hitInfo.hitPoint.add( normalA.mul( 0.001 ) ).toVar();
 			const bounceRay = Ray( { origin: bounceOrigin, direction: bounceDir } );
 
 			const bounceHit = HitInfo.wrap( traverseBVH(

package/src/TSL/EmissiveSampling.js

@@ -28,7 +28,7 @@ import {
 } from 'three/tsl';
 
 import { struct } from './structProxy.js';
-import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic } from './Common.js';
+import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT } from './Common.js';
 import { RandomValue } from './Random.js';
 import { calculateMaterialPDF } from './LightsSampling.js';
 
@@ -326,9 +326,8 @@ export const calculateEmissiveLightPdf = Fn( ( [
 	const area = triangleArea( triData.v0, triData.v1, triData.v2 );
 
 	// Targeted material read: only fetch emissive data (2 vec4s instead of full 27)
-	const MATERIAL_SLOTS = int( 27 );
-	const matData1 = getDatafromStorageBuffer( materialBuffer, triData.materialIndex, int( 1 ), MATERIAL_SLOTS );
-	const matData2 = getDatafromStorageBuffer( materialBuffer, triData.materialIndex, int( 2 ), MATERIAL_SLOTS );
+	const matData1 = getDatafromStorageBuffer( materialBuffer, triData.materialIndex, int( MATERIAL_SLOT.EMISSIVE_ROUGHNESS ), MATERIAL_SLOTS );
+	const matData2 = getDatafromStorageBuffer( materialBuffer, triData.materialIndex, int( MATERIAL_SLOT.IOR_TRANSMISSION ), MATERIAL_SLOTS );
 	const avgEmissive = matData1.x.add( matData1.y ).add( matData1.z ).div( 3.0 );
 	const power = max( avgEmissive.mul( matData2.a ).mul( area ), float( 1e-10 ) );
 	const selectionPdf = power.div( max( emissiveTotalPower, float( 1e-10 ) ) );

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( 1e-5 ), () => {
+		If( t.greaterThan( 0.001 ), () => {
 
 			// Optimized rectangle test using vector rejection
 			const hitPoint = rayOrigin.add( rayDirection.mul( t ) );

package/src/TSL/LightsDirect.js

@@ -25,10 +25,11 @@ import {
 	clamp,
 	smoothstep,
 	select,
+	texture,
 } from 'three/tsl';
 
-import { Ray, RayTracingMaterial, HitInfo, DirectionSample, MaterialCache } from './Struct.js';
-import { PI, TWO_PI, EPSILON, REC709_LUMINANCE_COEFFICIENTS, powerHeuristic, getMaterial } from './Common.js';
+import { Ray, ShadowMaterial, HitInfo, DirectionSample, MaterialCache } from './Struct.js';
+import { PI, TWO_PI, EPSILON, REC709_LUMINANCE_COEFFICIENTS, powerHeuristic, getShadowMaterial, getDatafromStorageBuffer } from './Common.js';
 import { fresnelSchlickFloat } from './Fresnel.js';
 import { iorToFresnel0 } from './Fresnel.js';
 import {
@@ -37,6 +38,33 @@ import {
 } from './LightsCore.js';
 import { calculateBeerLawAbsorption, calculateShadowTransmittance } from './MaterialTransmission.js';
 import { RandomValue } from './Random.js';
+import { getTransformedUV } from './TextureSampling.js';
+
+// Module-level state for alpha-cutout shadow testing.
+// Set by ShaderBuilder before graph construction (same pattern as _meshVisibilityBuffer in BVHTraversal.js).
+let _shadowAlbedoMaps = null;
+let _enableAlphaShadows = null;
+
+/**
+ * Set the albedo texture array node for alpha-aware shadow rays.
+ * Must be called before the shader graph is constructed.
+ * @param {TextureNode} maps - TSL texture node for the albedo array
+ */
+export function setShadowAlbedoMaps( maps ) {
+
+	_shadowAlbedoMaps = maps;
+
+}
+
+/**
+ * Set the runtime uniform node that toggles alpha-cutout shadows.
+ * @param {UniformNode} node - TSL int uniform (0 = disabled, 1 = enabled)
+ */
+export function setAlphaShadowsUniform( node ) {
+
+	_enableAlphaShadows = node;
+
+}
 
 // ================================================================================
 // SHADOW RAY MATERIAL TRANSPARENCY
@@ -102,11 +130,82 @@ export const traceShadowRay = Fn( ( [
 
 		} );
 
-		// Fetch material for the hit surface
-		const shadowMaterial = RayTracingMaterial.wrap( getMaterial( shadowHit.materialIndex, materialBuffer ) );
+		// Fetch material for the hit surface (thin reader: 7 slots instead of 27)
+		const shadowMaterial = ShadowMaterial.wrap( getShadowMaterial( shadowHit.materialIndex, materialBuffer ) );
+
+		// ---------------------------------------------------------------
+		// Alpha-cutout handling (MASK / BLEND with albedo texture alpha)
+		// Gated by runtime uniform + alphaMode check — zero overhead for opaque materials.
+		// UV computation deferred here from BVH traversal: barycentrics stored in shadowHit.uv,
+		// triangle index in shadowHit.triangleIndex. Actual UV interpolation only when needed.
+		// ---------------------------------------------------------------
+		const alphaCutout = tslBool( false ).toVar();
+
+		if ( _enableAlphaShadows ) If( _enableAlphaShadows.equal( int( 1 ) ), () => {
+
+			// Sample texture alpha once (shared by MASK and BLEND paths).
+			// Deferred UV: barycentrics in shadowHit.uv, triangle index in shadowHit.triangleIndex.
+			const texAlpha = float( 1.0 ).toVar();
+
+			if ( _shadowAlbedoMaps ) {
+
+				If( shadowMaterial.albedoMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+					const baryU = shadowHit.uv.x;
+					const baryV = shadowHit.uv.y;
+					const baryW = float( 1.0 ).sub( baryU ).sub( baryV );
+					const TRI_STRIDE = int( 8 );
+					const uvData1 = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 6 ), TRI_STRIDE );
+					const uvData2 = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 7 ), TRI_STRIDE );
+					const hitUV = uvData1.xy.mul( baryW ).add( uvData1.zw.mul( baryU ) ).add( uvData2.xy.mul( baryV ) );
+					const albedoUV = getTransformedUV( { uv: hitUV, transform: shadowMaterial.albedoTransform } );
+					texAlpha.assign( texture( _shadowAlbedoMaps, albedoUV ).depth( int( shadowMaterial.albedoMapIndex ) ).a );
+
+				} );
+
+			}
+
+			If( shadowMaterial.alphaMode.equal( int( 1 ) ), () => {
+
+				// MASK mode: binary alpha cutout
+				const effectiveAlpha = shadowMaterial.color.a.mul( texAlpha );
+				const cutoff = select( shadowMaterial.alphaTest.greaterThan( 0.0 ), shadowMaterial.alphaTest, float( 0.5 ) );
+				If( effectiveAlpha.lessThan( cutoff ), () => {
+
+					alphaCutout.assign( true );
+
+				} );
+
+			} ).ElseIf( shadowMaterial.alphaMode.equal( int( 2 ) ), () => {
+
+				// BLEND mode: modulate transmittance by alpha
+				const blendAlpha = clamp( shadowMaterial.color.a.mul( shadowMaterial.opacity ).mul( texAlpha ), 0.0, 1.0 );
+				transmittance.mulAssign( float( 1.0 ).sub( blendAlpha ) );
+
+				If( transmittance.lessThan( 0.005 ), () => {
+
+					transmittance.assign( 0.0 );
+					Break();
+
+				} );
+
+				alphaCutout.assign( true );
+
+			} );
+
+		} );
+
+		// ---------------------------------------------------------------
+		// Surface interaction: alpha-skip, transmission, transparent, or opaque
+		// ---------------------------------------------------------------
+		If( alphaCutout, () => {
+
+			// Alpha-transparent surface — advance ray past it
+			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 ) );
 
-		// Handle transmissive materials
-		If( shadowMaterial.transmission.greaterThan( 0.0 ), () => {
+		} ).ElseIf( shadowMaterial.transmission.greaterThan( 0.0 ), () => {
 
 			const entering = dot( dir, shadowHit.normal ).lessThan( 0.0 );
 			const N = select( entering, shadowHit.normal, shadowHit.normal.negate() );
@@ -142,9 +241,8 @@ export const traceShadowRay = Fn( ( [
 			} );
 
 			// Continue ray past transmissive surface
-			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 ) );
+			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( 0.001 ) ) );
+			remainingDist.subAssign( shadowHit.dst.add( 0.001 ) );
 
 		} ).ElseIf( shadowMaterial.transparent, () => {
 
@@ -159,9 +257,8 @@ export const traceShadowRay = Fn( ( [
 			} );
 
 			// Continue ray past transparent surface
-			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 ) );
+			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( 0.001 ) ) );
+			remainingDist.subAssign( shadowHit.dst.add( 0.001 ) );
 
 		} ).Else( () => {
 
@@ -259,7 +356,7 @@ export const estimateLightImportance = Fn( ( [ light, hitPoint, normal, material
 
 		If( lightFacing.greaterThan( 0.0 ), () => {
 
-			const solidAngle = light.area.div( max( distSq, 1e-4 ) );
+			const solidAngle = light.area.div( max( distSq, 0.1 ) );
 			const power = light.intensity.mul( dot( light.color, REC709_LUMINANCE_COEFFICIENTS ) ).mul( light.area );
 
 			// Material-aware weighting
@@ -661,7 +758,7 @@ export const calculatePointLightContribution = Fn( ( [
 			const rayOffset = calculateRayOffset( hitPoint, normal, material );
 			const rayOrigin = hitPoint.add( rayOffset );
 
-			const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.mul( 0.999 ), rngState );
+			const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.sub( 0.001 ), rngState );
 
 			If( visibility.greaterThan( 0.0 ), () => {
 
@@ -713,7 +810,7 @@ export const calculateSpotLightContribution = Fn( ( [
 				const rayOffset = calculateRayOffset( hitPoint, normal, material );
 				const rayOrigin = hitPoint.add( rayOffset );
 
-				const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.mul( 0.999 ), rngState );
+				const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.sub( 0.001 ), rngState );
 
 				If( visibility.greaterThan( 0.0 ), () => {
 

package/src/TSL/LightsSampling.js

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

package/src/TSL/PathTracerCore.js

@@ -747,7 +747,9 @@ export const Trace = Fn( ( [
 
 		} );
 
-		// Get material from texture
+		// Get full material (27 reads). Lazy transform loading was tested but regressed
+		// textured scenes due to identity-construct + conditional-assign overhead.
+		// Shadow rays use getShadowMaterial() (7 reads) — the real bandwidth win.
 		const material = RayTracingMaterial.wrap( getMaterial( hitInfo.materialIndex, materialBuffer ) ).toVar();
 
 		// Tessellation-free displacement — refine intersection with ray-height field marching
@@ -880,8 +882,7 @@ 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 );
-			const bounceEps = max( float( 1e-4 ), length( hitInfo.hitPoint ).mul( 1e-6 ) );
-			rayOrigin.assign( hitInfo.hitPoint.add( offsetDir.mul( bounceEps ) ) );
+			rayOrigin.assign( hitInfo.hitPoint.add( offsetDir.mul( 0.001 ) ) );
 			rayDirection.assign( interaction.direction );
 
 			stateIsPrimaryRay.assign( tslBool( false ) );
@@ -1055,7 +1056,7 @@ export const Trace = Fn( ( [
 
 						const rayOffset = calculateRayOffset( hitInfo.hitPoint, N, material );
 						const rayOrigin = hitInfo.hitPoint.add( rayOffset );
-						const shadowDist = emissiveSample.distance.mul( 0.999 );
+						const shadowDist = emissiveSample.distance.sub( 0.001 );
 						const visibility = traceShadowRayWrapped( rayOrigin, emissiveSample.direction, shadowDist, rngState );
 
 						If( visibility.greaterThan( 0.0 ), () => {
@@ -1138,7 +1139,7 @@ export const Trace = Fn( ( [
 		throughput.mulAssign( indirectResult.throughput );
 
 		// Prepare for next bounce
-		rayOrigin.assign( hitInfo.hitPoint.add( calculateRayOffset( hitInfo.hitPoint, N, material ) ) );
+		rayOrigin.assign( hitInfo.hitPoint.add( N.mul( 0.001 ) ) );
 		rayDirection.assign( indirectResult.direction );
 		prevBouncePdf.assign( indirectResult.combinedPdf );
 

package/src/TSL/Struct.js

@@ -52,6 +52,22 @@ export const RayTracingMaterial = struct( {
 	iridescenceThicknessRange: 'vec2',
 } );
 
+// Lightweight material for shadow ray evaluation — only the fields needed
+// by traceShadowRay (alpha, transmission, transparency, attenuation).
+export const ShadowMaterial = struct( {
+	color: 'vec4',
+	ior: 'float',
+	transmission: 'float',
+	attenuationColor: 'vec3',
+	attenuationDistance: 'float',
+	albedoMapIndex: 'int',
+	opacity: 'float',
+	transparent: 'bool',
+	alphaTest: 'float',
+	alphaMode: 'int',
+	albedoTransform: 'mat3',
+} );
+
 export const Sphere = struct( {
 	position: 'vec3',
 	radius: 'float',