rayzee 10.0.0 → 11.1.0

package/src/TSL/PathTracerCore.js

@@ -45,8 +45,10 @@ import {
 	computeAnisoAlphas,
 	calculateBRDFWeights,
 	sheenSamplingRoughness,
+	diffuseTransmissionPdf,
 } from './MaterialProperties.js';
-import { evaluateMaterialResponseFromDots, evaluateSpecularDeltaFromDots } from './MaterialEvaluation.js';
+import { evaluateMaterialResponseFromDots, evaluateSpecularDeltaFromDots, evaluateDiffuseTransmission } from './MaterialEvaluation.js';
+import { materialLayers } from './SceneResources.js';
 
 import {
 	ImportanceSampleCosine,
@@ -71,14 +73,16 @@ export const generateSampledDirection = Fn( ( [
 	mc,
 	weightsComputed, cachedBrdfWeights,
 	materialCacheCached, cachedMaterialCache,
-] ) => {
+], builder ) => {
 
+	const layers = materialLayers( builder );
 	const resultDirection = vec3( 0.0 ).toVar();
 	const resultValue = vec3( 0.0 ).toVar();
 	const resultPdf = float( 0.0 ).toVar();
 	const resultIsTransmission = tslBool( false ).toVar();
 	const resultColorWeight = vec3( 1.0 ).toVar();
 	const resultIsDelta = tslBool( false ).toVar();
+	const resultIsDiffuseTransmission = tslBool( false ).toVar();
 
 	// Compute BRDF weights
 	const weights = cachedBrdfWeights.toVar();
@@ -114,17 +118,42 @@ export const generateSampledDirection = Fn( ( [
 	const cumulativeDiffuse = weights.diffuse.toVar();
 	const cumulativeSpecular = cumulativeDiffuse.add( weights.specular ).toVar();
 	const cumulativeSheen = cumulativeSpecular.add( weights.sheen ).toVar();
-	const cumulativeClearcoat = cumulativeSheen.add( weights.clearcoat );
+	const cumulativeClearcoat = cumulativeSheen.add( weights.clearcoat ).toVar();
+	const cumulativeDiffuseTransmission = cumulativeClearcoat.add( weights.diffuseTransmission );
 
 	// Chained If/ElseIf so emitted WGSL becomes a single mutually-exclusive branch
-	// (replaces five separate If blocks gated on a `sampled` flag — divergence hotspot)
-	If( rand.lessThan( cumulativeDiffuse ), () => {
+	// (replaces five separate If blocks gated on a `sampled` flag — divergence hotspot). A layer no material uses
+	// has weight 0, so its link could never be taken and is left out.
+	const isotropicSpecular = () => {
+
+		If( material.roughness.greaterThan( 0.0 ), () => {
+
+			const TBN = constructTBN( { N } );
+			const localV = TBN.transpose().mul( V );
+
+			// VNDF sampling
+			const localH = sampleGGXVNDF( { V: localV, roughness: material.roughness, Xi: xi } );
+			H.assign( TBN.mul( localH ) );
+
+			resultDirection.assign( reflect( V.negate(), H ) );
+
+		} ).Else( () => {
+
+			resultDirection.assign( reflect( V.negate(), N ) );
+			resultIsDelta.assign( true );
+
+		} );
+
+	};
+
+	let lobes = If( rand.lessThan( cumulativeDiffuse ), () => {
 
 		resultDirection.assign( ImportanceSampleCosine( { N, xi } ) );
 
 	} ).ElseIf( rand.lessThan( cumulativeSpecular ), () => {
 
-		If( material.anisotropy.greaterThan( 0.0 ), () => {
+		if ( ! layers.anisotropy ) isotropicSpecular();
+		else If( material.anisotropy.greaterThan( 0.0 ), () => {
 
 			// Shared frame → sampler and eval/PDF stay bit-identical (MIS consistency)
 			const f = AnisoFrame.wrap( anisoTangentFrame( N, material.anisotropyRotation ) );
@@ -138,25 +167,11 @@ export const generateSampledDirection = Fn( ( [
 
 			resultDirection.assign( reflect( V.negate(), H ) );
 
-		} ).ElseIf( material.roughness.greaterThan( 0.0 ), () => {
-
-			const TBN = constructTBN( { N } );
-			const localV = TBN.transpose().mul( V );
-
-			// VNDF sampling
-			const localH = sampleGGXVNDF( { V: localV, roughness: material.roughness, Xi: xi } );
-			H.assign( TBN.mul( localH ) );
-
-			resultDirection.assign( reflect( V.negate(), H ) );
-
-		} ).Else( () => {
-
-			resultDirection.assign( reflect( V.negate(), N ) );
-			resultIsDelta.assign( true );
+		} ).Else( isotropicSpecular );
 
-		} );
+	} );
 
-	} ).ElseIf( rand.lessThan( cumulativeSheen ), () => {
+	if ( layers.sheen ) lobes = lobes.ElseIf( rand.lessThan( cumulativeSheen ), () => {
 
 		H.assign( ImportanceSampleGGX( { N, roughness: sheenSamplingRoughness( material.sheenRoughness ), Xi: xi } ) );
 		resultDirection.assign( reflect( V.negate(), H ) );
@@ -165,7 +180,9 @@ export const generateSampledDirection = Fn( ( [
 		// would add a P(reject)·cos term to the true density that calculateBSDFSamplingPDF cannot
 		// model, and dividing by the smaller modelled density inflated the lobe 23 %.
 
-	} ).ElseIf( rand.lessThan( cumulativeClearcoat ), () => {
+	} );
+
+	if ( layers.clearcoat ) lobes = lobes.ElseIf( rand.lessThan( cumulativeClearcoat ), () => {
 
 		// VNDF, not ImportanceSampleGGX: the mixture density reports this lobe with
 		// calculateVNDFPDF, and sampling the half-vector GGX distribution instead would make the
@@ -175,7 +192,16 @@ export const generateSampledDirection = Fn( ( [
 		H.assign( ccTBN.mul( sampleGGXVNDF( { V: ccTBN.transpose().mul( V ), roughness: clearcoatRoughness, Xi: xi } ) ) );
 		resultDirection.assign( reflect( V.negate(), H ) );
 
-	} ).Else( () => {
+	} );
+
+	if ( layers.diffuseTransmission ) lobes = lobes.ElseIf( rand.lessThan( cumulativeDiffuseTransmission ), () => {
+
+		resultDirection.assign( ImportanceSampleCosine( { N: N.negate(), xi } ) );
+		resultIsDiffuseTransmission.assign( true );
+
+	} );
+
+	lobes.Else( () => {
 
 		const entering = dot( V, N ).greaterThan( 0.0 );
 		// pathWavelength=0 — the spectral lock happens downstream; colorWeight is carried out on
@@ -193,10 +219,11 @@ export const generateSampledDirection = Fn( ( [
 
 	} );
 
-	// One mixture density for every reflection lobe: any of them could have produced this
-	// direction, so the chosen lobe's own pdf is not the density we sampled from.
-	If( resultIsTransmission.not(), () => {
+	// Below the surface only the diffuse transmission lobe draws, so its own density is the mixture's.
+	const reflected = () => {
 
+		// One mixture density for every reflection lobe: any of them could have produced this
+		// direction, so the chosen lobe's own pdf is not the density we sampled from.
 		const dotsOut = DotProducts.wrap( computeDotProductsAniso( N, V, resultDirection, material ) );
 		If( resultIsDelta, () => {
 
@@ -213,7 +240,15 @@ export const generateSampledDirection = Fn( ( [
 
 		} );
 
-	} );
+	};
+
+	if ( ! layers.diffuseTransmission ) If( resultIsTransmission.not(), reflected );
+	else If( resultIsDiffuseTransmission, () => {
+
+		resultValue.assign( evaluateDiffuseTransmission( material, max( dot( N, V ), 0.001 ) ) );
+		resultPdf.assign( diffuseTransmissionPdf( weights.diffuseTransmission, dot( N, resultDirection ).negate() ) );
+
+	} ).ElseIf( resultIsTransmission.not(), reflected );
 
 	resultPdf.assign( max( resultPdf, MIN_PDF ) );
 
@@ -223,6 +258,7 @@ export const generateSampledDirection = Fn( ( [
 		pdf: resultPdf,
 		isTransmission: resultIsTransmission,
 		colorWeight: resultColorWeight,
+		isDiffuseTransmission: resultIsDiffuseTransmission,
 	} );
 
 } );

package/src/TSL/Random.js

@@ -107,7 +107,7 @@ export const RandomPointInCircle = ( rngState ) => {
 //       +7  ground-catcher cosine BSDF   (ShadeKernel)
 //       +8  indirect-strategy direction  (LightsIndirect)
 //       +9  physical-sky sun disc        (LightsSampling)
-//   1D  +0  (free — was the {lights,BRDF} stochastic strategy pick)
+//   1D  +0  light kind for the picked shadow ray (LightsSampling lightPick, setting shadowRays)
 //       +1  emissive-triangle pick       (EmissiveSampling / LightBVHSampling)
 //       +2  BSDF lobe selection          (ShadeKernel)
 //       +3  Russian roulette             (PathTracerCore)
@@ -123,6 +123,8 @@ export const RandomPointInCircle = ( rngState ) => {
 //      +13  clearcoat lobe               (Clearcoat)
 //      +14  area/spot light phi          (LightsSampling)
 //      +15  light uv second component    (LightsSampling)
+//      +16  light path to connect to     (ConnectKernel, bidirectional)
+//      +17  light vertex on that path    (ConnectKernel, bidirectional)
 //
 // Stride is 32 rather than the ~16 in use so a new call site does not force a renumbering.
 // The index only keys a scramble seed, so spare slots cost nothing.
@@ -131,6 +133,8 @@ export const RandomPointInCircle = ( rngState ) => {
 // the next bounce's dimensions, so they live above AUX_BASE:
 //   AUX_BASE +  0..63   env-backdrop blur taps      (ShadeKernel)
 //   AUX_BASE + 64..    light reservoir, one dimension per scene light (LightsSampling)
+//   AUX_BASE + 2048..  light subpath emission (LightGenerateKernel); light paths draw at pixels
+//                      offset by LIGHT_PIXEL_ROW_OFFSET rows, so no camera path shares a sequence
 export const SAMPLER_DIMS_PER_BOUNCE = 32;
 export const SAMPLER_DIM_AUX_BASE = 4096;
 

package/src/TSL/SceneResources.js

@@ -0,0 +1,51 @@
+/**
+ * A renderer's own scene resources for its shaders: material texture buckets, the albedo maps alpha-cutout
+ * shadow rays read, gobo and IES textures, and the alpha-shadow switch. They ride in the build context of each
+ * kernel that reads them: a TSL function's body runs when its kernel compiles, often at the first dispatch, so
+ * module-level state was read from whichever renderer — or pipeline stage — had set it last.
+ *
+ * @typedef {Object} SceneResources
+ * @property {Array<Node>} srgbBuckets - sRGB material bucket texture nodes (albedo, emissive, sheen, specular colour)
+ * @property {Array<Node>} linearBuckets - linear material bucket texture nodes
+ * @property {?Array<Node>} shadowAlbedoMaps - sRGB buckets alpha-cutout shadow rays sample, or null
+ * @property {?Node} goboMaps - spot / directional gobo texture array, or null
+ * @property {?Node} iesProfiles - IES profile texture array, or null
+ * @property {?Node} alphaShadows - int uniform, 1 = shadow rays test texture alpha; null = never
+ * @property {?Object<string, boolean>} materialLayers - the MATERIAL_LAYERS some material uses; null = all of them
+ */
+
+import { context } from 'three/tsl';
+
+const KEY = 'rayzeeScene';
+
+/** Builds `node` (a kernel's root call) with these resources in its context. */
+export const withSceneResources = ( node, resources ) => context( node, { [ KEY ]: resources } );
+
+/**
+ * The resources of the kernel being built; call from a TSL function body with its builder.
+ * @returns {SceneResources}
+ */
+export function sceneResources( builder ) {
+
+	const resources = builder.context[ KEY ];
+	if ( ! resources ) throw new Error( 'this kernel samples scene resources: build its root with withSceneResources()' );
+	return resources;
+
+}
+
+/** The material layers a kernel compiles only while some material in its scene has them. */
+export const MATERIAL_LAYERS = Object.freeze( [ 'clearcoat', 'sheen', 'iridescence', 'anisotropy', 'subsurface', 'dispersion', 'diffuseTransmission' ] );
+
+/** Every layer compiled in. */
+export const ALL_MATERIAL_LAYERS = Object.freeze( Object.fromEntries( MATERIAL_LAYERS.map( ( layer ) => [ layer, true ] ) ) );
+
+/**
+ * The material layers the kernel being built compiles; call from a TSL function body with its builder. A layer no
+ * material uses is left out of every function that reads it. Outside a scene kernel (a test), every layer is in.
+ * @returns {Object<string, boolean>}
+ */
+export function materialLayers( builder ) {
+
+	return builder.context[ KEY ]?.materialLayers ?? ALL_MATERIAL_LAYERS;
+
+}