rayzee 6.4.0 → 7.0.0

package/src/TSL/FinalWriteKernel.js

@@ -0,0 +1,121 @@
+/**
+ * FinalWriteKernel.js — wavefront final output: temporal accumulation + MRT StorageTexture writes (16×16, 2D).
+ */
+
+import {
+	Fn, wgslFn, float, vec2, vec4, int, uint, uvec2,
+	If, mix, select, texture, textureStore,
+	localId, workgroupId,
+} from 'three/tsl';
+
+import {
+	readRayRadiance, readGBuffer, gbDecodeNormalDepth, gbDecodeAlbedo,
+} from '../Processor/PackedRayBuffer.js';
+
+const WG_SIZE = 16;
+
+// Debug mode 11: NaN/Inf detector — red where the accumulated color is NaN/Inf, black elsewhere.
+const nanInfToRed = /*@__PURE__*/ wgslFn( `
+	fn nanInfToRed( c: vec3f ) -> vec3f {
+		let isNan = c.x != c.x || c.y != c.y || c.z != c.z;
+		let isInf = abs( c.x ) > 1e30f || abs( c.y ) > 1e30f || abs( c.z ) > 1e30f;
+		if ( isNan || isInf ) { return vec3f( 1.0f, 0.0f, 0.0f ); }
+		return vec3f( 0.0f );
+	}
+` );
+
+export function buildFinalWriteKernel( params ) {
+
+	const {
+		rayBufferRO, gBufferRO,
+		writeColorTex, writeNDTex, writeAlbedoTex,
+		resolution, frame,
+		enableAccumulation, hasPreviousAccumulated, accumulationAlpha, cameraIsMoving,
+		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,
+	} = params;
+
+	const S = samplesPerPass | 0;
+
+	const computeFn = Fn( () => {
+
+		const gx = int( workgroupId.x ).mul( WG_SIZE ).add( int( localId.x ) );
+		const gy = int( workgroupId.y ).mul( WG_SIZE ).add( int( localId.y ) );
+
+		If( gx.lessThan( renderWidth ).and( gy.lessThan( renderHeight ) ), () => {
+
+			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 ) ) ) );
+
+				}
+
+				acc.assign( acc.div( float( S ) ) );
+				return acc;
+
+			} )();
+			// 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 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 );
+
+			// visMode 11 (NaN/Inf) bypasses accumulation (megakernel parity main_TSL_PathTracer.js:355) so the
+			// detector runs on each frame's fresh color — else mix() propagates a transient NaN and it stays red forever.
+			If( enableAccumulation.and( cameraIsMoving.not() ).and( frame.greaterThan( uint( 0 ) ) ).and( hasPreviousAccumulated ).and( visMode.notEqual( int( 11 ) ) ), () => {
+
+				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( transparentBackground, () => {
+
+					outputAlpha.assign( mix( prevAccumSample.w, sampleColor.w, accumulationAlpha ) );
+
+				} );
+
+			} );
+
+			// Debug mode 11: flag NaN/Inf on the accumulated color (red on NaN/Inf, black elsewhere).
+			If( visMode.equal( int( 11 ) ), () => {
+
+				finalColor.assign( nanInfToRed( finalColor ) );
+
+			} );
+
+			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();
+
+		} );
+
+	} );
+
+	return computeFn;
+
+}
+
+export { WG_SIZE as FINALWRITE_WG_SIZE };

package/src/TSL/GenerateKernel.js

@@ -0,0 +1,109 @@
+/**
+ * GenerateKernel.js — wavefront primary ray generation (16×16, 2D screen-space dispatch).
+ */
+
+import {
+	Fn, float, vec2, vec3, vec4, int, uint,
+	If, select,
+	localId, workgroupId,
+} from 'three/tsl';
+
+import {
+	getDecorrelatedSeed,
+	pcgHash,
+	getStratifiedSample,
+} from './Random.js';
+
+import { generateRayFromCamera } from './BVHTraversal.js';
+import { Ray } from './Struct.js';
+import { RAY_FLAG } from '../Processor/QueueManager.js';
+import {
+	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf,
+	writeRayRadiance, writeGBuffer,
+	writeMediumStack,
+} from '../Processor/PackedRayBuffer.js';
+
+const WG_SIZE = 16;
+
+export function buildGenerateKernel( params ) {
+
+	const {
+		rayBufferRW, rngBufferRW, gBufferRW,
+		resolution, frame,
+		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
+	} = params;
+
+	const S = samplesPerPass | 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 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 ) ), () => {
+
+			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 );
+
+			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 seed = pcgHash( { state: baseSeed } ).toVar();
+
+			const stratifiedJitter = getStratifiedSample( pixelCoord, subSample, int( S ), seed, resolution, frame ).toVar();
+
+			const jitterScale = vec2( 2.0 ).div( resolution );
+			const jitter = stratifiedJitter.sub( 0.5 ).mul( jitterScale );
+			const jitteredScreenPosition = screenPosition.add( jitter );
+
+			const ray = Ray.wrap( generateRayFromCamera(
+				jitteredScreenPosition, seed,
+				cameraWorldMatrix, cameraProjectionMatrixInverse,
+				enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
+			) );
+
+			writeRayOriginMeta( rayBufferRW, rayID, ray.origin, int( 0 ), int( 0 ) );
+			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.
+			writeRayThroughputPdf( rayBufferRW, rayID, vec4( 1.0, 1.0, 1.0, 0.0 ).xyz, float( 0.0 ) );
+			// Alpha inits to 1 in transparent-bg mode (megakernel parity: PathTracerCore.js:554). Shade zeroes
+			// it only on env-escape-without-opaque; a ray that dies inside geometry (e.g. SSS walk termination)
+			// 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 ) ), () => {
+
+				// 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 ) );
+
+			} );
+
+			writeMediumStack( rayBufferRW, rayID, uint( 0 ), uint( transmissiveBounces ), float( 1.0 ), float( 1.0 ), float( 1.0 ) );
+
+			rngBufferRW.element( rayID ).assign( seed );
+
+		} );
+
+	} );
+
+	return computeFn;
+
+}
+
+export { WG_SIZE as GENERATE_WG_SIZE };

package/src/TSL/LightsSampling.js

@@ -704,7 +704,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 	materialBuffer,
 	// Environment resources
 	envTexture, environmentIntensity, envMatrix,
-	envCDFBuffer,
+	envCDFTexture,
 	envTotalSum, envCompensationDelta, envResolution,
 	enableEnvironmentLight,
 ] ) => {
@@ -969,7 +969,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 			// Sample direction + PDF + color from importance-sampled environment
 			const envSampleResult = sampleEquirectProbability(
-				envTexture, envCDFBuffer,
+				envTexture, envCDFTexture,
 				envMatrix, environmentIntensity, envTotalSum, envCompensationDelta, envResolution, envRandom, envColor
 			).toVar();
 

package/src/TSL/MaterialTransmission.js

@@ -27,6 +27,7 @@ import { iorToFresnel0, fresnelSchlickFloat } from './Fresnel.js';
 import { DistributionGGX } from './MaterialProperties.js';
 import { ImportanceSampleGGX } from './MaterialSampling.js';
 import { RandomValue, pcgHash } from './Random.js';
+import { handleSubsurfaceEntry, SubsurfaceEntryResult } from './Subsurface.js';
 
 // ================================================================================
 // STRUCTS (local to transmission)
@@ -43,6 +44,7 @@ export const MaterialInteractionResult = struct( {
 	continueRay: 'bool', // Whether the ray should continue without further BRDF evaluation
 	isTransmissive: 'bool', // Flag to indicate this was a transmissive interaction
 	isAlphaSkip: 'bool', // Flag to indicate this was an alpha skip
+	isSubsurface: 'bool', // Flag to indicate this entered/exited a subsurface medium
 	didReflect: 'bool', // Whether TIR/reflection occurred (for medium stack update)
 	entering: 'bool', // Whether ray is entering or exiting medium
 	direction: 'vec3', // New ray direction if continuing
@@ -493,6 +495,7 @@ export const handleMaterialTransparency = Fn( ( [
 		continueRay: false,
 		isTransmissive: false,
 		isAlphaSkip: false,
+		isSubsurface: false,
 		didReflect: false,
 		entering: false,
 		direction: ray.direction,
@@ -501,8 +504,9 @@ export const handleMaterialTransparency = Fn( ( [
 		pathWavelength: pathWavelength,
 	} ).toVar();
 
-	// Fast path for fully opaque materials (most common case)
-	If( material.alphaMode.equal( int( 0 ) ).and( material.transmission.lessThanEqual( 0.0 ) ), () => {
+	// Fast path for fully opaque, non-scattering materials (most common case).
+	// Subsurface materials are opaque (transmission==0) but must NOT take this path.
+	If( material.alphaMode.equal( int( 0 ) ).and( material.transmission.lessThanEqual( 0.0 ) ).and( material.subsurface.lessThanEqual( 0.0 ) ), () => {
 
 		// no interaction needed
 
@@ -584,6 +588,32 @@ export const handleMaterialTransparency = Fn( ( [
 
 		} );
 
+		// Subsurface (independent of transmission; works at transmission==0). Entry is a lottery
+		// (prob = weight) so 1-weight falls through to the opaque BRDF; exit is deterministic.
+		If( handled.not().and( material.subsurface.greaterThan( 0.0 ) ), () => {
+
+			const entering = dot( ray.direction, normal ).lessThan( 0.0 );
+			const doEnter = entering.not().or( RandomValue( rngState ).lessThan( material.subsurface ) );
+
+			If( doEnter, () => {
+
+				const ssResult = SubsurfaceEntryResult.wrap( handleSubsurfaceEntry(
+					ray.direction, normal, material, entering, rngState,
+					currentMediumIOR, previousMediumIOR,
+				) ).toVar();
+
+				result.direction.assign( ssResult.direction );
+				result.throughput.assign( ssResult.throughput );
+				result.continueRay.assign( true );
+				result.isSubsurface.assign( true );
+				result.didReflect.assign( ssResult.didReflect );
+				result.entering.assign( entering );
+				result.alpha.assign( 1.0 );
+
+			} );
+
+		} );
+
 	} );
 
 	return result;