rayzee 6.0.0 → 6.1.0

package/src/TSL/LightsCore.js

@@ -3,14 +3,25 @@
 
 import {
 	Fn, wgslFn,
+	vec2,
 	vec3,
 	float,
+	int,
 	If,
 	dot,
 	normalize,
 	cross,
 	length,
 	abs,
+	select,
+	clamp,
+	max,
+	min,
+	mix,
+	tan,
+	acos,
+	atan,
+	texture,
 } from 'three/tsl';
 
 import { struct } from './patches.js';
@@ -24,6 +35,9 @@ export const DirectionalLight = struct( {
 	color: 'vec3',
 	intensity: 'float',
 	angle: 'float', // Angular diameter in radians
+	goboIndex: 'int', // -1 = no gobo, otherwise index into goboMaps array
+	goboIntensity: 'float', // signed: negative = inverted, |value| = strength
+	goboScale: 'float', // world units per gobo tile (used by directional projection)
 } );
 
 export const AreaLight = struct( {
@@ -53,6 +67,10 @@ export const SpotLight = struct( {
 	penumbra: 'float', // penumbra factor [0,1]
 	distance: 'float', // cutoff distance (0 = infinite)
 	decay: 'float', // decay exponent (2 = physically correct)
+	goboIndex: 'int', // -1 = no gobo, otherwise index into goboMaps array
+	goboIntensity: 'float', // mask strength multiplier (0 = no mask, 1 = full mask)
+	iesIndex: 'int', // -1 = no IES, otherwise index into iesProfiles array
+	iesIntensity: 'float', // blend [0,1] between flat (0) and full IES distribution (1)
 } );
 
 export const LightSample = struct( {
@@ -84,7 +102,7 @@ export const LIGHT_TYPE_SPOT = 3;
 
 export const getDirectionalLight = Fn( ( [ directionalLightsBuffer, index ] ) => {
 
-	const baseIndex = index.mul( 8 );
+	const baseIndex = index.mul( 12 );
 	return DirectionalLight( {
 		direction: normalize( vec3(
 			directionalLightsBuffer.element( baseIndex ),
@@ -98,6 +116,9 @@ export const getDirectionalLight = Fn( ( [ directionalLightsBuffer, index ] ) =>
 		),
 		intensity: directionalLightsBuffer.element( baseIndex.add( 6 ) ),
 		angle: directionalLightsBuffer.element( baseIndex.add( 7 ) ),
+		goboIndex: int( directionalLightsBuffer.element( baseIndex.add( 8 ) ) ),
+		goboIntensity: directionalLightsBuffer.element( baseIndex.add( 9 ) ),
+		goboScale: directionalLightsBuffer.element( baseIndex.add( 10 ) ),
 	} );
 
 } );
@@ -161,7 +182,7 @@ export const getPointLight = Fn( ( [ pointLightsBuffer, index ] ) => {
 
 export const getSpotLight = Fn( ( [ spotLightsBuffer, index ] ) => {
 
-	const baseIndex = index.mul( 14 );
+	const baseIndex = index.mul( 20 );
 	return SpotLight( {
 		position: vec3(
 			spotLightsBuffer.element( baseIndex ),
@@ -183,6 +204,11 @@ export const getSpotLight = Fn( ( [ spotLightsBuffer, index ] ) => {
 		penumbra: spotLightsBuffer.element( baseIndex.add( 11 ) ),
 		distance: spotLightsBuffer.element( baseIndex.add( 12 ) ),
 		decay: spotLightsBuffer.element( baseIndex.add( 13 ) ),
+		goboIndex: int( spotLightsBuffer.element( baseIndex.add( 14 ) ) ),
+		goboIntensity: spotLightsBuffer.element( baseIndex.add( 15 ) ),
+		iesIndex: int( spotLightsBuffer.element( baseIndex.add( 16 ) ) ),
+		iesIntensity: spotLightsBuffer.element( baseIndex.add( 17 ) ),
+		// slots 18, 19 reserved (vec4 padding)
 	} );
 
 } );
@@ -198,13 +224,17 @@ export const isDirectionValid = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
-// Distance attenuation based on Frostbite PBR
+// Distance attenuation based on Frostbite PBR. Integer exponents factored as
+// repeated multiplies — pow(x, 4) and pow(x, 2) are far cheaper this way.
 export const getDistanceAttenuation = /*@__PURE__*/ wgslFn( `
 	fn getDistanceAttenuation( lightDistance: f32, cutoffDistance: f32, decayExponent: f32 ) -> f32 {
 		var distanceFalloff = 1.0f / max( pow( lightDistance, decayExponent ), 0.01f );
 		if ( cutoffDistance > 0.0f ) {
-			let ratio = pow( lightDistance / cutoffDistance, 4.0f );
-			distanceFalloff *= pow( clamp( 1.0f - ratio, 0.0f, 1.0f ), 2.0f );
+			let r = lightDistance / cutoffDistance;
+			let r2 = r * r;
+			let ratio = r2 * r2;
+			let window = clamp( 1.0f - ratio, 0.0f, 1.0f );
+			distanceFalloff *= window * window;
 		}
 		return distanceFalloff;
 	}
@@ -218,6 +248,209 @@ 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 ] ) => {
+
+	const mask = float( 1.0 ).toVar();
+
+	If( light.goboIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		const forward = light.direction.toVar();
+		const toSurface = lightDir.negate().toVar();
+		const cosAlpha = dot( toSurface, forward ).toVar();
+
+		If( cosAlpha.greaterThan( 0.0 ), () => {
+
+			// Orthonormal basis around forward axis
+			const up = select(
+				abs( forward.z ).lessThan( 0.999 ),
+				vec3( 0.0, 0.0, 1.0 ),
+				vec3( 1.0, 0.0, 0.0 ),
+			);
+			const T = normalize( cross( up, forward ) ).toVar();
+			const B = cross( forward, T ).toVar();
+
+			// Project onto plane perpendicular to forward at distance 1
+			const invCos = float( 1.0 ).div( cosAlpha ).toVar();
+			const px = dot( toSurface, T ).mul( invCos ).toVar();
+			const py = dot( toSurface, B ).mul( invCos ).toVar();
+
+			// Cone edge → ±tan(angle); map to UV [0,1]
+			const tanA = max( tan( light.angle ), float( 1e-4 ) ).toVar();
+			const invTan = float( 0.5 ).div( tanA ).toVar();
+			const u = clamp( px.mul( invTan ).add( 0.5 ), float( 0.0 ), float( 1.0 ) ).toVar();
+			const v = clamp( py.mul( invTan ).add( 0.5 ), float( 0.0 ), float( 1.0 ) ).toVar();
+
+			if ( _goboMapsTexNode ) {
+
+				// 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 sample = min( tex.r, tex.a );
+				const inverted = light.goboIntensity.lessThan( 0.0 );
+				const effective = select( inverted, float( 1.0 ).sub( sample ), sample );
+				const strength = clamp( abs( light.goboIntensity ), float( 0.0 ), float( 1.0 ) );
+				mask.assign( mix( float( 1.0 ), effective, strength ) );
+
+			}
+
+		} ).Else( () => {
+
+			// Behind the light — emit zero so back-hemisphere is dark.
+			mask.assign( 0.0 );
+
+		} );
+
+	} );
+
+	return mask;
+
+} );
+
+// Sample a directional light's gobo mask. Returns 1.0 if no gobo assigned.
+// Projects the shading point onto a plane perpendicular to the light direction;
+// the mask is tiled at `light.goboScale` world units per tile so a single mask
+// 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 ] ) => {
+
+	const mask = float( 1.0 ).toVar();
+
+	If( light.goboIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		// `light.direction` in this engine points FROM target TOWARD the light.
+		// Project surface point onto plane perpendicular to that axis.
+		const axis = light.direction.toVar();
+
+		const up = select(
+			abs( axis.z ).lessThan( 0.999 ),
+			vec3( 0.0, 0.0, 1.0 ),
+			vec3( 1.0, 0.0, 0.0 ),
+		);
+		const T = normalize( cross( up, axis ) ).toVar();
+		const B = cross( axis, T ).toVar();
+
+		const invScale = float( 1.0 ).div( max( light.goboScale, float( 1e-4 ) ) ).toVar();
+		const u = dot( surfacePoint, T ).mul( invScale ).add( 0.5 ).toVar();
+		const v = dot( surfacePoint, B ).mul( invScale ).add( 0.5 ).toVar();
+
+		// Tile by fract so a single mask can cover any scene size.
+		const uTiled = u.sub( u.floor() ).toVar();
+		const vTiled = v.sub( v.floor() ).toVar();
+
+		if ( _goboMapsTexNode ) {
+
+			const tex = texture( _goboMapsTexNode, 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 );
+			const strength = clamp( abs( light.goboIntensity ), float( 0.0 ), float( 1.0 ) );
+			mask.assign( mix( float( 1.0 ), effective, strength ) );
+
+		}
+
+	} );
+
+	return mask;
+
+} );
+
+// ================================================================================
+// 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).
+//
+// IES texture layout: U = horizontal angle (0..360°), V = vertical angle (0..180°)
+// 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 ] ) => {
+
+	const result = float( 1.0 ).toVar();
+
+	If( light.iesIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		const forward = light.direction.toVar();
+		const toSurface = lightDir.negate().toVar();
+
+		// Vertical angle: between forward axis and emission direction. 0 = on axis (V=0),
+		// PI = anti-axis (V=1).
+		const cosV = clamp( dot( toSurface, forward ), float( - 1.0 ), float( 1.0 ) ).toVar();
+		const vAngle = acos( cosV ).toVar();
+		const v = clamp( vAngle.div( float( Math.PI ) ), float( 0.0 ), float( 1.0 ) ).toVar();
+
+		// Horizontal angle: project emission direction onto plane perpendicular to forward.
+		const up = select(
+			abs( forward.z ).lessThan( 0.999 ),
+			vec3( 0.0, 0.0, 1.0 ),
+			vec3( 1.0, 0.0, 0.0 ),
+		);
+		const T = normalize( cross( up, forward ) ).toVar();
+		const B = cross( forward, T ).toVar();
+
+		const px = dot( toSurface, T );
+		const py = dot( toSurface, B );
+		// atan2 → [-PI, PI]; remap to [0, 2PI] then to [0, 1].
+		const phi = atan( py, px );
+		const u = phi.div( float( 2.0 * Math.PI ) ).add( 0.5 ).toVar();
+
+		if ( _iesProfilesTexNode ) {
+
+			const sample = texture( _iesProfilesTexNode, 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 ) );
+
+		}
+
+	} );
+
+	return result;
+
+} );
+
 // ================================================================================
 // CONE SAMPLING FOR SOFT DIRECTIONAL SHADOWS
 // ================================================================================

package/src/TSL/LightsDirect.js

@@ -11,6 +11,8 @@ import {
 	Loop,
 	Break,
 	dot,
+	cross,
+	normalize,
 	abs,
 	max,
 	min,
@@ -61,7 +63,7 @@ export function setAlphaShadowsUniform( node ) {
 
 // Note: traverseBVH is passed as a parameter to avoid circular dependency
 export const traceShadowRay = Fn( ( [
-	origin, dir, maxDist, rngState,
+	origin, dir, maxDist,
 	// BVH traversal function and textures passed as parameters
 	traverseBVHShadowFn,
 	bvhBuffer,
@@ -83,7 +85,6 @@ export const traceShadowRay = Fn( ( [
 			shadowRay,
 			bvhBuffer,
 			triangleBuffer,
-			materialBuffer,
 			remainingDist,
 		) );
 
@@ -184,8 +185,18 @@ export const traceShadowRay = Fn( ( [
 
 		} ).ElseIf( shadowMaterial.transmission.greaterThan( 0.0 ), () => {
 
-			const entering = dot( dir, shadowHit.normal ).lessThan( 0.0 );
-			const N = select( entering, shadowHit.normal, shadowHit.normal.negate() );
+			// Deferred geometric-normal compute — refetch triangle positions and
+			// derive the normal here so opaque/alpha-cutout shadow hits don't pay
+			// the cross+normalize cost in BVH traversal.
+			const TRI_STRIDE_N = int( 8 );
+			const pA = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 0 ), TRI_STRIDE_N ).xyz;
+			const pB = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 1 ), TRI_STRIDE_N ).xyz;
+			const pC = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 2 ), TRI_STRIDE_N ).xyz;
+			const geomNormal = normalize( cross( pB.sub( pA ), pC.sub( pA ) ) );
+			shadowHit.normal.assign( geomNormal );
+
+			const entering = dot( dir, geomNormal ).lessThan( 0.0 );
+			const N = select( entering, geomNormal, geomNormal.negate() );
 
 			// Apply absorption if exiting medium
 			If( entering.not().and( shadowMaterial.attenuationDistance.greaterThan( 0.0 ) ), () => {
@@ -285,7 +296,7 @@ export const calculateRayOffset = Fn( ( [ hitPoint, normal, material ] ) => {
 // LIGHT IMPORTANCE ESTIMATION
 // ================================================================================
 
-export const calculateDirectionalLightImportance = Fn( ( [ light, hitPoint, normal, material, bounceIndex ] ) => {
+export const calculateDirectionalLightImportance = Fn( ( [ light, normal, material, bounceIndex ] ) => {
 
 	const NoL = max( float( 0.0 ), dot( normal, light.direction ) );
 	const result = float( 0.0 ).toVar();

package/src/TSL/LightsIndirect.js

@@ -19,18 +19,13 @@ import {
 	float,
 	vec2,
 	vec3,
-	vec4,
 	int,
-	uint,
 	bool as tslBool,
 	max,
-	min,
 	abs,
 	sqrt,
 	dot,
 	normalize,
-	length,
-	clamp,
 	If,
 	select,
 } from 'three/tsl';
@@ -40,10 +35,8 @@ import {
 } from './LightsCore.js';
 import {
 	SamplingStrategyWeights,
-	ImportanceSamplingInfo,
 } from './Struct.js';
 import {
-	PI,
 	PI_INV,
 	EPSILON,
 	MIN_PDF,
@@ -51,7 +44,6 @@ import {
 import { DistributionGGX, calculateVNDFPDF } from './MaterialProperties.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import { RandomValue } from './Random.js';
-import { sampleEquirectProbability, sampleEquirect } from './Environment.js';
 import { sampleMicrofacetTransmission, MicrofacetTransmissionResult } from './MaterialTransmission.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
 
@@ -115,8 +107,7 @@ export const calculateClearcoatPDF = Fn( ( [ V, L, N, clearcoatRoughness ] ) =>
 
 // Compute normalized strategy weights based on importance info
 export const computeSamplingInfo = Fn( ( [
-	samplingInfo, bounceIndex, material,
-	enableEnvironmentLight, useEnvMapIS,
+	samplingInfo,
 ] ) => {
 
 	// Material-only strategies (env handled via deterministic NEE in direct lighting)
@@ -177,13 +168,11 @@ export const computeSamplingInfo = Fn( ( [
 // Strategy Selection via Cumulative Distribution
 // =============================================================================
 
-// Returns vec2(selectedStrategy, strategyPdf)
 // Strategy IDs: 1=specular, 2=diffuse, 3=transmission, 4=clearcoat
 // (env removed — handled via deterministic NEE in direct lighting)
 export const selectSamplingStrategy = Fn( ( [ weights, randomValue ] ) => {
 
 	const selectedStrategy = int( 2 ).toVar(); // Default: diffuse
-	const strategyPdf = float( 1.0 ).toVar();
 
 	const cumulative = float( 0.0 ).toVar();
 	const found = tslBool( false ).toVar();
@@ -195,7 +184,6 @@ export const selectSamplingStrategy = Fn( ( [ weights, randomValue ] ) => {
 		If( randomValue.lessThan( cumulative ), () => {
 
 			selectedStrategy.assign( 1 );
-			strategyPdf.assign( weights.specularWeight );
 			found.assign( tslBool( true ) );
 
 		} );
@@ -209,7 +197,6 @@ export const selectSamplingStrategy = Fn( ( [ weights, randomValue ] ) => {
 		If( randomValue.lessThan( cumulative ), () => {
 
 			selectedStrategy.assign( 2 );
-			strategyPdf.assign( weights.diffuseWeight );
 			found.assign( tslBool( true ) );
 
 		} );
@@ -223,7 +210,6 @@ export const selectSamplingStrategy = Fn( ( [ weights, randomValue ] ) => {
 		If( randomValue.lessThan( cumulative ), () => {
 
 			selectedStrategy.assign( 3 );
-			strategyPdf.assign( weights.transmissionWeight );
 			found.assign( tslBool( true ) );
 
 		} );
@@ -233,20 +219,10 @@ export const selectSamplingStrategy = Fn( ( [ weights, randomValue ] ) => {
 	If( weights.useClearcoat.and( found.not() ), () => {
 
 		selectedStrategy.assign( 4 );
-		strategyPdf.assign( weights.clearcoatWeight );
-		found.assign( tslBool( true ) );
-
-	} );
-
-	// Fallback
-	If( found.not(), () => {
-
-		selectedStrategy.assign( 2 ); // Diffuse
-		strategyPdf.assign( select( weights.useDiffuse, weights.diffuseWeight, float( 1.0 ) ) );
 
 	} );
 
-	return vec2( float( selectedStrategy ), strategyPdf );
+	return selectedStrategy;
 
 } );
 
@@ -268,13 +244,8 @@ export const calculateIndirectLighting = Fn( ( [
 	V, N, material,
 	// brdfSample fields (DirectionSample)
 	brdfSampleDirection, brdfSamplePdf, brdfSampleValue,
-	sampleIndex, bounceIndex,
 	rngState,
 	samplingInfo,
-	// Environment resources
-	envTexture, environmentIntensity, envMatrix,
-	envTotalSum, envCompensationDelta, envResolution,
-	enableEnvironmentLight, useEnvMapIS,
 ] ) => {
 
 	// Initialize result
@@ -289,7 +260,6 @@ export const calculateIndirectLighting = Fn( ( [
 		.and( samplingInfo.specularImportance.greaterThanEqual( 0.0 ) )
 		.and( samplingInfo.transmissionImportance.greaterThanEqual( 0.0 ) )
 		.and( samplingInfo.clearcoatImportance.greaterThanEqual( 0.0 ) )
-		.and( samplingInfo.envmapImportance.greaterThanEqual( 0.0 ) )
 		.toVar();
 
 	If( validInput.not(), () => {
@@ -307,8 +277,7 @@ export const calculateIndirectLighting = Fn( ( [
 
 		// Use corrected sampling info
 		const weights = SamplingStrategyWeights.wrap( computeSamplingInfo(
-			samplingInfo, bounceIndex, material,
-			enableEnvironmentLight, useEnvMapIS,
+			samplingInfo,
 		).toVar() );
 
 		const selectionRand = RandomValue( rngState ).toVar();
@@ -317,9 +286,7 @@ export const calculateIndirectLighting = Fn( ( [
 		const sampleRand = vec2( r1, r2 ).toVar();
 
 		// Strategy selection
-		const strategyResult = selectSamplingStrategy( weights, selectionRand ).toVar();
-		const selectedStrategy = int( strategyResult.x ).toVar();
-		const strategySelectionPdf = strategyResult.y.toVar();
+		const selectedStrategy = selectSamplingStrategy( weights, selectionRand ).toVar();
 
 		const sampleDir = vec3( 0.0 ).toVar();
 		const samplePdf = float( 0.0 ).toVar();
@@ -346,8 +313,9 @@ export const calculateIndirectLighting = Fn( ( [
 
 			// Strategy 3: Transmission
 			const entering = dot( V, N ).greaterThan( 0.0 ).toVar();
+			// pathWavelength=0 — MIS evaluation reads only direction/PDF, no spectral tint
 			const mtResult = MicrofacetTransmissionResult.wrap( sampleMicrofacetTransmission(
-				V, N, material.ior, material.roughness, entering, material.dispersion, sampleRand, rngState
+				V, N, material.ior, material.roughness, entering, material.dispersion, sampleRand, rngState, float( 0.0 )
 			).toVar() );
 			sampleDir.assign( mtResult.direction );
 			samplePdf.assign( mtResult.pdf );