rayzee 11.7.0 → 11.9.0

package/src/TSL/Common.js

@@ -336,15 +336,22 @@ export function splitStorage( parts, perPart, type ) {
 
 }
 
-/** Element `index` of a storage node or of a {@link splitStorage}. */
-export function storageElement( buffer, index ) {
-
-	if ( ! buffer.isSplitStorage ) return buffer.element( index );
+/**
+ * Elements `base + r` of a {@link splitStorage}, for each offset r in `rows`, all of one record: a part holds whole
+ * records, so the part is picked once and every row is read in its branch.
+ */
+export function storageRows( buffer, base, rows ) {
 
 	const { parts, perPart } = buffer;
-	const e = int( index ).toVar();
-	const out = ( { uvec4, uvec2 }[ buffer.type ] ?? vec4 )( 0 ).toVar();
-	const read = ( k ) => () => out.assign( parts[ k ].element( k === 0 ? e : e.sub( int( perPart * k ) ) ) );
+	const e = int( base ).toVar();
+	const out = rows.map( () => ( { uvec4, uvec2 }[ buffer.type ] ?? vec4 )( 0 ).toVar() );
+	const read = ( k ) => () => {
+
+		const at = k === 0 ? e : e.sub( int( perPart * k ) );
+		rows.forEach( ( r, j ) => out[ j ].assign( parts[ k ].element( r === 0 ? at : at.add( int( r ) ) ) ) );
+
+	};
+
 	let branch = If( e.lessThan( int( perPart ) ), read( 0 ) );
 	for ( let k = 1; k < parts.length - 1; k ++ ) branch = branch.ElseIf( e.lessThan( int( perPart * ( k + 1 ) ) ), read( k ) );
 	branch.Else( read( parts.length - 1 ) );
@@ -352,6 +359,13 @@ export function storageElement( buffer, index ) {
 
 }
 
+/** Element `index` of a storage node or of a {@link splitStorage}. */
+export function storageElement( buffer, index ) {
+
+	return buffer.isSplitStorage ? storageRows( buffer, index, [ 0 ] )[ 0 ] : buffer.element( index );
+
+}
+
 const asNode = ( v ) => ( v?.isNode ? v : int( v ) );
 
 // Element `index · stride + offset`.
@@ -536,6 +550,7 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 		bumpScale: data12.r,
 		displacementScale: data12.g,
 		displacementMapIndex: int( data12.b ),
+		displacementBias: data12.a,
 		albedoTransform: arrayToMat3( { data1: data13, data2: data14 } ),
 		normalTransform: arrayToMat3( { data1: data15, data2: data16 } ),
 		roughnessTransform: arrayToMat3( { data1: data17, data2: data18 } ),
@@ -586,6 +601,7 @@ export const diffuseGroundMaterial = Fn( () => {
 		bumpMapIndex: int( - 1 ),
 		bumpScale: float( 1.0 ),
 		displacementScale: float( 0.0 ),
+		displacementBias: float( 0.0 ),
 		metalnessMapIndex: int( - 1 ),
 		roughnessMapIndex: int( - 1 ),
 		displacementMapIndex: int( - 1 ),
@@ -676,9 +692,10 @@ export const shadowFlagsSettle = ( flags, alphaShadows ) => {
 
 export const instanceRows = ( bvhBuffer, leafIndex ) => {
 
-	// Built over copy clusters, an instance is a copy record (3 vec4 from `copyRecordBase`), not a TLAS leaf.
+	// Over copy clusters an instance is a 3-vec4 copy record, which can straddle two parts: read per element.
 	const records = bvhBuffer.value?.copyRecordBase;
 	if ( records !== undefined ) return [ 0, 1, 2 ].map( ( row ) => getDatafromStorageBuffer( bvhBuffer, leafIndex, int( records + row ), int( 3 ) ) );
+	if ( bvhBuffer.isSplitStorage ) return storageRows( bvhBuffer, int( leafIndex ).mul( 4 ), [ 1, 2, 3 ] );
 	return [
 		getDatafromStorageBuffer( bvhBuffer, leafIndex, int( 1 ), int( 4 ) ),
 		getDatafromStorageBuffer( bvhBuffer, leafIndex, int( 2 ), int( 4 ) ),

package/src/TSL/DebugKernel.js

@@ -13,7 +13,7 @@ import {
 	localId, workgroupId,
 } from 'three/tsl';
 
-import { generateRayFromCamera } from './CameraRay.js';
+import { generateRayFromCamera, cameraClipDistance } from './CameraRay.js';
 import { Ray } from './Struct.js';
 import { TraceDebugMode } from './Debugger.js';
 import { pcgHash, getStratifiedSample } from './Random.js';
@@ -28,6 +28,7 @@ export function buildDebugKernel( params ) {
 		cameraWorldMatrix, cameraProjectionMatrixInverse, cameraProjectionMatrix, cameraViewMatrix,
 		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
 		enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur,
+		cameraClipStart,
 		bvhBuffer, triangleBuffer, materialBuffer,
 		envTexture, environmentMatrix, environmentIntensity, enableEnvironmentLight,
 		visMode, debugVisScale,
@@ -66,7 +67,7 @@ export function buildDebugKernel( params ) {
 
 				// Modes 1-8, 10 — shared per-mode debug color (primary-ray trace + counters).
 				color.assign( TraceDebugMode(
-					ray.origin, ray.direction,
+					ray.origin.add( ray.direction.mul( cameraClipDistance( ray.direction, cameraClipStart, cameraWorldMatrix, cameraProjection ) ) ), ray.direction,
 					bvhBuffer, triangleBuffer, materialBuffer,
 					envTexture, environmentMatrix, environmentIntensity, enableEnvironmentLight,
 					visMode, debugVisScale,

package/src/TSL/Displacement.js

@@ -1,33 +1,39 @@
 import { sceneResources } from './SceneResources.js';
-import { Fn, float, vec2, int, If, Loop, abs, normalize, dot, max, uintBitsToFloat } from 'three/tsl';
+import {
+	Fn, wgslFn, float, vec2, int, bool as tslBool, If, Loop, Break, abs, normalize, dot, cross, min, max, clamp, ceil, select, uintBitsToFloat,
+} from 'three/tsl';
 
 import { struct } from './patches.js';
 import { triangleRow, instanceRows, instanceDirToWorld } from './Common.js';
 import { sampleDisplacementMap, bucketTexelSize } from './TextureSampling.js';
 
-// Ray-displacement intersection configuration
-const MAX_MARCH_STEPS = 32;
-const MIN_MARCH_STEPS = 16;
-const BINARY_STEPS = 5;
+const MIN_MARCH_STEPS = 8;
+const MAX_MARCH_STEPS = 64;
+const MAX_BOUNCE_MARCH_STEPS = 16;
+const STEPS_PER_TEXEL = 0.25;
+const BINARY_STEPS = 6;
+const SLOPE_TEXELS = 1.5;
 
 export const DisplacementResult = struct( {
 	hitPoint: 'vec3',
 	uv: 'vec2',
 	normal: 'vec3',
-	height: 'float',
 } );
 
+// Texture-space UV per raw UV, per axis.
+const uvTransformScale = /*@__PURE__*/ wgslFn( `
+	fn uvTransformScale( transform: mat3x3f ) -> vec2f {
+		return max( vec2f( length( transform[0].xy ), length( transform[1].xy ) ), vec2f( 1e-6 ) );
+	}
+` );
+
 /**
  * Tessellation-free displacement mapping via analytical UV ray marching.
  *
- * Instead of projecting march points onto the triangle to get barycentrics (which
- * causes UV distortion from clamping), this computes the ray's UV trajectory
- * analytically using the triangle's actual tangent vectors (dP/du, dP/dv).
- *
  * The ray is parameterized as: P(dt) = hitPoint + rayDir * dt
  * UV along the ray:           UV(dt) = hitUV + dUV_dt * dt
  * Ray height above surface:   h_ray(dt) = dt * dot(rayDir, N)
- * Displaced surface height:   h_surf(dt) = (sample(UV(dt)) - 0.5) * scale
+ * Displaced surface height:   h_surf(dt) = sample(UV(dt)) * displacementScale + displacementBias, as three.js
  *
  * We find dt where h_ray(dt) = h_surf(dt).
  */
@@ -38,7 +44,6 @@ export const refineDisplacedIntersection = Fn( ( [
 	const resultHitPoint = hitInfo.hitPoint.toVar();
 	const resultUV = hitInfo.uv.toVar();
 	const resultNormal = hitInfo.normal.toVar();
-	const resultHeight = float( 0.0 ).toVar();
 
 	// Fetch triangle vertex data
 	const triIdx = hitInfo.triangleIndex;
@@ -83,16 +88,13 @@ export const refineDisplacedIntersection = Fn( ( [
 		const B = edge2.mul( dUV1.x ).sub( edge1.mul( dUV2.x ) ).mul( invDet ).toVar();
 		const N = hitInfo.normal.toVar();
 
-		const scale = material.displacementScale.div( float( 10.0 ) ); // Arbitrary scale factor for height
+		const scale = material.displacementScale;
+		const bias = material.displacementBias;
 		const rayDir = ray.direction;
 
-		// Compute UV velocity along the ray: dUV/dt
-		// Project ray direction onto surface tangent plane
 		const NdotD = dot( rayDir, N ).toVar();
 		const rayProj = rayDir.sub( N.mul( NdotD ) ).toVar();
 
-		// Solve: rayProj = du_dt * T + dv_dt * B
-		// Using the Gram matrix inverse of [T, B]
 		const TdotT = dot( T, T );
 		const TdotB = dot( T, B );
 		const BdotB = dot( B, B );
@@ -100,89 +102,60 @@ export const refineDisplacedIntersection = Fn( ( [
 
 		If( abs( detJ ).greaterThan( 1e-10 ), () => {
 
+			// Dual basis of (T, B): dot( Td, T ) = 1, dot( Td, B ) = 0, and likewise Bd.
 			const invDetJ = float( 1.0 ).div( detJ );
-			const rayProjDotT = dot( rayProj, T );
-			const rayProjDotB = dot( rayProj, B );
-
-			const du_dt = BdotB.mul( rayProjDotT ).sub( TdotB.mul( rayProjDotB ) ).mul( invDetJ );
-			const dv_dt = TdotT.mul( rayProjDotB ).sub( TdotB.mul( rayProjDotT ) ).mul( invDetJ );
-			const dUV_dt = vec2( du_dt, dv_dt ).toVar();
-
-			// Ray height change per unit dt: how fast the ray moves along the surface normal
-			const dh_ray_dt = NdotD.toVar();
-
-			// March range: displacement shell extends ±0.5*scale from base surface
-			// Compute dt range to traverse the full shell
-			const absNdotD = max( abs( dh_ray_dt ), 0.001 );
-			const dtShell = scale.div( absNdotD ).toVar();
+			const Td = T.mul( BdotB ).sub( B.mul( TdotB ) ).mul( invDetJ ).toVar();
+			const Bd = B.mul( TdotT ).sub( T.mul( TdotB ) ).mul( invDetJ ).toVar();
+			const dUV_dt = vec2( dot( rayProj, Td ), dot( rayProj, Bd ) ).toVar();
 
-			// Adaptive step count: full steps on primary ray, half on deeper bounces
-			const marchSteps = int( bounceIndex.equal( int( 0 ) ).select(
-				int( MAX_MARCH_STEPS ), int( MIN_MARCH_STEPS )
-			) ).toVar();
+			// +1 when the ray arrives from the side N points to.
+			const side = select( NdotD.lessThan( 0.0 ), float( 1.0 ), float( - 1.0 ) ).toVar();
+			const under = ( dt, height ) => dt.mul( NdotD ).sub( height.mul( scale ).add( bias ) ).mul( side ).lessThanEqual( 0.0 );
+			const heightAt = uv => sampleDisplacementMap( material.displacementMapIndex, uv, material.displacementTransform );
 
-			// Start from above the shell, march through
-			const dtStart = dtShell.negate().toVar();
-			const dtEnd = dtShell;
-			const dtStep = dtEnd.sub( dtStart ).div( float( marchSteps ) ).toVar();
+			// Enter the shell [bias, bias + scale] on the ray's side, never behind the ray's origin.
+			const top = max( bias, bias.add( scale ) );
+			const bottom = min( bias, bias.add( scale ) );
+			const slope = side.negate().mul( max( abs( NdotD ), 0.001 ) );
+			const dtStart = max( select( side.greaterThan( 0.0 ), top, bottom ).div( slope ), hitInfo.dst.negate() ).toVar();
+			const dtEnd = select( side.greaterThan( 0.0 ), bottom, top ).div( slope ).toVar();
 
-			// Track for binary refinement
-			const prevDt = dtStart.toVar();
-			const currDt = dtStart.toVar();
-			const found = int( 0 ).toVar();
+			// One step per few texels the ray crosses, so a grazing ray does not step over the gaps.
+			const texelsPerUV = uvTransformScale( { transform: material.displacementTransform } )
+				.div( bucketTexelSize( sceneResources( builder ).linearBuckets, material.displacementMapIndex ) ).toVar();
+			const texelsCrossed = dUV_dt.mul( texelsPerUV ).length().mul( dtEnd.sub( dtStart ) );
+			const maxSteps = select( bounceIndex.equal( int( 0 ) ), float( MAX_MARCH_STEPS ), float( MAX_BOUNCE_MARCH_STEPS ) );
+			const marchSteps = select( dtEnd.greaterThan( dtStart ),
+				int( clamp( ceil( texelsCrossed.mul( STEPS_PER_TEXEL ) ), float( MIN_MARCH_STEPS ), maxSteps ) ), int( 0 ) ).toVar();
+			const dtStep = dtEnd.sub( dtStart ).div( max( float( marchSteps ), 1.0 ) ).toVar();
 
-			// Linear march through displacement shell
-			Loop( { start: int( 0 ), end: marchSteps, type: 'int', condition: '<' }, ( { i } ) => {
+			const loDt = dtStart.toVar();
+			const hiDt = dtStart.toVar();
+			const found = tslBool( false ).toVar();
 
-				If( found.equal( int( 0 ) ), () => {
+			Loop( { start: int( 1 ), end: marchSteps.add( 1 ), type: 'int', condition: '<' }, ( { i } ) => {
 
-					const dt = dtStart.add( dtStep.mul( float( i ) ) ).toVar();
+				const dt = dtStart.add( dtStep.mul( float( i ) ) ).toVar();
 
-					// UV at this point along the ray
-					const marchUV = hitInfo.uv.add( dUV_dt.mul( dt ) );
+				If( under( dt, heightAt( hitInfo.uv.add( dUV_dt.mul( dt ) ) ) ), () => {
 
-					// Ray height above base surface at this dt
-					const rayHeight = dt.mul( dh_ray_dt );
-
-					// Displaced surface height
-					const heightSample = sampleDisplacementMap(
-						material.displacementMapIndex, marchUV, material.displacementTransform,
-					);
-					const surfaceHeight = heightSample.sub( 0.5 ).mul( scale );
-
-					// Ray crosses below displaced surface → intersection
-					If( rayHeight.lessThanEqual( surfaceHeight ).and( i.greaterThan( int( 0 ) ) ), () => {
-
-						found.assign( 1 );
-						currDt.assign( dt );
-
-					} ).Else( () => {
-
-						prevDt.assign( dt );
-
-					} );
+					found.assign( true );
+					hiDt.assign( dt );
+					Break();
 
 				} );
 
-			} );
+				loDt.assign( dt );
 
-			// Binary refinement
-			If( found.equal( int( 1 ) ), () => {
+			} );
 
-				const loDt = prevDt.toVar();
-				const hiDt = currDt.toVar();
+			If( found, () => {
 
 				Loop( { start: int( 0 ), end: int( BINARY_STEPS ), type: 'int', condition: '<' }, () => {
 
 					const midDt = loDt.add( hiDt ).mul( 0.5 ).toVar();
-					const midUV = hitInfo.uv.add( dUV_dt.mul( midDt ) );
-					const midRayHeight = midDt.mul( dh_ray_dt );
-					const midSample = sampleDisplacementMap(
-						material.displacementMapIndex, midUV, material.displacementTransform,
-					);
-					const midSurfHeight = midSample.sub( 0.5 ).mul( scale );
 
-					If( midRayHeight.lessThanEqual( midSurfHeight ), () => {
+					If( under( midDt, heightAt( hitInfo.uv.add( dUV_dt.mul( midDt ) ) ) ), () => {
 
 						hiDt.assign( midDt );
 
@@ -194,40 +167,20 @@ export const refineDisplacedIntersection = Fn( ( [
 
 				} );
 
-				// Final intersection
 				const finalDt = loDt.add( hiDt ).mul( 0.5 ).toVar();
 				const finalUV = hitInfo.uv.add( dUV_dt.mul( finalDt ) ).toVar();
-				const finalPoint = hitInfo.hitPoint.add( rayDir.mul( finalDt ) );
-
-				const finalHeight = sampleDisplacementMap(
-					material.displacementMapIndex, finalUV, material.displacementTransform,
-				);
-				const displacedHeight = finalHeight.sub( 0.5 ).mul( scale );
-
-				// Compute displaced normal from height-field gradients using UV tangent vectors.
-				// Finite-difference step = one texel of the SELECTED bucket array's real dimensions.
-				const texel = bucketTexelSize( sceneResources( builder ).linearBuckets, material.displacementMapIndex ).toVar();
-				const hC = finalHeight;
-				const hU = sampleDisplacementMap(
-					material.displacementMapIndex, finalUV.add( vec2( texel.x, 0.0 ) ), material.displacementTransform,
-				);
-				const hV = sampleDisplacementMap(
-					material.displacementMapIndex, finalUV.add( vec2( 0.0, texel.y ) ), material.displacementTransform,
-				);
-
-				// Perturb normal using actual tangent/bitangent from UV parameterization
-				const Tn = normalize( T ).toVar();
-				const Bn = normalize( B ).toVar();
-				const gradU = hU.sub( hC ).mul( scale );
-				const gradV = hV.sub( hC ).mul( scale );
-				const displacedNormal = normalize(
-					N.sub( Tn.mul( gradU ) ).sub( Bn.mul( gradV ) )
-				);
-
-				resultHitPoint.assign( finalPoint );
+
+				// Central differences over a few texels: an 8-bit map's steps make one-texel slopes flicker.
+				const step = vec2( SLOPE_TEXELS ).div( texelsPerUV ).toVar();
+				const dhdu = heightAt( finalUV.add( vec2( step.x, 0.0 ) ) ).sub( heightAt( finalUV.sub( vec2( step.x, 0.0 ) ) ) ).mul( scale ).div( step.x.mul( 2.0 ) );
+				const dhdv = heightAt( finalUV.add( vec2( 0.0, step.y ) ) ).sub( heightAt( finalUV.sub( vec2( 0.0, step.y ) ) ) ).mul( scale ).div( step.y.mul( 2.0 ) );
+				resultNormal.assign( normalize( N.sub( Td.mul( dhdu ) ).sub( Bd.mul( dhdv ) ) ) );
+
+				// A point behind the base triangle goes up onto its plane: rays spawned below it would hit it.
+				const faceN = normalize( cross( Td, Bd ) );
+				const moveDir = select( finalDt.greaterThan( 0.0 ), rayDir.sub( faceN.mul( dot( rayDir, faceN ) ) ), rayDir );
+				resultHitPoint.assign( hitInfo.hitPoint.add( moveDir.mul( finalDt ) ) );
 				resultUV.assign( finalUV );
-				resultNormal.assign( displacedNormal );
-				resultHeight.assign( displacedHeight );
 
 			} );
 
@@ -235,6 +188,6 @@ export const refineDisplacedIntersection = Fn( ( [
 
 	} );
 
-	return DisplacementResult( { hitPoint: resultHitPoint, uv: resultUV, normal: resultNormal, height: resultHeight } );
+	return DisplacementResult( { hitPoint: resultHitPoint, uv: resultUV, normal: resultNormal } );
 
 } );

package/src/TSL/FinalWriteKernel.js

@@ -39,7 +39,6 @@ export function buildFinalWriteKernel( params ) {
 		enableAccumulation, hasPreviousAccumulated, accumulationAlpha, cameraIsMoving,
 		// Aux MRT accumulates on its own epoch; hasPreviousAux=0 → write it verbatim instead of mixing.
 		hasPreviousAux, auxAccumulationAlpha,
-		transparentBackground,
 		prevAccumTexture, prevAlbedoTexture, prevNormalDepthTexture,
 		renderWidth,
 		chunkRowBase, chunkRows, // row band offset (global first row) + row count for this chunk
@@ -85,7 +84,9 @@ export function buildFinalWriteKernel( params ) {
 
 			const sampleColor = readRayRadiance( rayBufferRO, rayID );
 			const finalColor = sampleColor.xyz.toVar();
-			const outputAlpha = select( transparentBackground, sampleColor.w, float( 1.0 ) ).toVar();
+			// Coverage, whatever the backdrop: 0 where the camera saw past everything opaque. What shows or reads the
+			// image makes it opaque unless the background is transparent; auto exposure leaves a solid colour out by it.
+			const outputAlpha = sampleColor.w.toVar();
 
 			// A pixel frozen in a prior frame was skipped by Generate, so its rayBuffer sample is stale — pass
 			// the accumulated colour through unchanged (below) instead of mixing it. Inert unless adaptiveOn.
@@ -145,11 +146,7 @@ export function buildFinalWriteKernel( params ) {
 
 				} );
 
-				If( transparentBackground, () => {
-
-					outputAlpha.assign( select( wasFrozen, prevAccumSample.w, mix( prevAccumSample.w, sampleColor.w, accumulationAlpha ) ) );
-
-				} );
+				outputAlpha.assign( select( wasFrozen, prevAccumSample.w, mix( prevAccumSample.w, sampleColor.w, accumulationAlpha ) ) );
 
 			} );
 

package/src/TSL/GenerateKernel.js

@@ -22,7 +22,7 @@ import {
 	getStratifiedSample,
 } from './Random.js';
 
-import { generateRayFromCamera } from './CameraRay.js';
+import { generateRayFromCamera, cameraClipDistance } from './CameraRay.js';
 import { Ray } from './Struct.js';
 import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
 import {
@@ -41,6 +41,7 @@ export function buildGenerateKernel( params ) {
 		cameraWorldMatrix, cameraProjectionMatrixInverse,
 		cameraProjection, panoLonRange, panoLatRange, panoLevelHorizon,
 		enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur,
+		cameraClipStart,
 		renderWidth,
 		chunkRowBase, chunkRows, // row band offset (global first row) + row count for this chunk
 		transmissiveBounces, // per-ray refraction budget (megakernel parity: PathTracerCore.js:606)
@@ -79,7 +80,10 @@ export function buildGenerateKernel( params ) {
 			enableDOF, focalLength, aperture, focusDistance, unitsPerMetre, apertureScale, anamorphicRatio, dofMode, dofBlur,
 		) );
 
-		writeRayOriginMeta( rayBufferRW, rayID, ray.origin, int( 0 ), int( 0 ) );
+		// The ray starts at the clip plane. The bidirectional weights still measure the first segment from the camera:
+		// the skipped length rides in the alpha-skip distance (mis_ray_t), as a cutout's would.
+		const clipAlong = cameraClipDistance( ray.direction, cameraClipStart, cameraWorldMatrix, cameraProjection ).toVar();
+		writeRayOriginMeta( rayBufferRW, rayID, ray.origin.add( ray.direction.mul( clipAlong ) ), int( 0 ), int( 0 ), uint( 0 ), bdpt ? clipAlong : null );
 		// A fresh camera ray is NOT redirected — REDIRECTED stays clear so it sees the direct backdrop;
 		// ShadeKernel sets REDIRECTED on the first direction-changing interaction (see RAY_FLAG.REDIRECTED).
 		writeRayDirFlags( rayBufferRW, rayID, ray.direction, uint( RAY_FLAG.ACTIVE ) );

package/src/TSL/LightSplatKernel.js

@@ -29,7 +29,7 @@ export function buildLightSplatKernel( params ) {
 		hitBufferRO, splatBuffer,
 		bvhBuffer, triangleBuffer, materialBuffer,
 		lightPaths, slotsPerPath, lightTag, strategyView,
-		cameraPosition, cameraForward, cameraViewMatrix, cameraProjectionMatrix, pixelArea,
+		cameraPosition, cameraForward, cameraClipStart, cameraViewMatrix, cameraProjectionMatrix, pixelArea,
 		renderWidth, renderHeight,
 		globalIlluminationIntensity, fireflyThreshold, accumFrame, frame,
 		mergeVm = null,
@@ -68,7 +68,10 @@ export function buildLightSplatKernel( params ) {
 		const culled = diffuseTransmission
 			? select( behind, v.extra.bitAnd( uint( 2 ) ), v.extra.bitAnd( uint( 1 ) ) ).notEqual( uint( 0 ) )
 			: v.extra.notEqual( uint( 0 ) );
-		If( ( diffuseTransmission ? cosFacet.equal( 0.0 ) : cosFacet.lessThanEqual( 0.0 ) ).or( cosCamera.lessThanEqual( 1e-6 ) ).or( culled ), () => {
+		// The camera sees nothing in front of its clip plane, this far back along the line to it.
+		const clipAlong = cameraClipStart.div( max( cosCamera, 1e-6 ) ).toVar();
+		If( ( diffuseTransmission ? cosFacet.equal( 0.0 ) : cosFacet.lessThanEqual( 0.0 ) ).or( cosCamera.lessThanEqual( 1e-6 ) ).or( culled )
+			.or( dist2.lessThanEqual( clipAlong.mul( clipAlong ) ) ), () => {
 
 			Return();
 
@@ -123,9 +126,9 @@ export function buildLightSplatKernel( params ) {
 		const origin = offsetRayOrigin( v.position, diffuseTransmission ? select( behind, v.facetN.negate(), v.facetN ) : v.facetN ).toVar();
 		const segment = cameraPosition.sub( origin ).toVar();
 		const segmentLength = length( segment ).toVar();
-		// This segment stands in for the primary ray, which sees through the faces it culls.
+		// This segment stands in for the primary ray, which sees through the faces it culls and starts at the clip plane.
 		const visibility = traceShadowRayRefractiveOpaque(
-			origin, segment.div( segmentLength ), segmentLength.mul( SHADOW_END ),
+			origin, segment.div( segmentLength ), segmentLength.sub( clipAlong ).mul( SHADOW_END ),
 			traverseBVHShadowCameraCulled, bvhBuffer, triangleBuffer, materialBuffer,
 		);
 

package/src/TSL/LightsCore.js

@@ -60,6 +60,7 @@ export const PointLight = struct( {
 	intensity: 'float',
 	distance: 'float', // cutoff distance (0 = infinite)
 	decay: 'float', // decay exponent (2 = physically correct)
+	radius: 'float', // 0 = a point; else a disc of this radius facing the lit point (Cycles' soft falloff)
 } );
 
 export const SpotLight = struct( {
@@ -75,6 +76,7 @@ export const SpotLight = struct( {
 	goboIntensity: 'float', // mask strength multiplier (0 = no mask, 1 = full mask)
 	iesIndex: 'int', // -1 = no IES, otherwise index into iesProfiles array
 	iesIntensity: 'float', // blend [0,1] between flat (0) and full IES distribution (1)
+	radius: 'float', // as PointLight's
 } );
 
 export const LightSample = struct( {
@@ -173,7 +175,7 @@ export const getAreaLight = Fn( ( [ areaLightsBuffer, index ] ) => {
 
 export const getPointLight = Fn( ( [ pointLightsBuffer, index ] ) => {
 
-	const baseIndex = index.mul( 9 );
+	const baseIndex = index.mul( 10 );
 	return PointLight( {
 		position: vec3(
 			pointLightsBuffer.element( baseIndex ),
@@ -188,6 +190,7 @@ export const getPointLight = Fn( ( [ pointLightsBuffer, index ] ) => {
 		intensity: pointLightsBuffer.element( baseIndex.add( 6 ) ),
 		distance: pointLightsBuffer.element( baseIndex.add( 7 ) ),
 		decay: pointLightsBuffer.element( baseIndex.add( 8 ) ),
+		radius: pointLightsBuffer.element( baseIndex.add( 9 ) ),
 	} );
 
 } );
@@ -220,7 +223,8 @@ export const getSpotLight = Fn( ( [ spotLightsBuffer, index ] ) => {
 		goboIntensity: spotLightsBuffer.element( baseIndex.add( 15 ) ),
 		iesIndex: int( spotLightsBuffer.element( baseIndex.add( 16 ) ) ),
 		iesIntensity: spotLightsBuffer.element( baseIndex.add( 17 ) ),
-		// slots 18, 19 reserved (vec4 padding)
+		radius: spotLightsBuffer.element( baseIndex.add( 18 ) ),
+		// slot 19 reserved (vec4 padding)
 	} );
 
 } );

package/src/TSL/LightsDirect.js

@@ -2,7 +2,7 @@
 // Direct lighting calculations including shadow ray tracing
 // and contribution calculations for all light types.
 
-import { sceneResources } from './SceneResources.js';
+import { sceneResources, usesTransmissionMaps } from './SceneResources.js';
 import {
 	Fn,
 	float,
@@ -30,6 +30,7 @@ import { Ray, ShadowMaterial, HitInfo } from './Struct.js';
 import {
 	REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, instanceRows,
 	instanceFaceNormalToWorld, triangleRow, shadowFlagsSettle, offsetRayOrigin,
+	getDatafromStorageBuffer, MATERIAL_SLOT, MATERIAL_SLOTS,
 } from './Common.js';
 import { fresnelDielectric } from './Fresnel.js';
 import { calculateBeerLawAbsorption } from './MaterialTransmission.js';
@@ -49,7 +50,8 @@ const makeTraceShadowRay = ( refractiveBlocks ) => Fn( ( [
 	materialBuffer,
 ], builder ) => {
 
-	const { alphaShadows, shadowAlbedoMaps } = sceneResources( builder );
+	const { alphaShadows, shadowAlbedoMaps, linearBuckets } = sceneResources( builder );
+	const transmissionMaps = ! refractiveBlocks && usesTransmissionMaps( builder );
 	const transmittance = float( 1.0 ).toVar();
 	const rayOrigin = origin.toVar();
 	const remainingDist = float( maxDist ).toVar();
@@ -88,6 +90,19 @@ const makeTraceShadowRay = ( refractiveBlocks ) => Fn( ( [
 		// Fetch material for the hit surface (thin reader: 7 slots instead of 27)
 		const shadowMaterial = ShadowMaterial.wrap( getShadowMaterial( shadowHit.materialIndex, materialBuffer ) );
 
+		// The hit's texture coordinates through the albedo transform, which Shade reads the extension maps with too.
+		const hitTextureUV = () => {
+
+			const baryU = shadowHit.uv.x;
+			const baryV = shadowHit.uv.y;
+			const baryW = float( 1.0 ).sub( baryU ).sub( baryV );
+			const uvData1 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 3 ) );
+			const uvData2 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 4 ).xy );
+			const hitUV = uvData1.xy.mul( baryW ).add( uvData1.zw.mul( baryU ) ).add( uvData2.mul( baryV ) );
+			return getTransformedUV( { uv: hitUV, transform: shadowMaterial.albedoTransform } );
+
+		};
+
 		// ---------------------------------------------------------------
 		// Alpha-cutout handling (MASK / BLEND with albedo texture alpha)
 		// Gated by runtime uniform + alphaMode check — zero overhead for opaque materials.
@@ -106,14 +121,7 @@ const makeTraceShadowRay = ( refractiveBlocks ) => Fn( ( [
 
 				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 uvData1 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 3 ) );
-					const uvData2 = uintBitsToFloat( triangleRow( triangleBuffer, shadowHit.triangleIndex, 4 ).xy );
-					const hitUV = uvData1.xy.mul( baryW ).add( uvData1.zw.mul( baryU ) ).add( uvData2.mul( baryV ) );
-					const albedoUV = getTransformedUV( { uv: hitUV, transform: shadowMaterial.albedoTransform } );
-					texAlpha.assign( sampleBucket( shadowAlbedoMaps, shadowMaterial.albedoMapIndex, albedoUV ).a );
+					texAlpha.assign( sampleBucket( shadowAlbedoMaps, shadowMaterial.albedoMapIndex, hitTextureUV() ).a );
 
 				} );
 
@@ -167,6 +175,20 @@ const makeTraceShadowRay = ( refractiveBlocks ) => Fn( ( [
 
 		} : () => {
 
+			let transmission = shadowMaterial.transmission;
+			if ( transmissionMaps ) {
+
+				// glTF's transmission is the factor × the map's R: where the map is black the surface is opaque.
+				transmission = transmission.toVar();
+				const mapIndex = int( getDatafromStorageBuffer( materialBuffer, shadowHit.materialIndex, int( MATERIAL_SLOT.EXT_MAP_INDICES_A ), int( MATERIAL_SLOTS ) ).r ).toVar();
+				If( mapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+					transmission.mulAssign( sampleBucket( linearBuckets, mapIndex, hitTextureUV() ).r );
+
+				} );
+
+			}
+
 			// Deferred geometric-normal compute — refetch triangle positions and
 			// derive the normal here so opaque/alpha-cutout shadow hits don't pay
 			// the cross+normalize cost in BVH traversal.
@@ -204,7 +226,7 @@ const makeTraceShadowRay = ( refractiveBlocks ) => Fn( ( [
 			// Shadow rays go straight through, so both faces see the outside-in angle and eta.
 			const fresnel = fresnelDielectric( abs( dot( dir, N ) ), max( shadowMaterial.ior, 1.0 ) );
 
-			const matTransmittance = float( 1.0 ).sub( fresnel ).mul( shadowMaterial.transmission );
+			const matTransmittance = float( 1.0 ).sub( fresnel ).mul( transmission );
 			transmittance.mulAssign( matTransmittance );
 
 			// Early exit if almost no light passes through