rayzee 6.0.1 → 6.1.0

package/src/Stages/NormalDepth.js

@@ -93,7 +93,6 @@ export class NormalDepth extends RenderStage {
 		// Own storage nodes — created lazily when data is available
 		this._triStorageNode = null;
 		this._bvhStorageNode = null;
-		this._matStorageNode = null;
 
 		// Last-seen attribute identities. PathTracer replaces these in-place
 		// across model load / BVH rebuild; the compute's bind group is locked
@@ -101,7 +100,6 @@ export class NormalDepth extends RenderStage {
 		// when any of them swaps to a new object.
 		this._lastTriAttr = null;
 		this._lastBvhAttr = null;
-		this._lastMatAttr = null;
 
 		// Compute node — built once when storage buffers are ready
 		this._computeNode = null;
@@ -146,8 +144,6 @@ export class NormalDepth extends RenderStage {
 		const pt = this.pathTracer;
 		if ( ! pt ) return false;
 
-		const matStorageAttr = pt.materialData.materialStorageAttr;
-
 		// Detect attribute identity swap (PathTracer.setTriangleData /
 		// setBVHData replace the attribute object on growth). The compute
 		// node's bind group is locked to the buffer bound at compile time —
@@ -155,9 +151,8 @@ export class NormalDepth extends RenderStage {
 		// pointing at the now-discarded buffer, so every traversal misses.
 		const triSwapped = pt.triangleStorageAttr && pt.triangleStorageAttr !== this._lastTriAttr;
 		const bvhSwapped = pt.bvhStorageAttr && pt.bvhStorageAttr !== this._lastBvhAttr;
-		const matSwapped = matStorageAttr && matStorageAttr !== this._lastMatAttr;
 
-		if ( triSwapped || bvhSwapped || matSwapped ) {
+		if ( triSwapped || bvhSwapped ) {
 
 			// Drop compute + storage nodes so they get rebuilt against the
 			// current buffers. Cheap: this only happens on model load.
@@ -166,7 +161,6 @@ export class NormalDepth extends RenderStage {
 			this._computeBuilt = false;
 			this._triStorageNode = null;
 			this._bvhStorageNode = null;
-			this._matStorageNode = null;
 			this._dirty = true;
 
 		}
@@ -187,19 +181,10 @@ export class NormalDepth extends RenderStage {
 
 		}
 
-		if ( matStorageAttr && ! this._matStorageNode ) {
-
-			this._matStorageNode = storage(
-				matStorageAttr, 'vec4', matStorageAttr.count
-			).toReadOnly();
-
-		}
-
 		this._lastTriAttr = pt.triangleStorageAttr || this._lastTriAttr;
 		this._lastBvhAttr = pt.bvhStorageAttr || this._lastBvhAttr;
-		this._lastMatAttr = matStorageAttr || this._lastMatAttr;
 
-		return !! ( this._triStorageNode && this._bvhStorageNode && this._matStorageNode );
+		return !! ( this._triStorageNode && this._bvhStorageNode );
 
 	}
 
@@ -211,7 +196,6 @@ export class NormalDepth extends RenderStage {
 
 		const triStorage = this._triStorageNode;
 		const bvhStorage = this._bvhStorageNode;
-		const matStorage = this._matStorageNode;
 		const camWorld = this.cameraWorldMatrix;
 		const camProjInv = this.cameraProjectionMatrixInverse;
 		const resW = this.resolutionWidth;
@@ -249,7 +233,7 @@ export class NormalDepth extends RenderStage {
 				const ray = Ray( { origin: rayOrigin, direction: rayDirWorld } );
 
 				// BVH traversal (primary ray only) — wrap result for struct field access
-				const hit = HitInfo.wrap( traverseBVH( ray, bvhStorage, triStorage, matStorage ) );
+				const hit = HitInfo.wrap( traverseBVH( ray, bvhStorage, triStorage ) );
 
 				// Encode: normal * 0.5 + 0.5 in RGB, linear depth in A
 				const encodedNormal = hit.normal.mul( 0.5 ).add( 0.5 );

package/src/Stages/PathTracer.js

@@ -188,6 +188,16 @@ export class PathTracer extends RenderStage {
 		this.spotLightsData = null;
 		this.areaLightsData = null;
 
+		// Spot light gobo (projection mask) DataArrayTexture. Owned externally
+		// (GoboManager); ShaderBuilder reads via this property at graph build time
+		// and refreshes the bound TextureNode in-place when it changes.
+		this.goboMaps = null;
+
+		// Spot light IES photometric profiles DataArrayTexture. Owned externally
+		// (IESManager); ShaderBuilder reads via this property at graph build time
+		// and refreshes the bound TextureNode in-place when it changes.
+		this.iesProfiles = null;
+
 		// STBN noise textures
 		this.stbnScalarTexture = null;
 		this.stbnVec2Texture = null;
@@ -487,9 +497,6 @@ export class PathTracer extends RenderStage {
 		this.setInstanceTable( this.sdfs.instanceTable );
 		this.materialData.setMaterialData( this.sdfs.materialData );
 
-		// Update triangle count
-		this.totalTriangleCount.value = this.sdfs.triangleCount || 0;
-
 		// Material texture arrays
 		this.materialData.loadTexturesFromSdfs();
 
@@ -588,11 +595,11 @@ export class PathTracer extends RenderStage {
 	 */
 	_updateLightBufferNodes() {
 
-		// Directional lights (8 floats per light)
+		// Directional lights (12 floats per light — 8 light fields + gobo {index, signed intensity, scale, pad})
 		if ( this.directionalLightsData && this.directionalLightsData.length > 0 ) {
 
 			this.directionalLightsBufferNode.array = Array.from( this.directionalLightsData );
-			this.numDirectionalLights.value = Math.floor( this.directionalLightsData.length / 8 );
+			this.numDirectionalLights.value = Math.floor( this.directionalLightsData.length / 12 );
 
 		} else {
 
@@ -624,11 +631,11 @@ export class PathTracer extends RenderStage {
 
 		}
 
-		// Spot lights (14 floats per light)
+		// Spot lights (20 floats per light — 14 light fields + gobo {idx, signed intensity} + IES {idx, intensity} + 2 reserved)
 		if ( this.spotLightsData && this.spotLightsData.length > 0 ) {
 
 			this.spotLightsBufferNode.array = Array.from( this.spotLightsData );
-			this.numSpotLights.value = Math.floor( this.spotLightsData.length / 14 );
+			this.numSpotLights.value = Math.floor( this.spotLightsData.length / 20 );
 
 		} else {
 
@@ -1087,9 +1094,8 @@ export class PathTracer extends RenderStage {
 	/**
 	 * Renders the path tracing pass with accumulation.
 	 * @param {PipelineContext} context - Pipeline context
-	 * @param {RenderTarget} writeBuffer - Output render target
 	 */
-	render( context, writeBuffer ) {
+	render( context ) {
 
 		if ( ! this.isReady ) return;
 

package/src/TSL/BVHTraversal.js

@@ -13,7 +13,6 @@ import {
 	sign,
 	min,
 	normalize,
-	cross,
 	mix,
 	vec4,
 	notEqual,
@@ -116,7 +115,6 @@ export const traverseBVH = Fn( ( [
 	ray,
 	bvhBuffer,
 	triangleBuffer,
-	materialBuffer,
 ] ) => {
 
 	const closestHit = HitInfo( {
@@ -332,7 +330,6 @@ export const traverseBVHShadow = Fn( ( [
 	ray,
 	bvhBuffer,
 	triangleBuffer,
-	_materialBuffer, // eslint-disable-line no-unused-vars -- kept for call-site compatibility
 	maxShadowDist,
 ] ) => {
 
@@ -398,10 +395,11 @@ export const traverseBVHShadow = Fn( ( [
 						closestHit.materialIndex.assign( int( uvData2.z ) );
 						closestHit.meshIndex.assign( int( uvData2.w ) );
 
-						// Compute hit point and geometric normal -- required for transmissive
-						// Fresnel in traceShadowRay (cosThetaI needs a real normal, not vec3(0))
+						// Hit point is cheap (origin + dir*t). Geometric normal is deferred
+						// to traceShadowRay — only the transmission branch needs it, so we
+						// skip the cross+normalize for the (much more common) opaque-blocker
+						// and alpha-cutout paths. Normal stays vec3(0) from struct init.
 						closestHit.hitPoint.assign( ray.origin.add( ray.direction.mul( triResult.x ) ) );
-						closestHit.normal.assign( normalize( cross( pB.sub( pA ), pC.sub( pA ) ) ) );
 
 						// Store barycentrics + triangle index for deferred UV computation.
 						// Actual UV interpolation happens in traceShadowRay only when

package/src/TSL/Common.js

@@ -246,7 +246,7 @@ export const classifyMaterial = Fn( ( [ metalness, roughness, transmission, clea
 } );
 
 // Dynamic MIS strategy based on material properties
-export const selectOptimalMISStrategy = Fn( ( [ roughness, metalness, transmission, bounceIndex, throughput ] ) => {
+export const selectOptimalMISStrategy = Fn( ( [ roughness, metalness, bounceIndex, throughput ] ) => {
 
 	const throughputStrength = maxComponent( { v: throughput } ).toVar();
 

package/src/TSL/Debugger.js

@@ -88,7 +88,6 @@ export const TraceDebugMode = Fn( ( [
 		ray,
 		bvhBuffer,
 		triangleBuffer,
-		materialBuffer,
 	).toVar() );
 
 	// Case 7: Triangle Tests
@@ -351,7 +350,6 @@ export const TraceDebugMode = Fn( ( [
 				bounceRay,
 				bvhBuffer,
 				triangleBuffer,
-				materialBuffer,
 			).toVar() );
 
 			const incoming = vec3( 0.0 ).toVar();

package/src/TSL/EmissiveSampling.js

@@ -5,7 +5,6 @@ import {
 	Fn,
 	vec2,
 	vec3,
-	vec4,
 	float,
 	int,
 	bool as tslBool,
@@ -16,7 +15,6 @@ import {
 	cross,
 	length,
 	max,
-	min,
 	sqrt,
 	abs,
 	clamp,
@@ -28,9 +26,11 @@ import {
 } from 'three/tsl';
 
 import { struct } from './patches.js';
-import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT } from './Common.js';
+import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT, computeDotProducts } from './Common.js';
 import { RandomValue } from './Random.js';
-import { calculateMaterialPDF } from './LightsSampling.js';
+import { calculateMaterialPDFFromDots } from './LightsSampling.js';
+import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
+import { DotProducts } from './Struct.js';
 
 // ================================================================================
 // STRUCTS
@@ -378,7 +378,7 @@ const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissive
 // `emissiveTriangleBuffer` may be the shared packed light buffer; `emissiveVec4Offset`
 // gives the vec4 offset where emissive entries begin.
 export const sampleEmissiveTriangle = Fn( ( [
-	hitPoint, surfaceNormal, totalTriangleCount,
+	hitPoint, surfaceNormal,
 	rngState,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
@@ -514,19 +514,19 @@ export const sampleEmissiveTriangle = Fn( ( [
 // EMISSIVE TRIANGLE DIRECT LIGHTING CONTRIBUTION
 // ================================================================================
 
-// Note: calculateEmissiveTriangleContributionDebug requires traceShadowRay and
-// evaluateMaterialResponse which creates circular dependencies.
-// These are passed as function parameters to avoid the cycle.
+// Note: traceShadowRay and calculateRayOffset are passed as Fn parameters to
+// avoid a circular module dependency. BRDF evaluation no longer goes through a
+// callback — we import the FromDots variant directly so we can share dot
+// products with the PDF call below.
 
 export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 	hitPoint, normal, viewDir, material,
-	totalTriangleCount, bounceIndex, rngState,
+	bounceIndex, rngState,
 	emissiveBoost,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
 	// Callback functions to avoid circular deps
 	traceShadowRayFn,
-	evaluateMaterialResponseFn,
 	calculateRayOffsetFn,
 ] ) => {
 
@@ -544,7 +544,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 
 		// Sample emissive triangle (CDF importance-weighted)
 		const emissiveSample = EmissiveSample.wrap( sampleEmissiveTriangle(
-			hitPoint, normal, totalTriangleCount, rngState,
+			hitPoint, normal, rngState,
 			emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 			triangleBuffer,
 		) );
@@ -566,15 +566,15 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 
 				// Trace shadow ray
 				const shadowDist = emissiveSample.distance.sub( 0.001 );
-				const visibility = traceShadowRayFn( rayOrigin, emissiveSample.direction, shadowDist, rngState );
+				const visibility = traceShadowRayFn( rayOrigin, emissiveSample.direction, shadowDist );
 
 				If( visibility.greaterThan( 0.0 ), () => {
 
-					// Evaluate BRDF
-					const brdfValue = evaluateMaterialResponseFn( viewDir, emissiveSample.direction, normal, material );
-
-					// Calculate BRDF PDF for MIS
-					const brdfPdf = calculateMaterialPDF( viewDir, emissiveSample.direction, normal, material );
+					// Share H + dot products between BRDF eval and PDF (computeDotProducts
+					// would otherwise run twice with identical inputs).
+					const dots = DotProducts.wrap( computeDotProducts( normal, viewDir, emissiveSample.direction ) );
+					const brdfValue = evaluateMaterialResponseFromDots( material, dots );
+					const brdfPdf = calculateMaterialPDFFromDots( material, dots );
 
 					// MIS weight: balance light sampling vs BRDF sampling
 					const misWeight = select(
@@ -602,26 +602,24 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 
 } );
 
-// Wrapper function for backward compatibility
+// Wrapper that returns just the contribution vec3
 export const calculateEmissiveTriangleContribution = Fn( ( [
 	hitPoint, normal, viewDir, material,
-	totalTriangleCount, bounceIndex, rngState,
+	bounceIndex, rngState,
 	emissiveBoost,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
 	traceShadowRayFn,
-	evaluateMaterialResponseFn,
 	calculateRayOffsetFn,
 ] ) => {
 
 	const result = EmissiveContributionResult.wrap( calculateEmissiveTriangleContributionDebug(
 		hitPoint, normal, viewDir, material,
-		totalTriangleCount, bounceIndex, rngState,
+		bounceIndex, rngState,
 		emissiveBoost,
 		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 		triangleBuffer,
 		traceShadowRayFn,
-		evaluateMaterialResponseFn,
 		calculateRayOffsetFn,
 	) );
 	return result.contribution;

package/src/TSL/Environment.js

@@ -1,4 +1,4 @@
-import { Fn, wgslFn, vec2, vec4, float, int, If, texture, sampler, dot, sin, floor, fract, min, max, mix, clamp } from 'three/tsl';
+import { Fn, wgslFn, vec2, vec4, float, int, If, texture, dot, sin, sqrt, floor, fract, min, max, mix, clamp } from 'three/tsl';
 
 import { REC709_LUMINANCE_COEFFICIENTS } from './Common.js';
 
@@ -28,17 +28,6 @@ export const equirectUvToDirection = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
-// Calculate PDF for uniform sphere sampling with Jacobian
-export const equirectDirectionPdf = /*@__PURE__*/ wgslFn( `
-	fn equirectDirectionPdf( direction: vec3f, environmentMatrix: mat4x4f ) -> f32 {
-		let uv = equirectDirectionToUv( direction, environmentMatrix );
-		let theta = uv.y * 3.14159265358979323846f;
-		let sinTheta = sin( theta );
-		if ( sinTheta == 0.0f ) { return 0.0f; }
-		return 1.0f / ( 6.28318530717958647692f * 3.14159265358979323846f * sinTheta );
-	}
-`, [ equirectDirectionToUv ] );
-
 // Evaluate PDF for a given direction (for MIS)
 // Returns vec4(color.rgb, pdf) since TSL cannot use inout params
 // Uses MIS-compensated PDF (Karlík et al. 2019): max(0, lum - delta) / compensatedTotalSum
@@ -64,7 +53,12 @@ export const sampleEquirect = Fn( ( [ environment, direction, environmentMatrix,
 		const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) ).toVar();
 		const pdf = compensatedWeight.div( envTotalSum ).toVar();
 
-		const dirPdf = equirectDirectionPdf( { direction, environmentMatrix } ).toVar();
+		// Inline equirectDirectionPdf using the uv + sinTheta already in scope —
+		// the helper would otherwise re-derive uv via atan2+acos and recompute sin.
+		const dirPdf = sinTheta.greaterThan( 0.0 ).select(
+			float( 1.0 ).div( float( 2.0 * Math.PI * Math.PI ).mul( sinTheta ) ),
+			float( 0.0 )
+		).toVar();
 		const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf ).toVar();
 
 		result.assign( vec4( color, finalPdf ) );
@@ -138,7 +132,12 @@ export const sampleEquirectProbability = Fn( ( [
 	const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) ).toVar();
 	const pdf = compensatedWeight.div( envTotalSum ).toVar();
 
-	const dirPdf = equirectDirectionPdf( { direction, environmentMatrix } ).toVar();
+	// Inline equirectDirectionPdf — uv + sinTheta are already in scope, so we
+	// skip the helper's redundant uv-from-direction + sin recompute.
+	const dirPdf = sinTheta.greaterThan( 0.0 ).select(
+		float( 1.0 ).div( float( 2.0 * Math.PI * Math.PI ).mul( sinTheta ) ),
+		float( 0.0 )
+	).toVar();
 	const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf ).toVar();
 
 	return vec4( direction, finalPdf );
@@ -163,3 +162,50 @@ export const sampleEnvironment = /*@__PURE__*/ wgslFn( `
 		return texSample * environmentIntensity;
 	}
 `, [ equirectDirectionToUv ] );
+
+// Port of three.js PR #33611 (getGroundProjectedNormal) adapted from rasterizer fragment math
+// (cameraPosition + positionWorld) to path-tracer ray math (rayOrigin + rayDirection). When the
+// ray misses the projection sphere it falls back to rayDirection so distant scenes degrade gracefully.
+export const getGroundProjectedDirection = Fn( ( [ rayOrigin, rayDirection, radius, height ] ) => {
+
+	const p = rayDirection.toConst();
+	const camPos = rayOrigin.toVar();
+	camPos.y.subAssign( height );
+
+	const r2 = radius.mul( radius ).toConst();
+	const b = camPos.dot( p ).toConst();
+	const c = camPos.dot( camPos ).sub( r2 ).toConst();
+	const h = b.mul( b ).sub( c ).toConst();
+
+	const projected = rayDirection.toVar();
+
+	If( h.greaterThanEqual( 0.0 ), () => {
+
+		const tSphere = sqrt( h ).sub( b ).toVar();
+
+		// Disk sits at world y=0; the camPos shift only repositions the sphere.
+		const tDisk = float( 1e6 ).toVar();
+		const py = p.y.toConst();
+		If( py.lessThanEqual( 0.0 ), () => {
+
+			const t = rayOrigin.y.negate().div( py ).toConst();
+			const q = rayOrigin.add( p.mul( t ) ).toConst();
+			If( q.dot( q ).lessThan( r2 ), () => {
+
+				tDisk.assign( t );
+
+			} );
+
+		} );
+
+		If( tSphere.greaterThan( 0.0 ), () => {
+
+			projected.assign( camPos.add( p.mul( min( tSphere, tDisk ) ) ).div( radius ) );
+
+		} );
+
+	} );
+
+	return projected;
+
+} );

package/src/TSL/Fresnel.js

@@ -1,25 +1,34 @@
-import { Fn, float, vec3, max, pow, clamp, sqrt } from 'three/tsl';
+import { Fn, float, vec3, max, clamp, sqrt } from 'three/tsl';
 
 const EPSILON = 1e-6;
 
+// Schlick exponent factored as 4 multiplies — pow(x, 5.0) compiles to
+// exp2(5*log2(x)) on most backends, far slower than (x²)²·x.
+const pow5 = ( c ) => {
+
+	const c2 = c.mul( c );
+	return c2.mul( c2 ).mul( c );
+
+};
+
 export const fresnel = Fn( ( [ f0, NoV, roughness ] ) => {
 
 	const maxR = max( vec3( float( 1.0 ).sub( roughness ) ), f0 );
-	return f0.add( maxR.sub( f0 ).mul( pow( float( 1.0 ).sub( NoV ), 5.0 ) ) );
+	return f0.add( maxR.sub( f0 ).mul( pow5( float( 1.0 ).sub( NoV ) ) ) );
 
 } );
 
 export const fresnelSchlickFloat = Fn( ( [ cosTheta, F0 ] ) => {
 
 	const clampedCos = clamp( cosTheta, 0.0, 1.0 );
-	return F0.add( float( 1.0 ).sub( F0 ).mul( pow( float( 1.0 ).sub( clampedCos ), 5.0 ) ) );
+	return F0.add( float( 1.0 ).sub( F0 ).mul( pow5( float( 1.0 ).sub( clampedCos ) ) ) );
 
 } );
 
 export const fresnelSchlick = Fn( ( [ cosTheta, F0 ] ) => {
 
 	const clampedCos = clamp( cosTheta, 0.0, 1.0 );
-	return F0.add( vec3( 1.0 ).sub( F0 ).mul( pow( float( 1.0 ).sub( clampedCos ), 5.0 ) ) );
+	return F0.add( vec3( 1.0 ).sub( F0 ).mul( pow5( float( 1.0 ).sub( clampedCos ) ) ) );
 
 } );