rayzee 7.2.1 → 7.4.0

package/src/TSL/FinalWriteKernel.js

@@ -34,12 +34,13 @@ export function buildFinalWriteKernel( params ) {
 		transparentBackground,
 		prevAccumTexture, prevNormalDepthTexture, prevAlbedoTexture,
 		renderWidth, renderHeight,
-		// Multi-sample: average S sample-slots per pixel (slot = pixel + k*w*h, w*h from the resolution uniform).
-		samplesPerPass = 1,
 		visMode,
+		// Aux MRT (normalDepth + albedo) feeds only the denoiser/OIDN. Gated by a live uniform (1 = denoiser
+		// on): when off, skip the G-buffer decode, the prev-frame aux mix, and the two aux stores.
+		auxGBufferEnabled,
 	} = params;
 
-	const S = samplesPerPass | 0;
+	const auxOn = auxGBufferEnabled.greaterThan( uint( 0 ) );
 
 	const computeFn = Fn( () => {
 
@@ -51,31 +52,21 @@ export function buildFinalWriteKernel( params ) {
 			const pixelIndex = gy.mul( int( resolution.x ) ).add( gx );
 			const rayID = uint( pixelIndex );
 
-			// Average the S sub-samples; MRT (normal/depth/albedo) from sub-sample 0.
-			const sampleColor = ( () => {
-
-				if ( S <= 1 ) return readRayRadiance( rayBufferRO, rayID );
-				const acc = readRayRadiance( rayBufferRO, rayID ).toVar();
-				const mrps = uint( resolution.x ).mul( uint( resolution.y ) ).toVar(); // w*h from the resolution uniform, not baked
-				for ( let k = 1; k < S; k ++ ) {
-
-					acc.addAssign( readRayRadiance( rayBufferRO, rayID.add( uint( k ).mul( mrps ) ) ) );
-
-				}
+			const sampleColor = readRayRadiance( rayBufferRO, rayID );
+			const finalColor = sampleColor.xyz.toVar();
+			const outputAlpha = select( transparentBackground, sampleColor.w, float( 1.0 ) ).toVar();
 
-				acc.assign( acc.div( float( S ) ) );
-				return acc;
+			// MRT comes from the per-pixel G-buffer (rayID == pixelIndex). Half-packed: decode.
+			// auxOn gates the decode + stores so a no-denoiser frame does no G-buffer read and no aux writes.
+			const finalNormalDepth = vec4( 0.0 ).toVar();
+			const finalAlbedo = vec4( 0.0 ).xyz.toVar();
+			If( auxOn, () => {
 
-			} )();
-			// MRT comes from the per-pixel G-buffer (rayID == pixelIndex here, i.e. sub-sample 0). Half-packed: decode.
-			const gbuf = readGBuffer( gBufferRO, rayID );
-			const normalDepth = gbDecodeNormalDepth( gbuf );
-			const albedoID = vec4( gbDecodeAlbedo( gbuf ), 0.0 );
+				const gbuf = readGBuffer( gBufferRO, rayID );
+				finalNormalDepth.assign( gbDecodeNormalDepth( gbuf ) );
+				finalAlbedo.assign( vec4( gbDecodeAlbedo( gbuf ), 0.0 ).xyz );
 
-			const finalColor = sampleColor.xyz.toVar();
-			const finalNormalDepth = normalDepth.toVar();
-			const finalAlbedo = albedoID.xyz.toVar();
-			const outputAlpha = select( transparentBackground, sampleColor.w, float( 1.0 ) ).toVar();
+			} );
 
 			const pixelCoord = vec2( float( gx ).add( 0.5 ), float( gy ).add( 0.5 ) );
 			const prevUV = pixelCoord.div( resolution );
@@ -87,8 +78,12 @@ export function buildFinalWriteKernel( params ) {
 				const prevAccumSample = texture( prevAccumTexture, prevUV, 0 ).toVar();
 
 				finalColor.assign( mix( prevAccumSample.xyz, sampleColor.xyz, accumulationAlpha ) );
-				finalNormalDepth.assign( mix( texture( prevNormalDepthTexture, prevUV, 0 ), finalNormalDepth, accumulationAlpha ) );
-				finalAlbedo.assign( mix( texture( prevAlbedoTexture, prevUV, 0 ).xyz, finalAlbedo, accumulationAlpha ) );
+				If( auxOn, () => {
+
+					finalNormalDepth.assign( mix( texture( prevNormalDepthTexture, prevUV, 0 ), finalNormalDepth, accumulationAlpha ) );
+					finalAlbedo.assign( mix( texture( prevAlbedoTexture, prevUV, 0 ).xyz, finalAlbedo, accumulationAlpha ) );
+
+				} );
 
 				If( transparentBackground, () => {
 
@@ -107,8 +102,12 @@ export function buildFinalWriteKernel( params ) {
 
 			const uintCoord = uvec2( uint( gx ), uint( gy ) );
 			textureStore( writeColorTex, uintCoord, vec4( finalColor, outputAlpha ) ).toWriteOnly();
-			textureStore( writeNDTex, uintCoord, finalNormalDepth ).toWriteOnly();
-			textureStore( writeAlbedoTex, uintCoord, vec4( finalAlbedo, 1.0 ) ).toWriteOnly();
+			If( auxOn, () => {
+
+				textureStore( writeNDTex, uintCoord, finalNormalDepth ).toWriteOnly();
+				textureStore( writeAlbedoTex, uintCoord, vec4( finalAlbedo, 1.0 ) ).toWriteOnly();
+
+			} );
 
 		} );
 

package/src/TSL/GenerateKernel.js

@@ -33,39 +33,32 @@ export function buildGenerateKernel( params ) {
 		cameraWorldMatrix, cameraProjectionMatrixInverse,
 		enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
 		renderWidth, renderHeight,
-		// Multi-sample: S primary rays/pixel/frame; S>1 dispatch covers h*S rows, ray lands in slot subSample*(w*h) + pixelIndex.
-		samplesPerPass = 1,
 		transmissiveBounces, // per-ray refraction budget (megakernel parity: PathTracerCore.js:606)
 		transparentBackground, // alpha inits to 1 here (megakernel parity: PathTracerCore.js:554) — env-escape-without-opaque zeroes it in Shade
+		auxGBufferEnabled, // live uniform: 1 = init the per-pixel G-buffer (denoiser on), 0 = skip it
 	} = params;
 
-	const S = samplesPerPass | 0;
+	const auxOn = auxGBufferEnabled.greaterThan( uint( 0 ) );
 
 	const computeFn = Fn( () => {
 
 		const gx = int( workgroupId.x ).mul( WG_SIZE ).add( int( localId.x ) );
-		const gyRaw = int( workgroupId.y ).mul( WG_SIZE ).add( int( localId.y ) );
+		const gy = int( workgroupId.y ).mul( WG_SIZE ).add( int( localId.y ) );
 
-		const subSample = S > 1 ? gyRaw.div( renderHeight ).toVar() : int( 0 );
-		const gy = S > 1 ? gyRaw.sub( subSample.mul( renderHeight ) ).toVar() : gyRaw;
-		const yBound = S > 1 ? renderHeight.mul( int( S ) ) : renderHeight;
-
-		If( gx.lessThan( renderWidth ).and( gyRaw.lessThan( yBound ) ), () => {
+		If( gx.lessThan( renderWidth ).and( gy.lessThan( renderHeight ) ), () => {
 
 			const pixelCoord = vec2( float( gx ).add( 0.5 ), float( gy ).add( 0.5 ) );
 			const pixelIndex = gy.mul( int( resolution.x ) ).add( gx );
-			// maxRaysPerSample = w*h, derived from the resolution uniform (NOT baked) so resize never changes the WGSL.
-			const rayID = S > 1
-				? uint( pixelIndex ).add( uint( subSample ).mul( uint( resolution.x ).mul( uint( resolution.y ) ) ) )
-				: uint( pixelIndex );
+			// One ray per pixel: rayID is the pixel index.
+			const rayID = uint( pixelIndex );
 
 			const screenPosition = pixelCoord.div( resolution ).mul( 2.0 ).sub( 1.0 ).toVar();
 			screenPosition.y.assign( screenPosition.y.negate() );
 
-			const baseSeed = getDecorrelatedSeed( { pixelCoord, rayIndex: subSample, frame } ).toVar();
+			const baseSeed = getDecorrelatedSeed( { pixelCoord, rayIndex: int( 0 ), frame } ).toVar();
 			const seed = pcgHash( { state: baseSeed } ).toVar();
 
-			const stratifiedJitter = getStratifiedSample( pixelCoord, subSample, int( S ), seed, resolution, frame ).toVar();
+			const stratifiedJitter = getStratifiedSample( pixelCoord, int( 0 ), int( 1 ), seed, resolution, frame ).toVar();
 
 			const jitterScale = vec2( 2.0 ).div( resolution );
 			const jitter = stratifiedJitter.sub( 0.5 ).mul( jitterScale );
@@ -78,6 +71,8 @@ export function buildGenerateKernel( params ) {
 			) );
 
 			writeRayOriginMeta( rayBufferRW, rayID, ray.origin, int( 0 ), int( 0 ) );
+			// 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 ) );
 			// pdf inits to 0 = prevBouncePdf (megakernel parity PathTracerCore.js:556). The bounce>0 env/emissive
 			// MIS gate skips until an opaque scatter writes a real combinedPdf; free bounces preserve it.
@@ -87,7 +82,7 @@ export function buildGenerateKernel( params ) {
 			// keeps alpha 1 → solid. Non-transparent mode is inert (FinalWrite forces alpha 1).
 			writeRayRadiance( rayBufferRW, rayID, vec4( vec3( 0.0 ), select( transparentBackground, float( 1.0 ), float( 0.0 ) ) ) );
 
-			If( subSample.equal( int( 0 ) ), () => {
+			If( auxOn, () => {
 
 				// default: normal +Z, depth 1 (far), black albedo (background/miss)
 				writeGBuffer( gBufferRW, uint( pixelIndex ), vec3( 0.0, 0.0, 1.0 ), float( 1.0 ), vec3( 0.0 ) );

package/src/TSL/LightsSampling.js

@@ -58,7 +58,7 @@ import {
 	sampleIESProfile,
 } from './LightsCore.js';
 
-import { MISStrategy, DotProducts } from './Struct.js';
+import { MISStrategy, DotProducts, DirectLightingDual } from './Struct.js';
 import {
 	calculateDirectionalLightImportance,
 	estimateLightImportance,
@@ -707,9 +707,14 @@ export const calculateDirectLightingUnified = Fn( ( [
 	envCDFTexture,
 	envTotalSum, envCompensationDelta, envResolution,
 	enableEnvironmentLight,
+	// Shadow catcher: when true, also accumulate the unoccluded (visibility=1) reference
+	// at every light/env site so the caller can form a shadow ratio. Dead path otherwise.
+	wantUnoccluded,
 ] ) => {
 
 	const totalContribution = vec3( 0.0 ).toVar();
+	// Unoccluded reference (visibility forced to 1) — only filled when wantUnoccluded.
+	const unoccludedContribution = vec3( 0.0 ).toVar();
 	const rayOrigin = hitPoint.add( hitNormal.mul( 0.001 ) ).toVar();
 
 	// Binds BVH params so shadow-ray sites at varying call depths use a 3-arg call
@@ -819,7 +824,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 					const shadowDistance = min( lightSample.distance.sub( 0.001 ), float( 1000.0 ) );
 					const visibility = shadow( rayOrigin, lightSample.direction, shadowDistance );
 
-					If( visibility.greaterThan( 0.0 ), () => {
+					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
 						// Share H + dot products between BRDF eval and PDF — otherwise each
 						// would recompute normalize(V+L) + 5 dot products independently.
@@ -846,9 +851,15 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 						} );
 
-						// Guard division
-						const lightContribution = lightSample.emission.mul( brdfValue ).mul( NoL ).mul( visibility ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) );
-						totalContribution.addAssign( lightContribution.mul( totalSamplingWeight ).div( max( lightWeight, 1e-10 ) ) );
+						// Base contribution WITHOUT visibility; shadowed = base × visibility (identical to the
+						// pre-dual-sum math), unoccluded = base × 1 (shadow-catcher reference only).
+						const baseContribution = lightSample.emission.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) ).mul( totalSamplingWeight ).div( max( lightWeight, 1e-10 ) );
+						totalContribution.addAssign( baseContribution.mul( visibility ) );
+						If( wantUnoccluded, () => {
+
+							unoccludedContribution.addAssign( baseContribution );
+
+						} );
 
 					} );
 
@@ -918,7 +929,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 								const shadowDistance = min( hitDistance.sub( 0.001 ), float( 1000.0 ) );
 								const visibility = shadow( rayOrigin, brdfSampleDirection, shadowDistance );
 
-								If( visibility.greaterThan( 0.0 ), () => {
+								If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
 									const lightFacing = max( float( 0.0 ), dot( brdfSampleDirection, light.normal ).negate() ).toVar();
 
@@ -934,9 +945,14 @@ export const calculateDirectLightingUnified = Fn( ( [
 										const misW = powerHeuristic( { pdf1: brdfPdfWeighted, pdf2: lightPdfWeighted } ).toVar();
 
 										const lightEmission = light.color.mul( light.intensity );
-										// Guard division
-										const brdfContribution = lightEmission.mul( brdfSampleValue ).mul( NoL ).mul( visibility ).mul( misW ).div( max( brdfSamplePdf, 1e-10 ) );
-										totalContribution.addAssign( brdfContribution.mul( totalSamplingWeight ).div( max( brdfWeight, 1e-10 ) ) );
+										// Base contribution WITHOUT visibility (see discrete-light site).
+										const baseContribution = lightEmission.mul( brdfSampleValue ).mul( NoL ).mul( misW ).div( max( brdfSamplePdf, 1e-10 ) ).mul( totalSamplingWeight ).div( max( brdfWeight, 1e-10 ) );
+										totalContribution.addAssign( baseContribution.mul( visibility ) );
+										If( wantUnoccluded, () => {
+
+											unoccludedContribution.addAssign( baseContribution );
+
+										} );
 
 									} );
 
@@ -984,7 +1000,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 					const visibility = shadow( rayOrigin, envDirection, float( 1000.0 ) );
 
-					If( visibility.greaterThan( 0.0 ), () => {
+					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
 						// Share H + dots between env BRDF/PDF — same redundancy fix as the
 						// discrete-light path above.
@@ -1000,9 +1016,14 @@ export const calculateDirectLightingUnified = Fn( ( [
 							float( 1.0 )
 						).toVar();
 
-						// Guard division — no stochastic scaling needed (deterministic estimator)
-						const envContribution = envColor.mul( brdfValue ).mul( NoL ).mul( visibility ).mul( misW ).div( max( envPdf, 1e-10 ) );
-						totalContribution.addAssign( envContribution );
+						// Base contribution WITHOUT visibility (deterministic estimator; no stochastic scaling).
+						const baseContribution = envColor.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( envPdf, 1e-10 ) );
+						totalContribution.addAssign( baseContribution.mul( visibility ) );
+						If( wantUnoccluded, () => {
+
+							unoccludedContribution.addAssign( baseContribution );
+
+						} );
 
 					} );
 
@@ -1018,6 +1039,6 @@ export const calculateDirectLightingUnified = Fn( ( [
 	// NOTE: Emissive triangle sampling is handled separately in pathtracer_core.fs
 	// to bypass firefly suppression. Do not add it here to avoid double-counting.
 
-	return totalContribution;
+	return DirectLightingDual( { shadowed: totalContribution, unoccluded: unoccludedContribution } );
 
 } );