rayzee 5.10.2 → 6.0.0

package/src/TSL/LightsDirect.js

@@ -4,9 +4,6 @@
 
 import {
 	Fn,
-	vec2,
-	vec3,
-	vec4,
 	float,
 	int,
 	bool as tslBool,
@@ -14,13 +11,11 @@ import {
 	Loop,
 	Break,
 	dot,
-	normalize,
 	abs,
 	max,
 	min,
 	length,
 	sqrt,
-	pow,
 	cos,
 	clamp,
 	smoothstep,
@@ -29,14 +24,9 @@ import {
 } from 'three/tsl';
 
 import { Ray, ShadowMaterial, HitInfo } from './Struct.js';
-import { PI, TWO_PI, EPSILON, REC709_LUMINANCE_COEFFICIENTS, powerHeuristic, getShadowMaterial, getDatafromStorageBuffer } from './Common.js';
-import { fresnelSchlickFloat } from './Fresnel.js';
-import { iorToFresnel0 } from './Fresnel.js';
-import {
-	sampleCone, intersectAreaLight,
-} from './LightsCore.js';
-import { calculateBeerLawAbsorption, calculateShadowTransmittance } from './MaterialTransmission.js';
-import { RandomValue } from './Random.js';
+import { REC709_LUMINANCE_COEFFICIENTS, getShadowMaterial, getDatafromStorageBuffer } from './Common.js';
+import { fresnelSchlickFloat, iorToFresnel0 } from './Fresnel.js';
+import { calculateBeerLawAbsorption } from './MaterialTransmission.js';
 import { getTransformedUV } from './TextureSampling.js';
 
 // Module-level state for alpha-cutout shadow testing.
@@ -65,31 +55,6 @@ export function setAlphaShadowsUniform( node ) {
 
 }
 
-// ================================================================================
-// SHADOW RAY MATERIAL TRANSPARENCY
-// ================================================================================
-
-export const getMaterialTransparency = Fn( ( [ shadowHit, shadowRayDir, rngState ] ) => {
-
-	const result = float( 1.0 ).toVar();
-
-	// Check if the material has transmission (like glass)
-	If( shadowHit.material.transmission.greaterThan( 0.0 ), () => {
-
-		const isEntering = dot( shadowRayDir, shadowHit.normal ).lessThan( 0.0 );
-		const transmittance = calculateShadowTransmittance( shadowRayDir, shadowHit.normal, shadowHit.material, isEntering );
-		result.assign( float( 1.0 ).sub( transmittance ) );
-
-	} ).ElseIf( shadowHit.material.transparent, () => {
-
-		result.assign( shadowHit.material.opacity );
-
-	} );
-
-	return result;
-
-} );
-
 // ================================================================================
 // SHADOW RAY TRACING
 // ================================================================================
@@ -499,344 +464,3 @@ export const calculateSpotLightImportance = Fn( ( [ light, hitPoint, normal, mat
 
 } );
 
-// ================================================================================
-// DIRECTIONAL LIGHT CONTRIBUTION
-// ================================================================================
-
-export const shouldSkipDirectionalLight = Fn( ( [ light, normal, material, bounceIndex ] ) => {
-
-	const NoL = max( float( 0.0 ), dot( normal, light.direction ) );
-	const shouldSkip = tslBool( false ).toVar();
-
-	If( light.intensity.lessThanEqual( 0.001 ).or( NoL.lessThanEqual( 0.001 ) ), () => {
-
-		shouldSkip.assign( true );
-
-	} );
-
-	If( shouldSkip.not().and( bounceIndex.greaterThan( int( 0 ) ) ), () => {
-
-		If( light.intensity.lessThan( 0.01 ), () => {
-
-			shouldSkip.assign( true );
-
-		} );
-
-		If( shouldSkip.not().and( material.metalness.greaterThan( 0.9 ) ).and( NoL.lessThan( 0.1 ) ), () => {
-
-			shouldSkip.assign( true );
-
-		} );
-
-		If( shouldSkip.not().and( material.metalness.lessThan( 0.1 ) ).and( material.roughness.greaterThan( 0.9 ) ).and( light.intensity.lessThan( 0.1 ) ), () => {
-
-			shouldSkip.assign( true );
-
-		} );
-
-	} );
-
-	return shouldSkip;
-
-} );
-
-export const calculateDirectionalLightContribution = Fn( ( [
-	light, hitPoint, normal, viewDir, material, matCache, brdfSample, bounceIndex,
-	rngState,
-	// Shadow tracing callback + textures
-	traceShadowRayFn,
-	evaluateMaterialResponseCachedFn,
-] ) => {
-
-	const result = vec3( 0.0 ).toVar();
-
-	If( shouldSkipDirectionalLight( light, normal, material, bounceIndex ).not(), () => {
-
-		const rayOffset = calculateRayOffset( hitPoint, normal, material );
-		const rayOrigin = hitPoint.add( rayOffset );
-
-		// Determine shadow sampling strategy based on light angle
-		const shadowDirection = vec3( 0.0 ).toVar();
-		const lightPdf = float( 1e6 ).toVar();
-
-		If( light.angle.greaterThan( 0.001 ), () => {
-
-			// Soft shadows: sample direction within cone
-			const xi_r1 = RandomValue( rngState ).toVar();
-			const xi_r2 = RandomValue( rngState ).toVar();
-			const xi = vec2( xi_r1, xi_r2 );
-			const halfAngle = light.angle.mul( 0.5 );
-			shadowDirection.assign( sampleCone( { direction: light.direction, halfAngle, xi } ) );
-
-			// Calculate PDF for cone sampling
-			const cosHalfAngle = cos( halfAngle );
-			lightPdf.assign( float( 1.0 ).div( TWO_PI.mul( float( 1.0 ).sub( cosHalfAngle ) ) ) );
-
-		} ).Else( () => {
-
-			shadowDirection.assign( light.direction );
-
-		} );
-
-		const NoL = max( float( 0.0 ), dot( normal, shadowDirection ) );
-
-		If( NoL.greaterThan( 0.0 ), () => {
-
-			const maxShadowDistance = float( 1e6 );
-			const visibility = traceShadowRayFn( rayOrigin, shadowDirection, maxShadowDistance, rngState );
-
-			If( visibility.greaterThan( 0.0 ), () => {
-
-				const brdfValue = evaluateMaterialResponseCachedFn( viewDir, shadowDirection, normal, material, matCache );
-				const lightRadiance = light.color.mul( light.intensity );
-				const contribution = lightRadiance.mul( brdfValue ).mul( NoL ).mul( visibility );
-
-				// MIS for directional lights (only on primary rays)
-				If( bounceIndex.equal( int( 0 ) ).and( brdfSample.pdf.greaterThan( 0.0 ) ), () => {
-
-					const alignment = max( float( 0.0 ), dot( normalize( brdfSample.direction ), shadowDirection ) );
-
-					If( alignment.greaterThan( 0.996 ), () => {
-
-						const misWeight = powerHeuristic( { pdf1: lightPdf, pdf2: brdfSample.pdf } );
-						result.assign( contribution.mul( misWeight ) );
-
-					} ).Else( () => {
-
-						result.assign( contribution );
-
-					} );
-
-				} ).Else( () => {
-
-					result.assign( contribution );
-
-				} );
-
-			} );
-
-		} );
-
-	} );
-
-	return result;
-
-} );
-
-// ================================================================================
-// AREA LIGHT CONTRIBUTION
-// ================================================================================
-
-export const calculateAreaLightContribution = Fn( ( [
-	light, hitPoint, normal, viewDir, material, matCache, brdfSample,
-	sampleIndex, bounceIndex, rngState,
-	traceShadowRayFn,
-	evaluateMaterialResponseCachedFn,
-	getRandomSampleFn,
-] ) => {
-
-	const contribution = vec3( 0.0 ).toVar();
-
-	const lightImportance = estimateLightImportance( light, hitPoint, normal, material );
-
-	If( lightImportance.greaterThanEqual( 0.001 ), () => {
-
-		const rayOffset = calculateRayOffset( hitPoint, normal, material );
-		const rayOrigin = hitPoint.add( rayOffset );
-
-		const isDiffuse = material.roughness.greaterThan( 0.7 ).and( material.metalness.lessThan( 0.3 ) );
-		const isSpecular = material.roughness.lessThan( 0.3 ).or( material.metalness.greaterThan( 0.7 ) );
-		const isFirstBounce = bounceIndex.equal( int( 0 ) );
-
-		// LIGHT SAMPLING STRATEGY
-		If( isFirstBounce.or( isDiffuse ).or( lightImportance.greaterThan( 0.1 ).and( isSpecular.not() ) ), () => {
-
-			const ruv = getRandomSampleFn( sampleIndex, bounceIndex, rngState );
-
-			// Generate position on light surface
-			const lightPos = light.position
-				.add( light.u.mul( ruv.x.sub( 0.5 ) ) )
-				.add( light.v.mul( ruv.y.sub( 0.5 ) ) );
-
-			const toLight = lightPos.sub( hitPoint );
-			const lightDistSq = dot( toLight, toLight );
-			const lightDist = sqrt( lightDistSq );
-			const lightDir = toLight.div( lightDist );
-
-			const NoL = max( float( 0.0 ), dot( normal, lightDir ) );
-			const lightFacing = max( float( 0.0 ), dot( lightDir, light.normal ).negate() );
-
-			If( NoL.greaterThan( 0.0 ).and( lightFacing.greaterThan( 0.0 ) ), () => {
-
-				const visibility = traceShadowRayFn( rayOrigin, lightDir, lightDist, rngState );
-
-				If( visibility.greaterThan( 0.0 ), () => {
-
-					const brdfValue = evaluateMaterialResponseCachedFn( viewDir, lightDir, normal, material, matCache );
-
-					// Calculate PDFs for MIS
-					const lightPdf = lightDistSq.div( max( light.area.mul( lightFacing ), EPSILON ) );
-					const brdfPdf = brdfSample.pdf;
-
-					// Light contribution with inverse-square falloff
-					const falloff = light.area.div( float( 4.0 ).mul( PI ).mul( lightDistSq ) );
-					const lightContribution = light.color.mul( light.intensity ).mul( falloff ).mul( lightFacing );
-
-					// MIS weight
-					const misWeight = select(
-						brdfPdf.greaterThan( 0.0 ).and( isFirstBounce ),
-						powerHeuristic( { pdf1: lightPdf, pdf2: brdfPdf } ),
-						float( 1.0 ),
-					);
-
-					contribution.addAssign( lightContribution.mul( brdfValue ).mul( NoL ).mul( visibility ).mul( misWeight ) );
-
-				} );
-
-			} );
-
-		} );
-
-		// BRDF SAMPLING STRATEGY
-		If( isFirstBounce.or( isSpecular ).and( brdfSample.pdf.greaterThan( 0.0 ) ), () => {
-
-			const toLight = light.position.sub( rayOrigin );
-			const rayToLightDot = dot( toLight, brdfSample.direction );
-
-			If( rayToLightDot.greaterThan( 0.0 ), () => {
-
-				const hitDistance = intersectAreaLight( light, rayOrigin, brdfSample.direction );
-
-				If( hitDistance.greaterThan( 0.0 ), () => {
-
-					const visibility = traceShadowRayFn( rayOrigin, brdfSample.direction, hitDistance, rngState );
-
-					If( visibility.greaterThan( 0.0 ), () => {
-
-						const lightFacing = max( float( 0.0 ), dot( brdfSample.direction, light.normal ).negate() );
-
-						If( lightFacing.greaterThan( 0.0 ), () => {
-
-							const lightPdf = hitDistance.mul( hitDistance ).div( max( light.area.mul( lightFacing ), EPSILON ) );
-							const misWeight = powerHeuristic( { pdf1: brdfSample.pdf, pdf2: lightPdf } );
-
-							const lightEmission = light.color.mul( light.intensity );
-							const NoL = max( float( 0.0 ), dot( normal, brdfSample.direction ) );
-
-							contribution.addAssign( lightEmission.mul( brdfSample.value ).mul( NoL ).mul( visibility ).mul( misWeight ) );
-
-						} );
-
-					} );
-
-				} );
-
-			} );
-
-		} );
-
-	} );
-
-	return contribution;
-
-} );
-
-// ================================================================================
-// POINT LIGHT CONTRIBUTION
-// ================================================================================
-
-export const calculatePointLightContribution = Fn( ( [
-	light, hitPoint, normal, viewDir, material, matCache, brdfSample, bounceIndex,
-	rngState,
-	traceShadowRayFn,
-	evaluateMaterialResponseFn,
-] ) => {
-
-	const result = vec3( 0.0 ).toVar();
-
-	const toLight = light.position.sub( hitPoint );
-	const distance = length( toLight );
-
-	If( distance.lessThanEqual( 1000.0 ), () => {
-
-		const lightDir = toLight.div( distance );
-		const NdotL = dot( normal, lightDir );
-
-		If( NdotL.greaterThan( 0.0 ), () => {
-
-			const attenuation = float( 1.0 ).div( distance.mul( distance ) );
-			const lightRadiance = light.color.mul( light.intensity ).mul( attenuation );
-
-			const rayOffset = calculateRayOffset( hitPoint, normal, material );
-			const rayOrigin = hitPoint.add( rayOffset );
-
-			const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.sub( 0.001 ), rngState );
-
-			If( visibility.greaterThan( 0.0 ), () => {
-
-				const brdfValue = evaluateMaterialResponseFn( viewDir, lightDir, normal, material );
-				result.assign( brdfValue.mul( lightRadiance ).mul( NdotL ).mul( visibility ) );
-
-			} );
-
-		} );
-
-	} );
-
-	return result;
-
-} );
-
-// ================================================================================
-// SPOT LIGHT CONTRIBUTION
-// ================================================================================
-
-export const calculateSpotLightContribution = Fn( ( [
-	light, hitPoint, normal, viewDir, material, matCache, brdfSample, bounceIndex,
-	rngState,
-	traceShadowRayFn,
-	evaluateMaterialResponseFn,
-] ) => {
-
-	const result = vec3( 0.0 ).toVar();
-
-	const toLight = light.position.sub( hitPoint );
-	const distance = length( toLight );
-
-	If( distance.lessThanEqual( 1000.0 ), () => {
-
-		const lightDir = toLight.div( distance );
-		const NdotL = dot( normal, lightDir );
-
-		If( NdotL.greaterThan( 0.0 ), () => {
-
-			const spotCosAngle = dot( lightDir.negate(), light.direction );
-			const coneCosAngle = cos( light.angle );
-
-			If( spotCosAngle.greaterThanEqual( coneCosAngle ), () => {
-
-				const coneAttenuation = smoothstep( coneCosAngle, coneCosAngle.add( 0.1 ), spotCosAngle );
-				const distanceAttenuation = float( 1.0 ).div( distance.mul( distance ) );
-				const lightRadiance = light.color.mul( light.intensity ).mul( distanceAttenuation ).mul( coneAttenuation );
-
-				const rayOffset = calculateRayOffset( hitPoint, normal, material );
-				const rayOrigin = hitPoint.add( rayOffset );
-
-				const visibility = traceShadowRayFn( rayOrigin, lightDir, distance.sub( 0.001 ), rngState );
-
-				If( visibility.greaterThan( 0.0 ), () => {
-
-					const brdfValue = evaluateMaterialResponseFn( viewDir, lightDir, normal, material );
-					result.assign( brdfValue.mul( lightRadiance ).mul( NdotL ).mul( visibility ) );
-
-				} );
-
-			} );
-
-		} );
-
-	} );
-
-	return result;
-
-} );

package/src/TSL/LightsSampling.js

@@ -8,14 +8,11 @@
  *  - Deterministic environment NEE (always runs, two-strategy Veach MIS with implicit miss)
  *
  * Contains:
- *  - initLightSample                  — fully initialize LightSample
  *  - sampleRectAreaLight              — rectangle area light sampling
- *  - sampleCircAreaLight              — circle area light sampling
  *  - sampleSpotLightWithRadius        — spot light sampling with radius
  *  - samplePointLightWithAttenuation  — point light sampling with attenuation
  *  - sampleLightWithImportance        — importance-weighted light selection (3-pass)
  *  - calculateMaterialPDF             — material PDF for MIS
- *  - sampleAreaLightContribution      — area light with MIS
  *  - calculateDirectLightingUnified   — unified direct lighting (main entry)
  */
 
@@ -93,23 +90,6 @@ import {
 
 const TWO_PI = 2.0 * PI;
 
-// =============================================================================
-// Helper: Fully Initialize LightSample
-// =============================================================================
-
-export const initLightSample = Fn( () => {
-
-	return LightSample( {
-		valid: tslBool( false ),
-		direction: vec3( 0.0, 1.0, 0.0 ),
-		emission: vec3( 0.0 ),
-		distance: float( 0.0 ),
-		pdf: float( 0.0 ),
-		lightType: int( LIGHT_TYPE_POINT ),
-	} );
-
-} );
-
 // =============================================================================
 // Light Sampling Functions
 // =============================================================================
@@ -170,66 +150,6 @@ export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 
 } );
 
-// Enhanced area light sampling - circle
-export const sampleCircAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelectionPdf ] ) => {
-
-	const ls_valid = tslBool( false ).toVar();
-	const ls_direction = vec3( 0.0, 1.0, 0.0 ).toVar();
-	const ls_emission = vec3( 0.0 ).toVar();
-	const ls_distance = float( 0.0 ).toVar();
-	const ls_pdf = float( 0.0 ).toVar();
-	const ls_lightType = int( LIGHT_TYPE_POINT ).toVar();
-
-	// Validate light area to prevent NaN
-	If( light.area.greaterThan( 0.0 ), () => {
-
-		// Sample random position on circle
-		const r = float( 0.5 ).mul( sqrt( ruv.x ) ).toVar();
-		const theta = ruv.y.mul( TWO_PI ).toVar();
-		const x = r.mul( cos( theta ) ).toVar();
-		const y = r.mul( sin( theta ) ).toVar();
-
-		const randomPos = light.position
-			.add( light.u.mul( x ) )
-			.add( light.v.mul( y ) )
-			.toVar();
-
-		const toLight = randomPos.sub( rayOrigin ).toVar();
-		const lightDistSq = dot( toLight, toLight ).toVar();
-
-		// Guard against zero distance
-		If( lightDistSq.greaterThanEqual( 1e-10 ), () => {
-
-			const dist = sqrt( lightDistSq ).toVar();
-			const direction = toLight.div( dist ).toVar();
-			const lightNormal = normalize( cross( light.u, light.v ) ).toVar();
-			const cosAngle = dot( direction.negate(), lightNormal ).toVar();
-
-			ls_lightType.assign( int( LIGHT_TYPE_AREA ) );
-			ls_emission.assign( light.color.mul( light.intensity ) );
-			ls_distance.assign( dist );
-			ls_direction.assign( direction );
-			// Guard division
-			ls_pdf.assign(
-				lightDistSq.div( max( light.area.mul( max( cosAngle, 0.001 ) ), 1e-10 ) ).mul( lightSelectionPdf )
-			);
-			ls_valid.assign( cosAngle.greaterThan( 0.0 ) );
-
-		} );
-
-	} );
-
-	return LightSample( {
-		valid: ls_valid,
-		direction: ls_direction,
-		emission: ls_emission,
-		distance: ls_distance,
-		pdf: ls_pdf,
-		lightType: ls_lightType,
-	} );
-
-} );
-
 // Enhanced spot light sampling with radius support
 export const sampleSpotLightWithRadius = Fn( ( [ light, rayOrigin, ruv, lightSelectionPdf ] ) => {
 
@@ -819,97 +739,6 @@ export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material
 
 } );
 
-// =============================================================================
-// Enhanced Area Light Sampling with MIS
-// =============================================================================
-
-export const sampleAreaLightContribution = Fn( ( [
-	light,
-	worldWo,
-	hitPoint, hitNormal, material,
-	rayOrigin,
-	bounceIndex,
-	rngState,
-	// Shadow ray resources
-	bvhBuffer,
-	triangleBuffer,
-	materialBuffer,
-] ) => {
-
-	const result = vec3( 0.0 ).toVar();
-
-	// Sample random position on light surface
-	const ruv_r1 = RandomValue( rngState ).toVar();
-	const ruv_r2 = RandomValue( rngState ).toVar();
-	const ruv = vec2( ruv_r1, ruv_r2 ).toVar();
-	const lightPos = light.position.add( light.u.mul( ruv.x.mul( 2.0 ).sub( 1.0 ) ) ).add( light.v.mul( ruv.y.mul( 2.0 ).sub( 1.0 ) ) ).toVar();
-
-	const toLight = lightPos.sub( rayOrigin ).toVar();
-	const lightDistSq = dot( toLight, toLight ).toVar();
-
-	// Guard against zero distance
-	If( lightDistSq.greaterThanEqual( 1e-10 ), () => {
-
-		const lightDist = sqrt( lightDistSq ).toVar();
-		const lightDir = toLight.div( lightDist ).toVar();
-
-		// Check if light is facing the surface
-		const lightNormal = normalize( cross( light.u, light.v ) ).toVar();
-		const lightFacing = dot( lightDir.negate(), lightNormal ).toVar();
-
-		If( lightFacing.greaterThan( 0.0 ), () => {
-
-			// Check if surface is facing the light
-			const surfaceFacing = dot( hitNormal, lightDir ).toVar();
-
-			If( surfaceFacing.greaterThan( 0.0 ), () => {
-
-				// Validate direction
-				If( isDirectionValid( { direction: lightDir, surfaceNormal: hitNormal } ), () => {
-
-					// Test for occlusion
-					const visibility = traceShadowRay(
-						rayOrigin, lightDir, lightDist.sub( 0.001 ), rngState,
-						traverseBVHShadow,
-						bvhBuffer,
-						triangleBuffer,
-						materialBuffer,
-					);
-
-					If( visibility.greaterThan( 0.0 ), () => {
-
-						// Calculate BRDF
-						const brdfColor = evaluateMaterialResponse( worldWo, lightDir, hitNormal, material );
-
-						// Calculate light PDF - guard division
-						const lightPdf = lightDistSq.div( max( light.area.mul( lightFacing ), EPSILON ) ).toVar();
-
-						// Calculate BRDF PDF for MIS
-						const brdfPdf = calculateMaterialPDF( worldWo, lightDir, hitNormal, material ).toVar();
-
-						// Apply MIS weighting
-						const misWeight = select( brdfPdf.greaterThan( 0.0 ), powerHeuristic( { pdf1: lightPdf, pdf2: brdfPdf } ), float( 1.0 ) ).toVar();
-
-						// Calculate final contribution - guard division
-						const lightEmission = light.color.mul( light.intensity ).toVar();
-						result.assign(
-							lightEmission.mul( brdfColor ).mul( surfaceFacing ).mul( visibility ).mul( misWeight ).div( max( lightPdf, MIN_PDF ) )
-						);
-
-					} );
-
-				} );
-
-			} );
-
-		} );
-
-	} );
-
-	return result;
-
-} );
-
 // =============================================================================
 // Unified Direct Lighting System
 // =============================================================================