rayzee 5.10.2 → 6.0.0

package/src/TSL/MaterialEvaluation.js

@@ -1,9 +1,9 @@
 import {
-	Fn, float, vec3, int,
-	If, max, min, dot, sqrt, clamp, mix, normalize, pow
+	Fn, float, vec3,
+	If, max, min, clamp, mix
 } from 'three/tsl';
 
-import { DotProducts, MaterialCache } from './Struct.js';
+import { DotProducts } from './Struct.js';
 import {
 	PI, PI_INV, EPSILON, MIN_CLEARCOAT_ROUGHNESS,
 	computeDotProducts,
@@ -118,110 +118,10 @@ export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ] ) => {
 
 } );
 
-// -----------------------------------------------------------------------------
-// Cached Material Response Evaluation (Optimized)
-// -----------------------------------------------------------------------------
-
-export const evaluateMaterialResponseCached = Fn( ( [ V, L, N, material, cache ] ) => {
-
-	const result = vec3( 0.0 ).toVar();
-
-	If( cache.isPurelyDiffuse, () => {
-
-		result.assign( cache.diffuseColor );
-
-	} ).Else( () => {
-
-		const H = V.add( L ).toVar();
-		const lenSq = dot( H, H );
-		H.assign( lenSq.greaterThan( EPSILON ).select( H.div( sqrt( lenSq ) ), vec3( 0.0, 0.0, 1.0 ) ) );
-		const NoL = max( dot( N, L ), EPSILON );
-		const NoH = max( dot( N, H ), EPSILON );
-		const VoH = max( dot( V, H ), EPSILON );
-
-		const isTransmission = cache.NoV.mul( NoL ).lessThan( 0.0 );
-		If( isTransmission.and( material.transmission.greaterThan( 0.0 ) ), () => {
-
-			result.assign( evaluateMaterialResponse( V, L, N, material ) );
-
-		} ).Else( () => {
-
-			const F0 = cache.F0.toVar();
-
-			// Iridescence
-			If( material.iridescence.greaterThan( 0.0 ), () => {
-
-				// Per glTF KHR_materials_iridescence spec: use max thickness when no texture
-				const thickness = material.iridescenceThicknessRange.y;
-				const iridescenceFresnel = evalIridescence( float( 1.0 ), material.iridescenceIOR, VoH, thickness, F0 );
-				F0.assign( clamp( mix( F0, iridescenceFresnel, material.iridescence ), vec3( 0.0 ), vec3( 1.0 ) ) );
-
-			} );
-
-			// Use precomputed values
-			const denom = NoH.mul( NoH ).mul( cache.alpha2.sub( 1.0 ) ).add( 1.0 );
-			const D = cache.alpha2.div( max( float( PI ).mul( denom ).mul( denom ), EPSILON ) );
-
-			const ggx1 = NoL.div( NoL.mul( float( 1.0 ).sub( cache.k ) ).add( cache.k ) );
-			const ggx2 = cache.NoV.div( cache.NoV.mul( float( 1.0 ).sub( cache.k ) ).add( cache.k ) );
-			const G = ggx1.mul( ggx2 );
-
-			const F = fresnelSchlick( VoH, F0 ).toVar();
-
-			// Single-scatter specular BRDF
-			const specularDenom = max( float( 4.0 ).mul( cache.NoV ).mul( NoL ), EPSILON );
-			const specularSS = D.mul( G ).mul( F ).div( specularDenom );
-
-			// Kulla-Conty multiscatter energy compensation for rough surfaces
-			const specular = specularSS.mul( multiscatterCompensation( F0, cache.NoV, material.roughness ) );
-			// Diffuse energy budget from hemisphere-integrated specular albedo (includes multiscatter)
-			const E_total = specularDirectionalAlbedo( F0, cache.NoV, material.roughness );
-			const kD = vec3( 1.0 ).sub( E_total ).mul( float( 1.0 ).sub( material.metalness ) );
-			const diffuse = kD.mul( material.color.rgb ).mul( PI_INV );
-
-			const baseLayer = diffuse.add( specular ).toVar();
-
-			// Sheen
-			If( material.sheen.greaterThan( 0.0 ), () => {
-
-				const sheenDist = SheenDistribution( NoH, material.sheenRoughness );
-				const sheenTerm = material.sheenColor.mul( material.sheen ).mul( sheenDist ).mul( NoL );
-				// Hemisphere-averaged sheen reflectance for energy-conserving base layer attenuation
-				const avgSheenFactor = float( 1.0 ).sub( material.sheenRoughness ).mul( 0.5 ).add( 0.25 );
-				const sheenReflectance = clamp( material.sheenColor.mul( material.sheen ).mul( avgSheenFactor ), vec3( 0.0 ), vec3( 1.0 ) );
-				const sheenAttenuation = vec3( 1.0 ).sub( sheenReflectance );
-
-				result.assign( baseLayer.mul( sheenAttenuation ).add( sheenTerm ) );
-
-			} ).Else( () => {
-
-				result.assign( baseLayer );
-
-			} );
-
-		} );
-
-	} );
-
-	return result;
-
-} );
-
 // -----------------------------------------------------------------------------
 // Layered BRDF Evaluation (for clearcoat)
 // -----------------------------------------------------------------------------
 
-// Helper function to calculate energy conservation for layered materials
-export const calculateLayerAttenuation = Fn( ( [ clearcoat, VoH ] ) => {
-
-	// Fresnel term for clearcoat layer (using f0 = 0.04 for dielectric)
-	const F = fresnelSchlickFloat( VoH, float( 0.04 ) );
-	// Two-interface clearcoat attenuation: (1-F)² blended by clearcoat strength
-	// = 1 - clearcoat * F * (2 - F)
-	return float( 1.0 ).sub( clearcoat.mul( F ).mul( float( 2.0 ).sub( F ) ) );
-
-} );
-
 // Evaluate both clearcoat and base layer BRDFs
 export const evaluateLayeredBRDF = Fn( ( [ dots, material ] ) => {
 

package/src/TSL/MaterialProperties.js

@@ -324,64 +324,9 @@ export const calculateBRDFWeights = Fn( ( [ material, mc, cache ] ) => {
 } );
 
 // -----------------------------------------------------------------------------
-// Material Importance and Sampling Info
+// Importance Sampling Info
 // -----------------------------------------------------------------------------
 
-export const getMaterialImportance = Fn( ( [ material, mc ] ) => {
-
-	const result = float( 0.0 ).toVar();
-
-	// Early out for specialized materials
-	If( material.transmission.greaterThan( 0.0 ).or( material.clearcoat.greaterThan( 0.0 ) ), () => {
-
-		result.assign( 0.95 );
-
-	} ).Else( () => {
-
-		// Base importance from complexity score
-		const baseImportance = mc.complexityScore.toVar();
-
-		// Enhanced emissive importance
-		const emissiveImportance = float( 0.0 ).toVar();
-		If( mc.isEmissive, () => {
-
-			const emissiveLuminance = dot( material.emissive, REC709_LUMINANCE_COEFFICIENTS );
-			emissiveImportance.assign( min( float( 0.6 ), emissiveLuminance.mul( material.emissiveIntensity ).mul( 0.25 ) ) );
-
-		} );
-
-		// Material-specific boosts
-		const materialBoost = float( 0.0 ).toVar();
-		If( mc.isMetallic.and( mc.isSmooth ), () => {
-
-			materialBoost.addAssign( 0.25 );
-
-		} ).ElseIf( mc.isMetallic, () => {
-
-			materialBoost.addAssign( 0.15 );
-
-		} );
-
-		If( mc.isTransmissive, () => {
-
-			materialBoost.addAssign( 0.2 );
-
-		} );
-		If( mc.hasClearcoat, () => {
-
-			materialBoost.addAssign( 0.1 );
-
-		} );
-
-		const totalImportance = max( baseImportance.add( materialBoost ), emissiveImportance );
-		result.assign( clamp( totalImportance, 0.0, 1.0 ) );
-
-	} );
-
-	return result;
-
-} );
-
 export const getImportanceSamplingInfo = Fn( ( [
 	material, bounceIndex, mc,
 	environmentIntensity, useEnvMapIS, enableEnvironmentLight

package/src/TSL/MaterialSampling.js

@@ -1,24 +1,9 @@
-import {
-	Fn, wgslFn, float, vec3, If, max, min, abs, normalize, reflect, refract, dot, pow
-} from 'three/tsl';
-
-import {
-	MultiLobeWeights, DirectionSample, MaterialCache, MaterialClassification
-} from './Struct.js';
-
-import {
-	PI, PI_INV, MIN_PDF, classifyMaterial,
-} from './Common.js';
-import { dielectricF0 } from './Fresnel.js';
-
-import { calculateBRDFWeights, calculateGGXPDF } from './MaterialProperties.js';
-import { RandomValue } from './Random.js';
+import { wgslFn } from 'three/tsl';
 
 // =============================================================================
 // MATERIAL SAMPLING
 // =============================================================================
-// This file contains importance sampling functions for various BRDF lobes
-// including GGX, cosine-weighted hemisphere, VNDF, and multi-lobe MIS.
+// Importance sampling primitives: GGX, cosine-weighted hemisphere, VNDF.
 
 // -----------------------------------------------------------------------------
 // Basic Sampling Functions
@@ -63,12 +48,6 @@ export const cosineWeightedSample = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
-export const cosineWeightedPDF = Fn( ( [ NoL ] ) => {
-
-	return max( NoL, MIN_PDF ).mul( PI_INV );
-
-} );
-
 // -----------------------------------------------------------------------------
 // VNDF Sampling (Visible Normal Distribution Function)
 // -----------------------------------------------------------------------------
@@ -95,264 +74,3 @@ export const sampleGGXVNDF = /*@__PURE__*/ wgslFn( `
 		return normalize( vec3f( alpha * Nh.x, alpha * Nh.y, max( 0.0f, Nh.z ) ) );
 	}
 ` );
-
-// -----------------------------------------------------------------------------
-// Multi-Lobe MIS Sampling
-// -----------------------------------------------------------------------------
-
-// Enhanced sampling weights calculation for multi-lobe MIS
-export const calculateSamplingWeights = Fn( ( [ V, N, material ] ) => {
-
-	// Get material classification for optimized calculations
-	const mc = MaterialClassification.wrap( classifyMaterial( material ) );
-
-	// Create temporary cache values
-	const tempInvRoughness = float( 1.0 ).sub( material.roughness );
-	const tempMetalFactor = float( 0.5 ).add( float( 0.5 ).mul( material.metalness ) );
-	const tempIorFactor = min( float( 2.0 ).div( material.ior ), 1.0 );
-	const tempMaxSheenColor = max( material.sheenColor.r, max( material.sheenColor.g, material.sheenColor.b ) );
-
-	// Create temporary cache for calculations
-	const tempCache = MaterialCache( {
-		F0: dielectricF0( material.ior ),
-		NoV: float( 0.5 ),
-		diffuseColor: material.color.rgb,
-		isPurelyDiffuse: false,
-		alpha: material.roughness.mul( material.roughness ),
-		k: material.roughness.add( 1.0 ).mul( material.roughness.add( 1.0 ) ).div( 8.0 ),
-		alpha2: material.roughness.mul( material.roughness ).mul( material.roughness ).mul( material.roughness ),
-		invRoughness: tempInvRoughness,
-		metalFactor: tempMetalFactor,
-		iorFactor: tempIorFactor,
-		maxSheenColor: tempMaxSheenColor,
-	} );
-
-	// Calculate base BRDF weights
-	const brdfWeights = BRDFWeights.wrap( calculateBRDFWeights( material, mc, tempCache ) );
-
-	// Calculate view-dependent factors
-	const NoV = max( dot( N, V ), 0.0 );
-	const fresnelFactor = pow( float( 1.0 ).sub( NoV ), 5.0 );
-
-	// Energy-conserving Fresnel redistribution: energy lost by diffuse transfers to specular
-	// This preserves the total (diffuse + specular) weight while shifting toward specular at grazing angles
-	const fresnelTransfer = brdfWeights.diffuse.mul( fresnelFactor );
-	const diffuse = brdfWeights.diffuse.sub( fresnelTransfer ).toVar();
-	const specular = brdfWeights.specular.add( fresnelTransfer ).toVar();
-
-	// Other lobes remain unchanged — no artificial inflation
-	const clearcoat = brdfWeights.clearcoat.toVar();
-	const transmission = brdfWeights.transmission.mul( tempIorFactor ).toVar();
-	const sheen = brdfWeights.sheen.toVar();
-	const iridescence = brdfWeights.iridescence.toVar();
-
-	// Calculate total weight for normalization
-	const totalWeight = max(
-		diffuse.add( specular ).add( clearcoat ).add( transmission ).add( sheen ).add( iridescence ),
-		1e-6
-	).toVar();
-
-	// Normalize weights
-	const invTotal = float( 1.0 ).div( totalWeight );
-
-	return MultiLobeWeights( {
-		diffuse: diffuse.mul( invTotal ),
-		specular: specular.mul( invTotal ),
-		clearcoat: clearcoat.mul( invTotal ),
-		transmission: transmission.mul( invTotal ),
-		sheen: sheen.mul( invTotal ),
-		iridescence: iridescence.mul( invTotal ),
-		totalWeight,
-	} );
-
-} );
-
-// Calculate MIS weight considering all possible sampling strategies
-export const calculateMultiLobeMISWeight = Fn( ( [
-	sampledDirection, V, N, material, weights, selectedPdf
-] ) => {
-
-	// Calculate PDFs for all possible sampling strategies
-	const diffusePdf = float( 0.0 ).toVar();
-	const specularPdf = float( 0.0 ).toVar();
-	const clearcoatPdf = float( 0.0 ).toVar();
-	const transmissionPdf = float( 0.0 ).toVar();
-	const sheenPdf = float( 0.0 ).toVar();
-
-	const NoL = dot( N, sampledDirection );
-
-	// Diffuse PDF
-	If( NoL.greaterThan( 0.0 ), () => {
-
-		diffusePdf.assign( NoL.div( PI ) );
-
-	} );
-
-	// Specular PDF
-	const H = normalize( V.add( sampledDirection ) ).toVar();
-	const NoH = max( dot( N, H ), 0.0 );
-	const VoH = max( dot( V, H ), 0.0 );
-	const NoV = max( dot( N, V ), 0.0 );
-
-	If( NoH.greaterThan( 0.0 ).and( VoH.greaterThan( 0.0 ) ).and( NoV.greaterThan( 0.0 ) ), () => {
-
-		specularPdf.assign( calculateGGXPDF( NoH, VoH, material.roughness ) );
-
-		// Clearcoat PDF (using clearcoat roughness)
-		If( material.clearcoat.greaterThan( 0.0 ), () => {
-
-			clearcoatPdf.assign( calculateGGXPDF( NoH, VoH, material.clearcoatRoughness ) );
-
-		} );
-
-	} );
-
-	// Transmission PDF (simplified)
-	If( material.transmission.greaterThan( 0.0 ).and( NoL.lessThan( 0.0 ) ), () => {
-
-		// For transmission, we're sampling the opposite hemisphere
-		transmissionPdf.assign( abs( NoL ).div( PI ) );
-
-	} );
-
-	// Sheen PDF (approximated as diffuse)
-	If( material.sheen.greaterThan( 0.0 ).and( NoL.greaterThan( 0.0 ) ), () => {
-
-		sheenPdf.assign( NoL.div( PI ) );
-
-	} );
-
-	// Calculate weighted PDFs for each lobe
-	const weightedDiffusePdf = weights.diffuse.mul( diffusePdf );
-	const weightedSpecularPdf = weights.specular.mul( specularPdf );
-	const weightedClearcoatPdf = weights.clearcoat.mul( clearcoatPdf );
-	const weightedTransmissionPdf = weights.transmission.mul( transmissionPdf );
-	const weightedSheenPdf = weights.sheen.mul( sheenPdf );
-	const weightedIridescencePdf = weights.iridescence.mul( diffusePdf );
-
-	// Power heuristic (β=2): sum of squared weighted PDFs
-	const sumSquaredPdfs = weightedDiffusePdf.mul( weightedDiffusePdf )
-		.add( weightedSpecularPdf.mul( weightedSpecularPdf ) )
-		.add( weightedClearcoatPdf.mul( weightedClearcoatPdf ) )
-		.add( weightedTransmissionPdf.mul( weightedTransmissionPdf ) )
-		.add( weightedSheenPdf.mul( weightedSheenPdf ) )
-		.add( weightedIridescencePdf.mul( weightedIridescencePdf ) );
-
-	// MIS weight: selectedPdf² / Σ(pdf_i²)
-	const misWeight = float( 1.0 ).toVar();
-
-	If( sumSquaredPdfs.greaterThan( 0.0 ).and( selectedPdf.greaterThan( 0.0 ) ), () => {
-
-		const selectedPdfSquared = selectedPdf.mul( selectedPdf );
-		misWeight.assign( selectedPdfSquared.div( sumSquaredPdfs ) );
-
-	} );
-
-	return misWeight;
-
-} );
-
-// Multi-lobe MIS for complex materials
-// Note: evaluateMaterialResponse is imported from MaterialEvaluation.js at usage site
-export const sampleMaterialWithMultiLobeMIS = Fn( ( [
-	V, N, material, xi, rngState, evaluateMaterialResponse
-] ) => {
-
-	// Calculate individual lobe weights
-	const weights = calculateSamplingWeights( V, N, material );
-
-	// Multi-importance sampling across different lobes
-	const rand = RandomValue( rngState );
-	const cumulativeDiffuse = weights.diffuse;
-	const cumulativeSpecular = cumulativeDiffuse.add( weights.specular );
-	const cumulativeClearcoat = cumulativeSpecular.add( weights.clearcoat );
-	const cumulativeTransmission = cumulativeClearcoat.add( weights.transmission );
-
-	const sampledDirection = vec3( 0.0 ).toVar();
-	const lobePdf = float( 0.0 ).toVar();
-	const resultPdf = float( 0.0 ).toVar();
-
-	If( rand.lessThan( cumulativeDiffuse ), () => {
-
-		// Diffuse sampling
-		sampledDirection.assign( ImportanceSampleCosine( { N, xi } ) );
-		lobePdf.assign( max( dot( N, sampledDirection ), 0.0 ).div( PI ) );
-		resultPdf.assign( lobePdf.mul( weights.diffuse ) );
-
-	} ).ElseIf( rand.lessThan( cumulativeSpecular ), () => {
-
-		// Specular sampling
-		const H = ImportanceSampleGGX( { N, roughness: material.roughness, Xi: xi } ).toVar();
-		sampledDirection.assign( reflect( V.negate(), H ) );
-
-		If( dot( N, sampledDirection ).greaterThan( 0.0 ), () => {
-
-			const NoH = max( dot( N, H ), 0.0 );
-			const VoH = max( dot( V, H ), 0.0 );
-			lobePdf.assign( calculateGGXPDF( NoH, VoH, material.roughness ) );
-
-		} );
-
-		resultPdf.assign( lobePdf.mul( weights.specular ) );
-
-	} ).ElseIf( rand.lessThan( cumulativeClearcoat ).and( material.clearcoat.greaterThan( 0.0 ) ), () => {
-
-		// Clearcoat sampling
-		const H = ImportanceSampleGGX( { N, roughness: material.clearcoatRoughness, Xi: xi } ).toVar();
-		sampledDirection.assign( reflect( V.negate(), H ) );
-
-		If( dot( N, sampledDirection ).greaterThan( 0.0 ), () => {
-
-			const NoH = max( dot( N, H ), 0.0 );
-			const VoH = max( dot( V, H ), 0.0 );
-			lobePdf.assign( calculateGGXPDF( NoH, VoH, material.clearcoatRoughness ) );
-
-		} );
-
-		resultPdf.assign( lobePdf.mul( weights.clearcoat ) );
-
-	} ).ElseIf( rand.lessThan( cumulativeTransmission ).and( material.transmission.greaterThan( 0.0 ) ), () => {
-
-		// Transmission sampling - simplified approach
-		const H = ImportanceSampleGGX( { N, roughness: material.roughness, Xi: xi } ).toVar();
-		const refractionDir = refract( V.negate(), H, float( 1.0 ).div( material.ior ) ).toVar();
-
-		If( dot( refractionDir, refractionDir ).greaterThan( 0.001 ), () => {
-
-			sampledDirection.assign( normalize( refractionDir ) );
-			const NoH = max( dot( N, H ), 0.0 );
-			const VoH = max( dot( V, H ), 0.0 );
-			lobePdf.assign( calculateGGXPDF( NoH, VoH, material.roughness ) );
-
-		} ).Else( () => {
-
-			// Total internal reflection - fallback to specular
-			sampledDirection.assign( reflect( V.negate(), H ) );
-			lobePdf.assign( 0.1 );
-
-		} );
-
-		resultPdf.assign( lobePdf.mul( weights.transmission ) );
-
-	} ).Else( () => {
-
-		// Fallback to diffuse sampling for sheen/iridescence
-		sampledDirection.assign( ImportanceSampleCosine( { N, xi } ) );
-		lobePdf.assign( max( dot( N, sampledDirection ), 0.0 ).div( PI ) );
-		resultPdf.assign( lobePdf.mul( weights.sheen.add( weights.iridescence ) ) );
-
-	} );
-
-	// Calculate MIS weight considering all possible sampling strategies
-	const misWeight = calculateMultiLobeMISWeight( sampledDirection, V, N, material, weights, resultPdf );
-
-	const resultValue = evaluateMaterialResponse( V, sampledDirection, N, material ).toVar();
-	resultValue.mulAssign( misWeight );
-
-	return DirectionSample( {
-		direction: sampledDirection,
-		value: resultValue,
-		pdf: resultPdf,
-	} );
-
-} );

package/src/TSL/MaterialTransmission.js

@@ -103,103 +103,10 @@ export const MediumStack = struct( {
 	depth: 'int',
 } );
 
-// ================================================================================
-// MEDIUM STACK HELPERS
-// ================================================================================
-
-export const getCurrentMediumIOR = Fn( ( [ mediumStack ] ) => {
-
-	const result = float( 1.0 ).toVar();
-
-	If( mediumStack.depth.greaterThan( int( 0 ) ), () => {
-
-		// Read IOR from current depth
-		If( mediumStack.depth.equal( int( 1 ) ), () => {
-
-			result.assign( mediumStack.m1_ior );
-
-		} );
-		If( mediumStack.depth.equal( int( 2 ) ), () => {
-
-			result.assign( mediumStack.m2_ior );
-
-		} );
-		If( mediumStack.depth.equal( int( 3 ) ), () => {
-
-			result.assign( mediumStack.m3_ior );
-
-		} );
-
-	} );
-
-	return result;
-
-} );
-
 // ================================================================================
 // DISPERSION
 // ================================================================================
 
-// Calculate wavelength-dependent IOR for dispersion using Cauchy dispersion equation
-export const calculateDispersiveIOR = /*@__PURE__*/ wgslFn( `
-	fn calculateDispersiveIOR( baseIOR: f32, dispersionStrength: f32 ) -> vec3f {
-		let B = dispersionStrength * 0.03f;
-		// Standard CIE wavelengths for RGB (in micrometers)
-		let wavelengths = vec3f( 0.7000f, 0.5461f, 0.4358f );
-		// Apply Cauchy's equation: n(λ) = A + B/λ²
-		let dispersiveIOR = baseIOR + B / ( wavelengths * wavelengths );
-		return max( dispersiveIOR, vec3f( 1.001f ) );
-	}
-` );
-
-// Convert wavelength to RGB using spectral sensitivity curves
-export const wavelengthToRGB = /*@__PURE__*/ wgslFn( `
-	fn wavelengthToRGB( wavelength: f32 ) -> vec3f {
-		var color = vec3f( 0.0f );
-		// Violet: 380-440
-		if ( wavelength >= 380.0f && wavelength < 440.0f ) {
-			let t = ( wavelength - 380.0f ) / 60.0f;
-			color = vec3f( 0.6f + 0.4f * ( 1.0f - t ), 0.0f, 1.0f );
-		}
-		// Blue: 440-490
-		if ( wavelength >= 440.0f && wavelength < 490.0f ) {
-			let t = ( wavelength - 440.0f ) / 50.0f;
-			color = vec3f( 0.6f * ( 1.0f - t ), 0.0f, 1.0f );
-		}
-		// Blue-Cyan: 490-510
-		if ( wavelength >= 490.0f && wavelength < 510.0f ) {
-			let t = ( wavelength - 490.0f ) / 20.0f;
-			color = vec3f( 0.0f, t, 1.0f );
-		}
-		// Cyan-Green-Yellow: 510-580
-		if ( wavelength >= 510.0f && wavelength < 580.0f ) {
-			let t = ( wavelength - 510.0f ) / 70.0f;
-			if ( t < 0.5f ) {
-				color = vec3f( 0.0f, 1.0f, 1.0f - t * 2.0f );
-			} else {
-				color = vec3f( ( t - 0.5f ) * 2.0f, 1.0f, 0.0f );
-			}
-		}
-		// Yellow-Orange-Red: 580-645
-		if ( wavelength >= 580.0f && wavelength < 645.0f ) {
-			let t = ( wavelength - 580.0f ) / 65.0f;
-			color = vec3f( 1.0f, 1.0f - t, 0.0f );
-		}
-		// Red: 645-700
-		if ( wavelength >= 645.0f && wavelength <= 700.0f ) {
-			color = vec3f( 1.0f, 0.0f, 0.0f );
-		}
-		// Apply intensity falloff at spectrum edges
-		if ( wavelength < 420.0f ) {
-			color = color * ( ( wavelength - 380.0f ) / 40.0f );
-		}
-		if ( wavelength > 680.0f ) {
-			color = color * ( ( 700.0f - wavelength ) / 20.0f );
-		}
-		return color;
-	}
-` );
-
 // Enhanced spectral sampling for realistic dispersion
 export const sampleWavelengthForDispersion = Fn( ( [ baseIOR, dispersionStrength, random ] ) => {
 

package/src/TSL/Random.js

@@ -138,21 +138,6 @@ export const RandomValue = ( state ) => {
 
 };
 
-// Generate random float with better precision
-
-export const RandomValueHighPrecision = ( state ) => {
-
-	// Capture s1 immediately (.toVar()) before advancing state, so it isn't
-	// re-evaluated lazily after the second pcgHash advances state further.
-	const s1 = pcgHash( { state } ).toVar();
-	state.assign( s1 );
-	const s2 = pcgHash( { state } ).toVar();
-
-	// Combine two 24-bit values for 48-bit precision
-	return float( s1.shiftRight( 8 ) ).add( float( s2.shiftRight( 8 ) ).mul( 1.0 / 16777216.0 ) ).mul( 1.0 / 16777216.0 );
-
-};
-
 // -----------------------------------------------------------------------------
 // Directional sampling functions
 // -----------------------------------------------------------------------------
@@ -198,14 +183,6 @@ const computeSTBNAtlasCoord = ( pixelCoords, sampleIndex, dimensionIndex, frame
 
 };
 
-// Sample 1D scalar STBN value in [0,1]
-export const sampleSTBNScalar = ( pixelCoords, sampleIndex, dimensionIndex, frame ) => {
-
-	const coord = computeSTBNAtlasCoord( pixelCoords, sampleIndex, dimensionIndex, frame );
-	return stbnScalarTextureNode.load( coord ).x;
-
-};
-
 // Sample decorrelated 2D STBN pair in [0,1]²
 export const sampleSTBN2D = ( pixelCoords, sampleIndex, dimensionPairIndex, frame ) => {
 

package/src/TSL/Struct.js

@@ -216,22 +216,6 @@ export const MISStrategy = struct( {
 	useEnvSampling: 'bool',
 } );
 
-// IMPROVEMENT: Multi-layer MIS type aliases and extensions
-// Use existing structs with clear naming for multi-lobe MIS
-// #define MaterialWeights BRDFWeights
-// #define SamplingResult DirectionSample
-
-// Enhanced material weights for multi-lobe sampling
-export const MultiLobeWeights = struct( {
-	diffuse: 'float',
-	specular: 'float',
-	clearcoat: 'float',
-	transmission: 'float',
-	sheen: 'float',
-	iridescence: 'float',
-	totalWeight: 'float',
-} );
-
 // General rendering state (used across all rendering paths)
 export const RenderState = struct( {
 	traversals: 'int', // Remaining general bounces
@@ -241,8 +225,3 @@ export const RenderState = struct( {
 	actualBounceDepth: 'int', // True depth without manipulation
 } );
 
-export const pathTracerOutputStruct = struct( {
-	gColor: 'vec4', // RGB + alpha
-	gNormalDepth: 'vec4', // Normal(RGB) + depth(A)
-	gAlbedo: 'vec4' // Albedo color + alpha
-} );