rayzee 10.0.0 → 11.0.0

package/src/TSL/LightVisibility.js

@@ -0,0 +1,111 @@
+/**
+ * Where each kind of light gets through, learned from the shadow-ray pick's own rays (LightsSampling lightPick):
+ * tries and visible counts per cell of space and facing. Shade reads the learned half, which no kernel writes during
+ * a frame, so a render repeats; it adds to the fresh half, folded into the learned one after each frame.
+ */
+
+import { Fn, float, int, uint, If, Return, instanceIndex, abs, ceil, exp2, floor, length, log2, max, select, sqrt, atomicAdd, atomicLoad, atomicStore } from 'three/tsl';
+
+import { VISIBILITY_BASE, VISIBILITY_CELLS, VISIBILITY_KINDS, VISIBILITY_COUNTER_WORDS } from '../Processor/QueueManager.js';
+import { pcgHash } from './Random.js';
+
+export const VISIBILITY_KIND = { LAMPS: 0, ENVIRONMENT: 1, SUN: 2, EMITTERS: 3 };
+
+const LEARNED = VISIBILITY_BASE;
+const FRESH = VISIBILITY_BASE + VISIBILITY_COUNTER_WORDS;
+const SLOTS = VISIBILITY_CELLS * VISIBILITY_KINDS;
+// A cell is this share of its distance from the camera, rounded up to a power of two.
+const CELL_SHARE = 1 / 32;
+// Below it a kind is still picked now and then, so a light that comes into view is found again.
+const MIN_SHARE = 1 / 64;
+const HALVE_AT = 1 << 16;
+
+const hashIn = ( h, v ) => pcgHash( { state: h.bitXor( v ) } );
+
+/** The cell of a point and the side its surface faces. */
+export const visibilityCell = ( p, n, cameraPosition ) => {
+
+	const level = ceil( log2( max( length( p.sub( cameraPosition ) ).mul( CELL_SHARE ), 1e-6 ) ) ).toVar();
+	const c = floor( p.div( exp2( level ) ) ).toVar();
+	const a = abs( n );
+	const facing = select( a.x.greaterThan( max( a.y, a.z ) ), select( n.x.greaterThan( 0.0 ), uint( 0 ), uint( 1 ) ),
+		select( a.y.greaterThan( a.z ), select( n.y.greaterThan( 0.0 ), uint( 2 ), uint( 3 ) ), select( n.z.greaterThan( 0.0 ), uint( 4 ), uint( 5 ) ) ) );
+
+	let h = pcgHash( { state: uint( int( level ).add( 1024 ) ) } );
+	h = hashIn( h, uint( int( c.x ) ) );
+	h = hashIn( h, uint( int( c.y ) ) );
+	h = hashIn( h, uint( int( c.z ) ) );
+	h = hashIn( h, facing );
+	return h.bitAnd( uint( VISIBILITY_CELLS - 1 ) ).toVar();
+
+};
+
+const slot = ( cell, kind ) => cell.mul( uint( VISIBILITY_KINDS ) ).add( uint( kind ) ).mul( uint( 2 ) );
+
+/** √ of the share of rays that got through: the pick's best weight against a light that is on or off. */
+export const visibilityShare = ( counters, cell, kind ) => {
+
+	const at = uint( LEARNED ).add( slot( cell, kind ) ).toVar();
+	const tries = float( atomicLoad( counters.element( at ) ) );
+	const seen = float( atomicLoad( counters.element( at.add( uint( 1 ) ) ) ) );
+	return sqrt( max( seen.add( 0.5 ).div( tries.add( 1.0 ) ), MIN_SHARE ) );
+
+};
+
+export const recordVisibility = ( counters, cell, kind, visible ) => {
+
+	const at = uint( FRESH ).add( slot( cell, kind ) ).toVar();
+	atomicAdd( counters.element( at ), uint( 1 ) );
+	If( visible, () => {
+
+		atomicAdd( counters.element( at.add( uint( 1 ) ) ), uint( 1 ) );
+
+	} );
+
+};
+
+/** Adds the frame's counts to the learned ones, halving both past HALVE_AT so the table keeps up with a change. */
+export function buildVisibilityFoldKernel( { counters } ) {
+
+	return Fn( () => {
+
+		If( instanceIndex.greaterThanEqual( uint( SLOTS ) ), () => {
+
+			Return();
+
+		} );
+
+		const learned = uint( LEARNED ).add( instanceIndex.mul( uint( 2 ) ) ).toVar();
+		const fresh = uint( FRESH ).add( instanceIndex.mul( uint( 2 ) ) ).toVar();
+		const tries = atomicLoad( counters.element( learned ) ).add( atomicLoad( counters.element( fresh ) ) ).toVar();
+		const seen = atomicLoad( counters.element( learned.add( uint( 1 ) ) ) ).add( atomicLoad( counters.element( fresh.add( uint( 1 ) ) ) ) ).toVar();
+		If( tries.greaterThan( uint( HALVE_AT ) ), () => {
+
+			tries.assign( tries.shiftRight( uint( 1 ) ) );
+			seen.assign( seen.shiftRight( uint( 1 ) ) );
+
+		} );
+		atomicStore( counters.element( learned ), tries );
+		atomicStore( counters.element( learned.add( uint( 1 ) ) ), seen );
+		atomicStore( counters.element( fresh ), uint( 0 ) );
+		atomicStore( counters.element( fresh.add( uint( 1 ) ) ), uint( 0 ) );
+
+	} )().compute( SLOTS, [ 256 ] );
+
+}
+
+/** Forgets everything learned: a reset may have moved what blocks what. */
+export function buildVisibilityClearKernel( { counters } ) {
+
+	const words = 2 * VISIBILITY_COUNTER_WORDS;
+	return Fn( () => {
+
+		If( instanceIndex.lessThan( uint( words ) ), () => {
+
+			atomicStore( counters.element( uint( LEARNED ).add( instanceIndex ) ), uint( 0 ) );
+
+		} );
+
+	} )().compute( words, [ 256 ] );
+
+}

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 );