rayzee 9.4.2 → 9.5.0

package/src/TSL/LightSplatKernel.js

@@ -0,0 +1,165 @@
+/**
+ * LightSplatKernel.js — light tracing: every stored light vertex to the pinhole, into the pixel it
+ * projects to. Fixed-point u32 channels: WGSL has no float atomics, and integer sums are order-free.
+ */
+
+import {
+	Fn, float, vec3, vec4, int, uint, If, instanceIndex, atomicAdd, atomicLoad, atomicStore, Return,
+	dot, sqrt, max, min, floor, length, localId, workgroupId,
+} from 'three/tsl';
+
+import { evaluateMaterialResponse } from './MaterialEvaluation.js';
+import { calculateMaterialPDF } from './LightsSampling.js';
+import { traceShadowRayRefractiveOpaque } from './LightsDirect.js';
+import { traverseBVHShadowCameraCulled } from './BVHTraversal.js';
+import { offsetRayOrigin, SHADOW_END, sanitizeRGB } from './Common.js';
+import { pcgHash } from './Random.js';
+import { regularizePathContribution } from './PathTracerCore.js';
+import { resolveSurfaceMaterial, lightEndCosine, misPartial, misWeight, strategyWeight, STRATEGY, SPLAT_SCALE, SPLAT_MAX } from './Bidirectional.js';
+import {
+	cachedVertex, readVertexRecord, readLightPathLength, readRayRadiance, writeRayRadiance,
+} from '../Processor/PackedRayBuffer.js';
+
+const WG_SIZE = 256;
+const RESOLVE_WG_SIZE = 16;
+
+export function buildLightSplatKernel( params ) {
+
+	const {
+		hitBufferRO, splatBuffer,
+		bvhBuffer, triangleBuffer, materialBuffer,
+		lightPaths, slotsPerPath, lightTag, strategyView,
+		cameraPosition, cameraForward, cameraViewMatrix, cameraProjectionMatrix, pixelArea,
+		renderWidth, renderHeight,
+		globalIlluminationIntensity, fireflyThreshold, accumFrame, frame,
+		mergeVm = null,
+	} = params;
+
+	return Fn( () => {
+
+		const slot = instanceIndex.toVar();
+		If( slot.greaterThanEqual( lightPaths.mul( slotsPerPath ) ), () => {
+
+			Return();
+
+		} );
+
+		const c = slot.mod( slotsPerPath ).toVar();
+		const stored = readLightPathLength( hitBufferRO, cachedVertex( slot.sub( c ) ), lightTag );
+		If( c.greaterThanEqual( stored ), () => {
+
+			Return();
+
+		} );
+
+		const record = readVertexRecord( hitBufferRO, cachedVertex( slot ) );
+		const v = { ...record, vm: mergeVm?.( record.position ) ?? null };
+
+		const toCamera = cameraPosition.sub( v.position ).toVar();
+		const dist2 = max( dot( toCamera, toCamera ), 1e-12 ).toVar();
+		const dir = toCamera.div( sqrt( dist2 ) ).toVar();
+		const cosFacet = dot( dir, v.facetN ).toVar();
+		const cosCamera = dot( dir, cameraForward ).negate().toVar();
+		// The camera is this vertex's viewer: like a camera path, only the facet decides which side it is on.
+		If( cosFacet.lessThanEqual( 0.0 ).or( cosCamera.lessThanEqual( 1e-6 ) ).or( v.extra.notEqual( uint( 0 ) ) ), () => {
+
+			Return();
+
+		} );
+
+		const clip = cameraProjectionMatrix.mul( cameraViewMatrix.mul( vec4( v.position, 1.0 ) ) ).toVar();
+		If( clip.w.lessThanEqual( 0.0 ), () => {
+
+			Return();
+
+		} );
+
+		const px = floor( clip.x.div( clip.w ).mul( 0.5 ).add( 0.5 ).mul( float( renderWidth ) ) ).toVar();
+		const py = floor( float( 0.5 ).sub( clip.y.div( clip.w ).mul( 0.5 ) ).mul( float( renderHeight ) ) ).toVar();
+		If( px.lessThan( 0.0 ).or( py.lessThan( 0.0 ) ).or( px.greaterThanEqual( float( renderWidth ) ) ).or( py.greaterThanEqual( float( renderHeight ) ) ), () => {
+
+			Return();
+
+		} );
+
+		const material = resolveSurfaceMaterial( v.materialIndex, v.uv, v.N, materialBuffer );
+		const f = evaluateMaterialResponse( dir, v.V, v.N, material ).toVar();
+
+		// The pinhole's solid-angle density for a uniform point in a pixel: 1 / (A_pixel cos³θ).
+		const cameraPdfW = float( 1.0 ).div( pixelArea.mul( cosCamera ).mul( cosCamera ).mul( cosCamera ) );
+		const toSurface = cameraPdfW.div( dist2 ).toVar();
+
+		// Georgiev (46); the camera side has no sum of its own.
+		const wLight = misPartial( toSurface.mul( cosFacet ).div( float( lightPaths ) ), v, calculateMaterialPDF( dir, v.V, v.N, material ) );
+		const bounces = c.add( uint( 1 ) );
+		const gi = float( 1.0 ).toVar();
+		If( bounces.greaterThan( uint( 1 ) ), () => {
+
+			gi.assign( globalIlluminationIntensity );
+
+		} );
+
+		const contribution = regularizePathContribution(
+			v.throughput.mul( f ).mul( lightEndCosine( v.V, v.N, v.facetN, dir ) )
+				.mul( toSurface.div( float( lightPaths ) ).mul( strategyWeight( strategyView, STRATEGY.LIGHT_TRACE, misWeight( wLight, float( 0.0 ) ) ) ).mul( gi ) ),
+			float( c ), fireflyThreshold, int( accumFrame ),
+		).toVar();
+
+		const origin = offsetRayOrigin( v.position, 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.
+		const visibility = traceShadowRayRefractiveOpaque(
+			origin, segment.div( segmentLength ), segmentLength.mul( SHADOW_END ),
+			traverseBVHShadowCameraCulled, bvhBuffer, triangleBuffer, materialBuffer,
+		);
+
+		If( visibility.greaterThan( 0.0 ), () => {
+
+			const value = min( sanitizeRGB( contribution.mul( visibility ) ), vec3( SPLAT_MAX ) ).mul( SPLAT_SCALE ).toVar();
+			const dither = float( pcgHash( { state: slot.bitXor( uint( frame ).mul( uint( 0x9E3779B9 ) ) ) } ).shiftRight( uint( 8 ) ) ).mul( 1.0 / 16777216.0 ).toVar();
+			const base = uint( py ).mul( uint( renderWidth ) ).add( uint( px ) ).mul( uint( 3 ) ).toVar();
+			atomicAdd( splatBuffer.element( base ), uint( floor( value.x.add( dither ) ) ) );
+			atomicAdd( splatBuffer.element( base.add( uint( 1 ) ) ), uint( floor( value.y.add( dither ) ) ) );
+			atomicAdd( splatBuffer.element( base.add( uint( 2 ) ) ), uint( floor( value.z.add( dither ) ) ) );
+
+		} );
+
+	} );
+
+}
+
+export function buildSplatResolveKernel( params ) {
+
+	const { rayBufferRW, splatBuffer, renderWidth, chunkRowBase, chunkRows } = params;
+
+	return Fn( () => {
+
+		const gx = int( workgroupId.x ).mul( RESOLVE_WG_SIZE ).add( int( localId.x ) );
+		const localGy = int( workgroupId.y ).mul( RESOLVE_WG_SIZE ).add( int( localId.y ) );
+
+		If( gx.lessThan( renderWidth ).and( localGy.lessThan( chunkRows ) ), () => {
+
+			const rayID = uint( localGy.mul( renderWidth ).add( gx ) );
+			const base = uint( localGy.add( chunkRowBase ).mul( renderWidth ).add( gx ) ).mul( uint( 3 ) ).toVar();
+			const r = atomicLoad( splatBuffer.element( base ) ).toVar();
+			const g = atomicLoad( splatBuffer.element( base.add( uint( 1 ) ) ) ).toVar();
+			const b = atomicLoad( splatBuffer.element( base.add( uint( 2 ) ) ) ).toVar();
+
+			If( r.bitOr( g ).bitOr( b ).notEqual( uint( 0 ) ), () => {
+
+				atomicStore( splatBuffer.element( base ), uint( 0 ) );
+				atomicStore( splatBuffer.element( base.add( uint( 1 ) ) ), uint( 0 ) );
+				atomicStore( splatBuffer.element( base.add( uint( 2 ) ) ), uint( 0 ) );
+				const radiance = readRayRadiance( rayBufferRW, rayID ).toVar();
+				writeRayRadiance( rayBufferRW, rayID, vec4( radiance.xyz.add( vec3( float( r ), float( g ), float( b ) ).div( SPLAT_SCALE ) ), radiance.w ) );
+
+			} );
+
+		} );
+
+	} );
+
+}
+
+export { WG_SIZE as LIGHT_SPLAT_WG_SIZE, RESOLVE_WG_SIZE as SPLAT_RESOLVE_WG_SIZE };

package/src/TSL/LightsCore.js

@@ -1,6 +1,7 @@
 // Lights Core - Ported from lights_core.fs
 // Light data structures, access functions, and utility functions
 
+import { sceneResources } from './SceneResources.js';
 import {
 	Fn, wgslFn,
 	vec2,
@@ -268,28 +269,14 @@ export const getSpotAttenuation = /*@__PURE__*/ wgslFn( `
 // SPOT LIGHT GOBO (PROJECTION MASK) SAMPLING
 // ================================================================================
 
-// Module-level state for spot light gobo masks.
-// Set by ShaderBuilder before graph construction.
-let _goboMapsTexNode = null;
-
-/**
- * Set the DataArrayTexture node used to sample spot light gobo masks.
- * Must be called before the shader graph is constructed.
- * @param {TextureNode} node - TSL texture node for the gobo DataArrayTexture
- */
-export function setGoboMapsTexture( node ) {
-
-	_goboMapsTexNode = node;
-
-}
-
 // Sample a spot light's gobo mask. Returns 1.0 if no gobo assigned.
 // Projects the surface direction onto a plane perpendicular to the light's
 // forward axis at unit distance; cone edge maps to UV ±0.5 around centre.
 //
 // `lightDir` = unit direction from surface TO light (matches `LightSample.direction`).
-export const sampleSpotGoboMask = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
+export const sampleSpotGoboMask = /*@__PURE__*/ Fn( ( [ light, lightDir ], builder ) => {
 
+	const { goboMaps } = sceneResources( builder );
 	const mask = float( 1.0 ).toVar();
 
 	If( light.goboIndex.greaterThanEqual( int( 0 ) ), () => {
@@ -319,13 +306,13 @@ export const sampleSpotGoboMask = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
 			const u = clamp( px.mul( invTan ).add( 0.5 ), float( 0.0 ), float( 1.0 ) );
 			const v = clamp( py.mul( invTan ).add( 0.5 ), float( 0.0 ), float( 1.0 ) );
 
-			if ( _goboMapsTexNode ) {
+			if ( goboMaps ) {
 
 				// Sample min(.r, .a) so masks encoded in either RGB-luminance
 				// or alpha (Kenney's "Transparent" variants store the shape in alpha
 				// with RGB=white) both produce the expected result.
 				// Sign of goboIntensity encodes inversion: negative = inverted, |value| = strength.
-				const tex = texture( _goboMapsTexNode, vec2( u, v ) ).depth( light.goboIndex );
+				const tex = texture( goboMaps, vec2( u, v ) ).depth( light.goboIndex );
 				const sample = min( tex.r, tex.a );
 				const inverted = light.goboIntensity.lessThan( 0.0 );
 				const effective = select( inverted, float( 1.0 ).sub( sample ), sample );
@@ -353,8 +340,9 @@ export const sampleSpotGoboMask = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
 // can cover any scene size by adjusting the scale.
 //
 // `surfacePoint` = world-space position of the surface being shaded.
-export const sampleDirectionalGoboMask = /*@__PURE__*/ Fn( ( [ light, surfacePoint ] ) => {
+export const sampleDirectionalGoboMask = /*@__PURE__*/ Fn( ( [ light, surfacePoint ], builder ) => {
 
+	const { goboMaps } = sceneResources( builder );
 	const mask = float( 1.0 ).toVar();
 
 	If( light.goboIndex.greaterThanEqual( int( 0 ) ), () => {
@@ -379,9 +367,9 @@ export const sampleDirectionalGoboMask = /*@__PURE__*/ Fn( ( [ light, surfacePoi
 		const uTiled = u.sub( u.floor() );
 		const vTiled = v.sub( v.floor() );
 
-		if ( _goboMapsTexNode ) {
+		if ( goboMaps ) {
 
-			const tex = texture( _goboMapsTexNode, vec2( uTiled, vTiled ) ).depth( light.goboIndex );
+			const tex = texture( goboMaps, vec2( uTiled, vTiled ) ).depth( light.goboIndex );
 			const sample = min( tex.r, tex.a );
 			const inverted = light.goboIntensity.lessThan( 0.0 );
 			const effective = select( inverted, float( 1.0 ).sub( sample ), sample );
@@ -400,20 +388,6 @@ export const sampleDirectionalGoboMask = /*@__PURE__*/ Fn( ( [ light, surfacePoi
 // IES PROFILE (PHOTOMETRIC INTENSITY) SAMPLING
 // ================================================================================
 
-// Module-level texture node for IES profile DataArrayTexture.
-// Set by ShaderBuilder before graph construction.
-let _iesProfilesTexNode = null;
-
-/**
- * Bind the DataArrayTexture node carrying all loaded IES profiles.
- * @param {TextureNode} node
- */
-export function setIESProfilesTexture( node ) {
-
-	_iesProfilesTexNode = node;
-
-}
-
 // Sample a spot light's IES profile. Returns a normalized multiplier in [0,1]
 // (or 1.0 if no profile assigned).
 //
@@ -421,8 +395,9 @@ export function setIESProfilesTexture( node ) {
 // where V=0 is along the light's "forward" axis (the spot's direction).
 //
 // `lightDir` = unit direction from surface TO light (matches LightSample.direction).
-export const sampleIESProfile = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
+export const sampleIESProfile = /*@__PURE__*/ Fn( ( [ light, lightDir ], builder ) => {
 
+	const { iesProfiles } = sceneResources( builder );
 	const result = float( 1.0 ).toVar();
 
 	If( light.iesIndex.greaterThanEqual( int( 0 ) ), () => {
@@ -451,9 +426,9 @@ export const sampleIESProfile = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
 		const phi = atan( py, px );
 		const u = phi.div( float( 2.0 * Math.PI ) ).add( 0.5 );
 
-		if ( _iesProfilesTexNode ) {
+		if ( iesProfiles ) {
 
-			const sample = texture( _iesProfilesTexNode, vec2( u, v ) ).depth( light.iesIndex ).r;
+			const sample = texture( iesProfiles, vec2( u, v ) ).depth( light.iesIndex ).r;
 			// Blend between flat (1.0) and full profile by iesIntensity.
 			const strength = clamp( light.iesIntensity, float( 0.0 ), float( 1.0 ) );
 			result.assign( mix( float( 1.0 ), sample, strength ) );

package/src/TSL/LightsDirect.js

@@ -2,6 +2,7 @@
 // Direct lighting calculations including shadow ray tracing
 // and contribution calculations for all light types.
 
+import { sceneResources } from './SceneResources.js';
 import {
 	Fn,
 	float,
@@ -28,43 +29,27 @@ import {
 import { Ray, ShadowMaterial, HitInfo } from './Struct.js';
 import {
 	REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, instanceRows,
-	instanceFaceNormalToWorld, triangleRow, getAlphaShadowsUniform, shadowFlagsSettle, offsetRayOrigin,
+	instanceFaceNormalToWorld, triangleRow, shadowFlagsSettle, offsetRayOrigin,
 } from './Common.js';
 import { fresnelDielectric } from './Fresnel.js';
 import { calculateBeerLawAbsorption } from './MaterialTransmission.js';
 import { getTransformedUV, sampleBucket } from './TextureSampling.js';
 
-// Module-level state for alpha-cutout shadow testing.
-// Set by PathTracer before shade-graph construction.
-let _shadowAlbedoMaps = null;
-
-export { setAlphaShadowsUniform } from './Common.js';
-
-/**
- * Set the sRGB bucket texture node array for alpha-aware shadow rays (albedo alpha).
- * Must be called before the shade graph is constructed.
- * @param {Array} buckets - K sRGB bucket texture nodes
- */
-export function setShadowAlbedoMaps( buckets ) {
-
-	_shadowAlbedoMaps = buckets;
-
-}
-
 // ================================================================================
 // SHADOW RAY TRACING
 // ================================================================================
 
 // Note: traverseBVH is passed as a parameter to avoid circular dependency
-export const traceShadowRay = Fn( ( [
+const makeTraceShadowRay = ( refractiveBlocks ) => Fn( ( [
 	origin, dir, maxDist,
 	// BVH traversal function and textures passed as parameters
 	traverseBVHShadowFn,
 	bvhBuffer,
 	triangleBuffer,
 	materialBuffer,
-] ) => {
+], builder ) => {
 
+	const { alphaShadows, shadowAlbedoMaps } = sceneResources( builder );
 	const transmittance = float( 1.0 ).toVar();
 	const rayOrigin = origin.toVar();
 	const remainingDist = float( maxDist ).toVar();
@@ -93,7 +78,7 @@ export const traceShadowRay = Fn( ( [
 		// alphaMode/transparent/transmission/opacity all indicate a fully opaque surface.
 		// Short-circuits the 7-slot getShadowMaterial fetch and the whole alpha decision tree.
 		const flags = triangleRow( triangleBuffer, shadowHit.triangleIndex, 4 ).z;
-		If( shadowFlagsSettle( flags ), () => {
+		If( shadowFlagsSettle( flags, alphaShadows ), () => {
 
 			transmittance.assign( 0.0 );
 			Break();
@@ -111,14 +96,13 @@ export const traceShadowRay = Fn( ( [
 		// ---------------------------------------------------------------
 		const alphaCutout = tslBool( false ).toVar();
 
-		const alphaShadows = getAlphaShadowsUniform();
 		if ( alphaShadows ) If( alphaShadows.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 ( shadowAlbedoMaps ) {
 
 				If( shadowMaterial.albedoMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
@@ -129,7 +113,7 @@ export const traceShadowRay = Fn( ( [
 					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, albedoUV ).a );
 
 				} );
 
@@ -176,7 +160,12 @@ export const traceShadowRay = Fn( ( [
 			rayOrigin.assign( shadowHit.hitPoint.add( dir.mul( alphaEps ) ) );
 			remainingDist.subAssign( shadowHit.dst.add( alphaEps ) );
 
-		} ).ElseIf( shadowMaterial.transmission.greaterThan( 0.0 ), () => {
+		} ).ElseIf( shadowMaterial.transmission.greaterThan( 0.0 ), refractiveBlocks ? () => {
+
+			transmittance.assign( 0.0 );
+			Break();
+
+		} : () => {
 
 			// Deferred geometric-normal compute — refetch triangle positions and
 			// derive the normal here so opaque/alpha-cutout shadow hits don't pay
@@ -262,6 +251,11 @@ export const traceShadowRay = Fn( ( [
 
 } );
 
+export const traceShadowRay = /*@__PURE__*/ makeTraceShadowRay( false );
+
+// For the bidirectional strategies: their light paths carry what refracts, so glass must block.
+export const traceShadowRayRefractiveOpaque = /*@__PURE__*/ makeTraceShadowRay( true );
+
 // ================================================================================
 // RAY OFFSET CALCULATION
 // ================================================================================
@@ -273,9 +267,14 @@ export const calculateRayOffset = Fn( ( [ hitPoint, normal ] ) => offsetRayOrigi
 // LIGHT IMPORTANCE ESTIMATION
 // ================================================================================
 
+// A light's cosine for importance: either side for a surface that passes light through diffusely.
+const importanceCosine = ( normal, direction, material ) => select(
+	material.diffuseTransmission.greaterThan( 0.0 ), abs( dot( normal, direction ) ), max( float( 0.0 ), dot( normal, direction ) ),
+);
+
 export const calculateDirectionalLightImportance = Fn( ( [ light, normal, material, bounceIndex ] ) => {
 
-	const NoL = max( float( 0.0 ), dot( normal, light.direction ) );
+	const NoL = importanceCosine( normal, light.direction, material );
 	const result = float( 0.0 ).toVar();
 
 	If( NoL.greaterThan( 0.0 ), () => {
@@ -312,7 +311,7 @@ export const estimateLightImportance = Fn( ( [ light, hitPoint, normal, material
 	const distSq = dist.mul( dist );
 
 	const lightDir = toLight.div( dist );
-	const NoL = max( dot( normal, lightDir ), 0.0 );
+	const NoL = importanceCosine( normal, lightDir, material );
 	const result = float( 0.0 ).toVar();
 
 	If( NoL.greaterThan( 0.0 ), () => {
@@ -366,7 +365,7 @@ export const calculatePointLightImportance = Fn( ( [ light, hitPoint, normal, ma
 
 		const dist = sqrt( distSq );
 		const lightDir = toLight.div( dist );
-		const NoL = max( float( 0.0 ), dot( normal, lightDir ) );
+		const NoL = importanceCosine( normal, lightDir, material );
 
 		If( NoL.greaterThan( 0.0 ), () => {
 
@@ -417,7 +416,7 @@ export const calculateSpotLightImportance = Fn( ( [ light, hitPoint, normal, mat
 	If( distSq.greaterThanEqual( 0.001 ), () => {
 
 		const lightDir = toLight.div( sqrt( distSq ) );
-		const NoL = max( float( 0.0 ), dot( normal, lightDir ) );
+		const NoL = importanceCosine( normal, lightDir, material );
 
 		If( NoL.greaterThan( 0.0 ), () => {
 

package/src/TSL/LightsIndirect.js

@@ -32,6 +32,8 @@ export const calculateIndirectLighting = Fn( ( [
 	brdfSampleDirection, brdfSamplePdf, brdfSampleValue,
 	// DirectionSample carries these so refraction throughput does not need a second sampler run.
 	isTransmission, brdfSampleColorWeight,
+	// Drawn through the surface by the diffuse transmission lobe: its cosine is taken below N.
+	isDiffuseTransmission,
 	rngState,
 	pixelCoord, resolution, frame, dimBase,
 ] ) => {
@@ -61,7 +63,7 @@ export const calculateIndirectLighting = Fn( ( [
 		//
 		// brdfSamplePdf is now the true mixture density (calculateBSDFSamplingPDF), so the
 		// estimator is just f·NoL/pdf and the MIS pairs share one function by construction.
-		const NoL = max( dot( N, brdfSampleDirection ), 0.0 ).toVar();
+		const NoL = select( isDiffuseTransmission, dot( N, brdfSampleDirection ).negate(), max( dot( N, brdfSampleDirection ), 0.0 ) ).toVar();
 		const pdf = max( brdfSamplePdf, MIN_PDF ).toVar();
 
 		r_direction.assign( brdfSampleDirection );