rayzee 6.2.0 → 6.3.0

package/src/TSL/Common.js

@@ -204,7 +204,7 @@ export const applySoftSuppressionRGB = wgslFn( `
 export const classifyMaterial = Fn( ( [ metalness, roughness, transmission, clearcoat, emissive ] ) => {
 
 	const isMetallic = metalness.greaterThan( 0.7 ).toVar();
-	const isRough = roughness.greaterThan( 0.8 ).toVar();
+	const isRough = roughness.greaterThan( 0.8 );
 	const isSmooth = roughness.lessThan( 0.3 ).toVar();
 	const isTransmissive = transmission.greaterThan( 0.5 ).toVar();
 	const hasClearcoat = clearcoat.greaterThan( 0.5 ).toVar();
@@ -218,8 +218,7 @@ export const classifyMaterial = Fn( ( [ metalness, roughness, transmission, clea
 		.add( float( 0.25 ).mul( float( isSmooth ) ) )
 		.add( float( 0.45 ).mul( float( isTransmissive ) ) )
 		.add( float( 0.35 ).mul( float( hasClearcoat ) ) )
-		.add( float( 0.3 ).mul( float( isEmissive ) ) )
-		.toVar();
+		.add( float( 0.3 ).mul( float( isEmissive ) ) );
 
 	// Add material interaction complexity
 	const interactionComplexity = float( 0.0 ).toVar();
@@ -255,7 +254,7 @@ export const selectOptimalMISStrategy = Fn( ( [ roughness, metalness, bounceInde
 	const brdfWeight = float( 0.5 ).toVar();
 	const lightWeight = float( 0.5 ).toVar();
 	const useBRDFSampling = tslBool( true );
-	const useLightSampling = throughputStrength.greaterThan( 0.01 ).toVar();
+	const useLightSampling = throughputStrength.greaterThan( 0.01 );
 
 	If( roughness.lessThan( 0.1 ).and( metalness.greaterThan( 0.8 ) ), () => {
 

package/src/TSL/Debugger.js

@@ -124,15 +124,15 @@ export const TraceDebugMode = Fn( ( [
 			} ).toVar();
 
 			const envLuminance = dot( envSample.xyz, REC709_LUMINANCE_COEFFICIENTS ).toVar();
-			const rawLuminance = envLuminance.toVar();
+			const rawLuminance = envLuminance;
 
 			// Adaptive scaling
 			const adaptiveScale = max( debugVisScale.mul( 0.1 ), 0.001 );
-			const scaledLuminance = envLuminance.div( adaptiveScale ).toVar();
+			const scaledLuminance = envLuminance.div( adaptiveScale );
 
 			// Logarithmic scaling for better dynamic range
 			const logLuminance = log( envLuminance.add( 1e-6 ) );
-			const logScaled = logLuminance.add( 10.0 ).div( 10.0 ).toVar();
+			const logScaled = logLuminance.add( 10.0 ).div( 10.0 );
 
 			// Choose scaling based on debugVisScale
 			const finalValue = select( debugVisScale.greaterThan( 1.0 ), scaledLuminance, logScaled ).toVar();
@@ -327,7 +327,7 @@ export const TraceDebugMode = Fn( ( [
 				material, hitInfo.uv, hitInfo.normal,
 			) ).toVar();
 
-			const albedoA = matSamples.albedo.rgb.toVar();
+			const albedoA = matSamples.albedo.rgb;
 			const normalA = normalize( matSamples.normal ).toVar();
 
 			// Generate per-pixel per-frame random seed for stochastic bounce direction
@@ -339,11 +339,11 @@ export const TraceDebugMode = Fn( ( [
 			// Cosine-weighted hemisphere sample around the surface normal
 			const xi_r1 = RandomValue( rngState ).toVar();
 			const xi_r2 = RandomValue( rngState ).toVar();
-			const xi = vec2( xi_r1, xi_r2 ).toVar();
+			const xi = vec2( xi_r1, xi_r2 );
 			const bounceDir = cosineWeightedSample( { N: normalA, xi } ).toVar();
 
 			// Trace secondary ray from the hit point (offset along normal to avoid self-intersection)
-			const bounceOrigin = hitInfo.hitPoint.add( normalA.mul( 0.001 ) ).toVar();
+			const bounceOrigin = hitInfo.hitPoint.add( normalA.mul( 0.001 ) );
 			const bounceRay = Ray( { origin: bounceOrigin, direction: bounceDir } );
 
 			const bounceHit = HitInfo.wrap( traverseBVH(

package/src/TSL/Displacement.js

@@ -45,15 +45,15 @@ export const refineDisplacedIntersection = Fn( ( [
 	const triIdx = hitInfo.triangleIndex;
 
 	const pA = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 0 ), int( TRI_STRIDE ) ).xyz.toVar();
-	const pB = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 1 ), int( TRI_STRIDE ) ).xyz.toVar();
-	const pC = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 2 ), int( TRI_STRIDE ) ).xyz.toVar();
+	const pB = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 1 ), int( TRI_STRIDE ) ).xyz;
+	const pC = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 2 ), int( TRI_STRIDE ) ).xyz;
 
 	const uvData1 = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 6 ), int( TRI_STRIDE ) ).toVar();
-	const uvData2 = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 7 ), int( TRI_STRIDE ) ).toVar();
+	const uvData2 = getDatafromStorageBuffer( triangleBuffer, triIdx, int( 7 ), int( TRI_STRIDE ) );
 
 	const uvA = uvData1.xy.toVar();
-	const uvB = uvData1.zw.toVar();
-	const uvC = uvData2.xy.toVar();
+	const uvB = uvData1.zw;
+	const uvC = uvData2.xy;
 
 	// Compute tangent vectors from triangle edges + UV differences
 	const edge1 = pB.sub( pA ).toVar();
@@ -94,8 +94,8 @@ export const refineDisplacedIntersection = Fn( ( [
 			const rayProjDotT = dot( rayProj, T );
 			const rayProjDotB = dot( rayProj, B );
 
-			const du_dt = BdotB.mul( rayProjDotT ).sub( TdotB.mul( rayProjDotB ) ).mul( invDetJ ).toVar();
-			const dv_dt = TdotT.mul( rayProjDotB ).sub( TdotB.mul( rayProjDotT ) ).mul( invDetJ ).toVar();
+			const du_dt = BdotB.mul( rayProjDotT ).sub( TdotB.mul( rayProjDotB ) ).mul( invDetJ );
+			const dv_dt = TdotT.mul( rayProjDotB ).sub( TdotB.mul( rayProjDotT ) ).mul( invDetJ );
 			const dUV_dt = vec2( du_dt, dv_dt ).toVar();
 
 			// Ray height change per unit dt: how fast the ray moves along the surface normal
@@ -103,7 +103,7 @@ export const refineDisplacedIntersection = Fn( ( [
 
 			// March range: displacement shell extends ±0.5*scale from base surface
 			// Compute dt range to traverse the full shell
-			const absNdotD = max( abs( dh_ray_dt ), 0.001 ).toVar();
+			const absNdotD = max( abs( dh_ray_dt ), 0.001 );
 			const dtShell = scale.div( absNdotD ).toVar();
 
 			// Adaptive step count: full steps on primary ray, half on deeper bounces
@@ -113,7 +113,7 @@ export const refineDisplacedIntersection = Fn( ( [
 
 			// Start from above the shell, march through
 			const dtStart = dtShell.negate().toVar();
-			const dtEnd = dtShell.toVar();
+			const dtEnd = dtShell;
 			const dtStep = dtEnd.sub( dtStart ).div( float( marchSteps ) ).toVar();
 
 			// Track for binary refinement
@@ -129,10 +129,10 @@ export const refineDisplacedIntersection = Fn( ( [
 					const dt = dtStart.add( dtStep.mul( float( i ) ) ).toVar();
 
 					// UV at this point along the ray
-					const marchUV = hitInfo.uv.add( dUV_dt.mul( dt ) ).toVar();
+					const marchUV = hitInfo.uv.add( dUV_dt.mul( dt ) );
 
 					// Ray height above base surface at this dt
-					const rayHeight = dt.mul( dh_ray_dt ).toVar();
+					const rayHeight = dt.mul( dh_ray_dt );
 
 					// Displaced surface height
 					const heightSample = sampleDisplacementMap(
@@ -165,7 +165,7 @@ export const refineDisplacedIntersection = Fn( ( [
 				Loop( { start: int( 0 ), end: int( BINARY_STEPS ), type: 'int', condition: '<' }, () => {
 
 					const midDt = loDt.add( hiDt ).mul( 0.5 ).toVar();
-					const midUV = hitInfo.uv.add( dUV_dt.mul( midDt ) ).toVar();
+					const midUV = hitInfo.uv.add( dUV_dt.mul( midDt ) );
 					const midRayHeight = midDt.mul( dh_ray_dt );
 					const midSample = sampleDisplacementMap(
 						displacementMaps, material.displacementMapIndex, midUV, material.displacementTransform,
@@ -187,7 +187,7 @@ export const refineDisplacedIntersection = Fn( ( [
 				// Final intersection
 				const finalDt = loDt.add( hiDt ).mul( 0.5 ).toVar();
 				const finalUV = hitInfo.uv.add( dUV_dt.mul( finalDt ) ).toVar();
-				const finalPoint = hitInfo.hitPoint.add( rayDir.mul( finalDt ) ).toVar();
+				const finalPoint = hitInfo.hitPoint.add( rayDir.mul( finalDt ) );
 
 				const finalHeight = sampleDisplacementMap(
 					displacementMaps, material.displacementMapIndex, finalUV, material.displacementTransform,

package/src/TSL/Environment.js

@@ -47,19 +47,19 @@ export const sampleEquirect = Fn( ( [ environment, direction, environmentMatrix,
 
 		// sin(theta) matches the CDF's solid-angle weighting (lum * sinTheta)
 		const sinTheta = sin( uv.y.mul( Math.PI ) ).toVar();
-		const lum = dot( color, REC709_LUMINANCE_COEFFICIENTS ).toVar();
-		const weightedLum = lum.mul( sinTheta ).toVar();
+		const lum = dot( color, REC709_LUMINANCE_COEFFICIENTS );
+		const weightedLum = lum.mul( sinTheta );
 		// MIS Compensation: subtract delta to match the sharpened CDF
-		const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) ).toVar();
-		const pdf = compensatedWeight.div( envTotalSum ).toVar();
+		const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) );
+		const pdf = compensatedWeight.div( envTotalSum );
 
 		// 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();
+		);
+		const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf );
 
 		result.assign( vec4( color, finalPdf ) );
 
@@ -127,18 +127,18 @@ export const sampleEquirectProbability = Fn( ( [
 
 	// Calculate PDF — sin(theta) weighting + MIS Compensation (Karlík et al. 2019)
 	const sinTheta = sin( uv.y.mul( Math.PI ) ).toVar();
-	const lum = dot( color.div( environmentIntensity ), REC709_LUMINANCE_COEFFICIENTS ).toVar();
-	const weightedLum = lum.mul( sinTheta ).toVar();
-	const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) ).toVar();
-	const pdf = compensatedWeight.div( envTotalSum ).toVar();
+	const lum = dot( color.div( environmentIntensity ), REC709_LUMINANCE_COEFFICIENTS );
+	const weightedLum = lum.mul( sinTheta );
+	const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) );
+	const pdf = compensatedWeight.div( envTotalSum );
 
 	// 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();
+	);
+	const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf );
 
 	return vec4( direction, finalPdf );
 

package/src/TSL/LightsCore.js

@@ -291,18 +291,17 @@ export const sampleSpotGoboMask = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
 				vec3( 1.0, 0.0, 0.0 ),
 			);
 			const T = normalize( cross( up, forward ) ).toVar();
-			const B = cross( forward, T ).toVar();
+			const B = cross( forward, T );
 
 			// 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();
+			const px = dot( toSurface, T ).mul( invCos );
+			const py = dot( toSurface, B ).mul( invCos );
 
 			// 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();
+			const invTan = float( 0.5 ).div( max( tan( light.angle ), float( 1e-4 ) ) ).toVar();
+			const u = clamp( px.mul( invTan ).add( 0.5 ), float( 0.0 ), float( 1.0 ) );
+			const v = clamp( py.mul( invTan ).add( 0.5 ), float( 0.0 ), float( 1.0 ) );
 
 			if ( _goboMapsTexNode ) {
 
@@ -354,15 +353,15 @@ export const sampleDirectionalGoboMask = /*@__PURE__*/ Fn( ( [ light, surfacePoi
 			vec3( 1.0, 0.0, 0.0 ),
 		);
 		const T = normalize( cross( up, axis ) ).toVar();
-		const B = cross( axis, T ).toVar();
+		const B = cross( axis, T );
 
 		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();
+		const uTiled = u.sub( u.floor() );
+		const vTiled = v.sub( v.floor() );
 
 		if ( _goboMapsTexNode ) {
 
@@ -417,9 +416,9 @@ export const sampleIESProfile = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
 
 		// 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();
+		const cosV = clamp( dot( toSurface, forward ), float( - 1.0 ), float( 1.0 ) );
+		const vAngle = acos( cosV );
+		const v = clamp( vAngle.div( float( Math.PI ) ), float( 0.0 ), float( 1.0 ) );
 
 		// Horizontal angle: project emission direction onto plane perpendicular to forward.
 		const up = select(
@@ -428,13 +427,13 @@ export const sampleIESProfile = /*@__PURE__*/ Fn( ( [ light, lightDir ] ) => {
 			vec3( 1.0, 0.0, 0.0 ),
 		);
 		const T = normalize( cross( up, forward ) ).toVar();
-		const B = cross( forward, T ).toVar();
+		const B = cross( forward, T );
 
 		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();
+		const u = phi.div( float( 2.0 * Math.PI ) ).add( 0.5 );
 
 		if ( _iesProfilesTexNode ) {
 

package/src/TSL/LightsDirect.js

@@ -268,11 +268,8 @@ export const traceShadowRay = Fn( ( [
 
 export const calculateRayOffset = Fn( ( [ hitPoint, normal, material ] ) => {
 
-	// Base epsilon scaled by scene size
-	const scaleEpsilon = max( float( 1e-4 ), length( hitPoint ).mul( 1e-6 ) ).toVar();
-
-	// Adjust for material properties
-	const materialEpsilon = scaleEpsilon.toVar();
+	// Base epsilon scaled by scene size; adjusted by material properties below.
+	const materialEpsilon = max( float( 1e-4 ), length( hitPoint ).mul( 1e-6 ) ).toVar();
 
 	If( material.transmission.greaterThan( 0.0 ), () => {
 

package/src/TSL/LightsIndirect.js

@@ -71,17 +71,17 @@ export const calculateTransmissionPDF = Fn( ( [ V, L, N, ior, roughness, enterin
 
 	} );
 
-	const VoH = abs( dot( V, H ) ).toVar();
+	const VoH = abs( dot( V, H ) );
 	const LoH = abs( dot( L, H ) ).toVar();
 	const NoH = abs( dot( N, H ) ).toVar();
 
 	// GGX distribution
-	const D = DistributionGGX( NoH, roughness ).toVar();
+	const D = DistributionGGX( NoH, roughness );
 
 	// Jacobian for transmission
 	const denom_inner = VoH.add( LoH.mul( eta ) ).toVar();
-	const denom = denom_inner.mul( denom_inner ).toVar();
-	const jacobian = LoH.mul( eta ).mul( eta ).div( max( denom, EPSILON ) ).toVar();
+	const denom = denom_inner.mul( denom_inner );
+	const jacobian = LoH.mul( eta ).mul( eta ).div( max( denom, EPSILON ) );
 
 	return D.mul( NoH ).mul( jacobian );
 
@@ -92,10 +92,10 @@ export const calculateClearcoatPDF = Fn( ( [ V, L, N, clearcoatRoughness ] ) =>
 
 	const H_raw = V.add( L ).toVar();
 	const lenSq = dot( H_raw, H_raw ).toVar();
-	const H = select( lenSq.greaterThan( EPSILON ), H_raw.div( sqrt( lenSq ) ), N ).toVar();
+	const H = select( lenSq.greaterThan( EPSILON ), H_raw.div( sqrt( lenSq ) ), N );
 
-	const NoH = max( dot( N, H ), 0.0 ).toVar();
-	const NoV = max( dot( N, V ), 0.0 ).toVar();
+	const NoH = max( dot( N, H ), 0.0 );
+	const NoV = max( dot( N, V ), 0.0 );
 
 	return calculateVNDFPDF( NoH, NoV, clearcoatRoughness );
 
@@ -259,15 +259,14 @@ export const calculateIndirectLighting = Fn( ( [
 	const validInput = samplingInfo.diffuseImportance.greaterThanEqual( 0.0 )
 		.and( samplingInfo.specularImportance.greaterThanEqual( 0.0 ) )
 		.and( samplingInfo.transmissionImportance.greaterThanEqual( 0.0 ) )
-		.and( samplingInfo.clearcoatImportance.greaterThanEqual( 0.0 ) )
-		.toVar();
+		.and( samplingInfo.clearcoatImportance.greaterThanEqual( 0.0 ) );
 
 	If( validInput.not(), () => {
 
 		// Fallback to diffuse sampling
 		const r1_fb = RandomValue( rngState ).toVar();
 		const r2_fb = RandomValue( rngState ).toVar();
-		const sampleRand = vec2( r1_fb, r2_fb ).toVar();
+		const sampleRand = vec2( r1_fb, r2_fb );
 		r_direction.assign( cosineWeightedSample( N, sampleRand ) );
 		r_throughput.assign( material.color.xyz );
 		r_misWeight.assign( 1.0 );
@@ -312,7 +311,7 @@ export const calculateIndirectLighting = Fn( ( [
 		} ).ElseIf( selectedStrategy.equal( int( 3 ) ), () => {
 
 			// Strategy 3: Transmission
-			const entering = dot( V, N ).greaterThan( 0.0 ).toVar();
+			const entering = dot( V, N ).greaterThan( 0.0 );
 			// 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, float( 0.0 )
@@ -333,7 +332,7 @@ export const calculateIndirectLighting = Fn( ( [
 		// For transmission directions (below surface), use |cos| instead of max(cos, 0)
 		const rawNoL = dot( N, sampleDir ).toVar();
 		const NoL = max( rawNoL, 0.0 ).toVar();
-		const absNoL = abs( rawNoL ).toVar();
+		const absNoL = abs( rawNoL );
 
 		// Calculate combined PDF for MIS (material strategies only)
 		const combinedPdf = float( 0.0 ).toVar();
@@ -351,25 +350,26 @@ export const calculateIndirectLighting = Fn( ( [
 
 		If( weights.useDiffuse, () => {
 
-			const diffusePdf = cosineWeightedPDF( NoL ).toVar();
-			combinedPdf.addAssign( weights.diffuseWeight.mul( diffusePdf ) );
+			combinedPdf.addAssign( weights.diffuseWeight.mul( cosineWeightedPDF( NoL ) ) );
 
 		} );
 
 		If( weights.useTransmission.and( material.transmission.greaterThan( 0.0 ) ), () => {
 
 			// Calculate transmission PDF for this direction
-			const entering = dot( V, N ).greaterThan( 0.0 ).toVar();
-			const transmissionPdf = calculateTransmissionPDF( V, sampleDir, N, material.ior, material.roughness, entering ).toVar();
-			combinedPdf.addAssign( weights.transmissionWeight.mul( transmissionPdf ) );
+			const entering = dot( V, N ).greaterThan( 0.0 );
+			combinedPdf.addAssign( weights.transmissionWeight.mul(
+				calculateTransmissionPDF( V, sampleDir, N, material.ior, material.roughness, entering )
+			) );
 
 		} );
 
 		If( weights.useClearcoat.and( material.clearcoat.greaterThan( 0.0 ) ), () => {
 
 			// Calculate clearcoat PDF for this direction
-			const clearcoatPdf = calculateClearcoatPDF( V, sampleDir, N, material.clearcoatRoughness ).toVar();
-			combinedPdf.addAssign( weights.clearcoatWeight.mul( clearcoatPdf ) );
+			combinedPdf.addAssign( weights.clearcoatWeight.mul(
+				calculateClearcoatPDF( V, sampleDir, N, material.clearcoatRoughness )
+			) );
 
 		} );
 
@@ -382,10 +382,9 @@ export const calculateIndirectLighting = Fn( ( [
 
 		// Throughput calculation: use |cos| for transmission, max(cos,0) for reflection strategies
 		const cosineWeight = select( selectedStrategy.equal( int( 3 ) ), absNoL, NoL );
-		const throughput = sampleBrdfValue.mul( cosineWeight ).mul( misWeight ).div( samplePdf ).toVar();
 
 		r_direction.assign( sampleDir );
-		r_throughput.assign( throughput );
+		r_throughput.assign( sampleBrdfValue.mul( cosineWeight ).mul( misWeight ).div( samplePdf ) );
 		r_misWeight.assign( misWeight );
 		r_pdf.assign( samplePdf );
 		r_combinedPdf.assign( combinedPdf );

package/src/TSL/LightsSampling.js

@@ -107,8 +107,7 @@ export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 		// Sample random position on rectangle (u/v are half-vectors, so map [0,1] → [-1,1])
 		const randomPos = 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();
+			.add( light.v.mul( ruv.y.mul( 2.0 ).sub( 1.0 ) ) );
 
 		const toLight = randomPos.sub( rayOrigin ).toVar();
 		const lightDistSq = dot( toLight, toLight ).toVar();
@@ -222,7 +221,7 @@ export const samplePointLightWithAttenuation = Fn( ( [ light, rayOrigin, lightSe
 	If( lightDistSq.greaterThanEqual( 1e-20 ), () => {
 
 		const lightDist = sqrt( lightDistSq ).toVar();
-		const lightDir = toLight.div( lightDist ).toVar();
+		const lightDir = toLight.div( lightDist );
 
 		// Calculate distance attenuation using the light's actual distance and decay properties
 		const distanceAttenuation = getDistanceAttenuation( { lightDistance: lightDist, cutoffDistance: light.distance, decayExponent: light.decay } );
@@ -400,7 +399,7 @@ export const sampleLightWithImportance = Fn( ( [
 
 		If( totalWeight.lessThanEqual( 0.0 ), () => {
 
-			const lightSelection = randomSeed.x.mul( float( totalLights ) ).toVar();
+			const lightSelection = randomSeed.x.mul( float( totalLights ) );
 			const selectedLight = int( lightSelection ).toVar();
 			// Guard division by zero
 			const lightSelectionPdf = float( 1.0 ).div( max( float( totalLights ), 1.0 ) ).toVar();
@@ -544,7 +543,7 @@ export const sampleLightWithImportance = Fn( ( [
 						w.mul( cosTheta ).add( u.mul( cos( phi ) ).add( v.mul( sin( phi ) ) ).mul( sinTheta ) )
 					) );
 					// Guard division: (1.0 - cosHalfAngle) could be zero if angle is 0
-					const solidAngle = float( TWO_PI ).mul( max( float( 1.0 ).sub( cosHalfAngle ), 1e-10 ) ).toVar();
+					const solidAngle = float( TWO_PI ).mul( max( float( 1.0 ).sub( cosHalfAngle ), 1e-10 ) );
 					dirPdf.assign( float( 1.0 ).div( solidAngle ) );
 
 				} );
@@ -626,9 +625,9 @@ export const sampleLightWithImportance = Fn( ( [
 // to avoid recomputing H + dots.
 export const calculateMaterialPDFFromDots = Fn( ( [ material, dots ] ) => {
 
-	const NoV = dots.NoV.toVar();
+	const NoV = dots.NoV;
 	const NoL = dots.NoL.toVar();
-	const NoH = dots.NoH.toVar();
+	const NoH = dots.NoH;
 
 	// Calculate lobe weights
 	const diffuseWeight = float( 1.0 ).sub( material.metalness ).mul(
@@ -660,7 +659,7 @@ export const calculateMaterialPDFFromDots = Fn( ( [ material, dots ] ) => {
 		// Specular PDF (VNDF sampling used in path tracer)
 		If( specularWeight.greaterThan( 0.0 ).and( NoL.greaterThan( 0.0 ) ), () => {
 
-			const roughness = max( material.roughness, 0.02 ).toVar();
+			const roughness = max( material.roughness, 0.02 );
 			pdf.addAssign( specularWeight.mul( calculateVNDFPDF( NoH, NoV, roughness ) ) );
 
 		} );
@@ -774,10 +773,10 @@ export const calculateDirectLightingUnified = Fn( ( [
 		const sampleBRDF = tslBool( false ).toVar();
 
 		// Calculate effective weights for probability (only include light weight if lights exist)
-		const effectiveLightWeight = select( hasDiscreteLights, lightWeight, float( 0.0 ) ).toVar();
+		const effectiveLightWeight = select( hasDiscreteLights, lightWeight, float( 0.0 ) );
 		// Guard division
-		const invTotalSamplingWeight = float( 1.0 ).div( max( totalSamplingWeight, 1e-10 ) ).toVar();
-		const cumulativeLight = effectiveLightWeight.mul( invTotalSamplingWeight ).toVar();
+		const invTotalSamplingWeight = float( 1.0 ).div( max( totalSamplingWeight, 1e-10 ) );
+		const cumulativeLight = effectiveLightWeight.mul( invTotalSamplingWeight );
 
 		If( rand.lessThan( cumulativeLight ).and( useLightSampling ).and( hasDiscreteLights ), () => {
 
@@ -813,11 +812,11 @@ export const calculateDirectLightingUnified = Fn( ( [
 			If( lightSample.valid.and( lightSample.pdf.greaterThan( 0.0 ) ), () => {
 
 				const NoL = max( float( 0.0 ), dot( hitNormal, lightSample.direction ) ).toVar();
-				const lightImportance = lightSample.emission.x.add( lightSample.emission.y ).add( lightSample.emission.z ).toVar();
+				const lightImportance = lightSample.emission.x.add( lightSample.emission.y ).add( lightSample.emission.z );
 
 				If( NoL.greaterThan( 0.0 ).and( lightImportance.mul( NoL ).greaterThan( importanceThreshold ) ).and( isDirectionValid( { direction: lightSample.direction, surfaceNormal: hitNormal } ) ), () => {
 
-					const shadowDistance = min( lightSample.distance.sub( 0.001 ), float( 1000.0 ) ).toVar();
+					const shadowDistance = min( lightSample.distance.sub( 0.001 ), float( 1000.0 ) );
 					const visibility = shadow( rayOrigin, lightSample.direction, shadowDistance );
 
 					If( visibility.greaterThan( 0.0 ), () => {
@@ -832,8 +831,8 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 						If( bPdf.greaterThan( 0.0 ).and( useBRDFSampling ), () => {
 
-							const lightPdfWeighted = lightSample.pdf.mul( lightWeight ).toVar();
-							const brdfPdfWeighted = bPdf.mul( brdfWeight ).toVar();
+							const lightPdfWeighted = lightSample.pdf.mul( lightWeight );
+							const brdfPdfWeighted = bPdf.mul( brdfWeight );
 
 							// Apply power heuristic only for area lights — the BRDF path can
 							// intersect area lights, so both strategies contribute and MIS is valid.
@@ -916,7 +915,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 							If( hitDistance.greaterThan( 0.0 ), () => {
 
-								const shadowDistance = min( hitDistance.sub( 0.001 ), float( 1000.0 ) ).toVar();
+								const shadowDistance = min( hitDistance.sub( 0.001 ), float( 1000.0 ) );
 								const visibility = shadow( rayOrigin, brdfSampleDirection, shadowDistance );
 
 								If( visibility.greaterThan( 0.0 ), () => {
@@ -925,16 +924,16 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 									If( lightFacing.greaterThan( 0.0 ), () => {
 
-										const lightDistSq = hitDistance.mul( hitDistance ).toVar();
+										const lightDistSq = hitDistance.mul( hitDistance );
 										// Guard division
 										const lightPdf = lightDistSq.div( max( light.area.mul( lightFacing ), EPSILON ) ).toVar();
 										lightPdf.divAssign( max( float( totalLights ), 1.0 ) );
 
-										const brdfPdfWeighted = brdfSamplePdf.mul( brdfWeight ).toVar();
-										const lightPdfWeighted = lightPdf.mul( lightWeight ).toVar();
+										const brdfPdfWeighted = brdfSamplePdf.mul( brdfWeight );
+										const lightPdfWeighted = lightPdf.mul( lightWeight );
 										const misW = powerHeuristic( { pdf1: brdfPdfWeighted, pdf2: lightPdfWeighted } ).toVar();
 
-										const lightEmission = light.color.mul( light.intensity ).toVar();
+										const lightEmission = light.color.mul( light.intensity );
 										// Guard division
 										const brdfContribution = lightEmission.mul( brdfSampleValue ).mul( NoL ).mul( visibility ).mul( misW ).div( max( brdfSamplePdf, 1e-10 ) );
 										totalContribution.addAssign( brdfContribution.mul( totalSamplingWeight ).div( max( brdfWeight, 1e-10 ) ) );

package/src/TSL/MaterialEvaluation.js

@@ -77,7 +77,7 @@ export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 		// Precalculate shared terms
 		const D = DistributionGGX( dots.NoH, material.roughness );
 		const G = GeometrySmith( dots.NoV, dots.NoL, material.roughness );
-		const F = fresnelSchlick( dots.VoH, F0 ).toVar();
+		const F = fresnelSchlick( dots.VoH, F0 );
 
 		// Single-scatter specular BRDF
 		const specularSS = D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) );
@@ -145,7 +145,7 @@ export const evaluateLayeredBRDF = Fn( ( [ dots, material ] ) => {
 
 	const D = DistributionGGX( dots.NoH, material.roughness );
 	const G = GeometrySmith( dots.NoV, dots.NoL, material.roughness );
-	const F = fresnelSchlick( dots.VoH, F0 ).toVar();
+	const F = fresnelSchlick( dots.VoH, F0 );
 	const baseBRDFSS = D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) );
 
 	// Shared DFG evaluation — compensation factor and total directional albedo

package/src/TSL/MaterialProperties.js

@@ -156,7 +156,7 @@ export const evalIridescence = Fn( ( [ outsideIOR, eta2, cosTheta1, thinFilmThic
 	const iridescenceIor = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) ).toVar();
 
 	// Evaluate the cosTheta on the base layer (Snell law)
-	const sinTheta2Sq = square( { x: outsideIOR.div( iridescenceIor ) } ).mul( float( 1.0 ).sub( square( { x: cosTheta1 } ) ) ).toVar();
+	const sinTheta2Sq = square( { x: outsideIOR.div( iridescenceIor ) } ).mul( float( 1.0 ).sub( square( { x: cosTheta1 } ) ) );
 
 	// Handle TIR
 	const cosTheta2Sq = float( 1.0 ).sub( sinTheta2Sq ).toVar();
@@ -171,11 +171,11 @@ export const evalIridescence = Fn( ( [ outsideIOR, eta2, cosTheta1, thinFilmThic
 		const cosTheta2 = sqrt( cosTheta2Sq ).toVar();
 
 		// First interface
-		const R0 = iorToFresnel0( iridescenceIor, outsideIOR ).toVar();
+		const R0 = iorToFresnel0( iridescenceIor, outsideIOR );
 		const R12 = fresnelSchlickFloat( cosTheta1, R0 ).toVar();
 		const T121 = float( 1.0 ).sub( R12 ).toVar();
-		const phi12 = iridescenceIor.lessThan( outsideIOR ).select( float( PI ), float( 0.0 ) ).toVar();
-		const phi21 = float( PI ).sub( phi12 ).toVar();
+		const phi12 = iridescenceIor.lessThan( outsideIOR ).select( float( PI ), float( 0.0 ) );
+		const phi21 = float( PI ).sub( phi12 );
 
 		// Second interface
 		const baseIOR = fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) ).toVar();
@@ -189,7 +189,7 @@ export const evalIridescence = Fn( ( [ outsideIOR, eta2, cosTheta1, thinFilmThic
 			baseIOR.x.lessThan( iridescenceIor ).select( float( PI ), float( 0.0 ) ),
 			baseIOR.y.lessThan( iridescenceIor ).select( float( PI ), float( 0.0 ) ),
 			baseIOR.z.lessThan( iridescenceIor ).select( float( PI ), float( 0.0 ) )
-		).toVar();
+		);
 
 		const OPD = float( 2.0 ).mul( iridescenceIor ).mul( thinFilmThickness ).mul( cosTheta2 ).toVar();
 		const phi = vec3( phi21 ).add( phi23 ).toVar();

package/src/TSL/MaterialTransmission.js

@@ -134,16 +134,16 @@ const wavelengthToXYZ = /*@__PURE__*/ Fn( ( [ wl ] ) => {
 export const sampleWavelengthForDispersion = Fn( ( [ baseIOR, dispersionStrength, random ] ) => {
 
 	const wl = mix( float( 380.0 ), float( 700.0 ), random ).toVar();
-	const sampledIOR = iorFromWavelength( baseIOR, dispersionStrength, wl ).toVar();
+	const sampledIOR = iorFromWavelength( baseIOR, dispersionStrength, wl );
 
 	const xyz = wavelengthToXYZ( wl ).toVar();
 	const rgb = vec3(
 		xyz.x.mul( 3.2406 ).sub( xyz.y.mul( 1.5372 ) ).sub( xyz.z.mul( 0.4986 ) ),
 		xyz.x.mul( - 0.9689 ).add( xyz.y.mul( 1.8758 ) ).add( xyz.z.mul( 0.0415 ) ),
 		xyz.x.mul( 0.0557 ).sub( xyz.y.mul( 0.2040 ) ).add( xyz.z.mul( 1.0570 ) ),
-	).toVar();
+	);
 
-	const colorWeight = max( rgb, vec3( 0.0 ) ).mul( vec3( 1.819, 2.773, 2.928 ) ).toVar();
+	const colorWeight = max( rgb, vec3( 0.0 ) ).mul( vec3( 1.819, 2.773, 2.928 ) );
 
 	return SpectralSample( {
 		wavelength: wl,
@@ -390,9 +390,7 @@ export const handleTransmission = Fn( ( [
 		const metallicReflect = float( 0.95 );
 
 		// Blend based on metalness
-		const baseReflectProb = mix( dielectricReflect, metallicReflect, material.metalness ).toVar();
-
-		reflectProb.assign( baseReflectProb );
+		reflectProb.assign( mix( dielectricReflect, metallicReflect, material.metalness ) );
 
 	} );
 

package/src/TSL/PathTracer.js

@@ -182,9 +182,10 @@ export const pathTracerMain = ( params ) => {
 
 	const baseSeed = getDecorrelatedSeed( { pixelCoord, rayIndex: int( 0 ), frame } ).toVar();
 
-	// MRT data
+	// MRT — linearDepth is ray distance (sky/miss = 1e6), the convention
+	// MotionVector + ASVGF expect downstream.
 	const worldNormal = vec3( 0.0, 0.0, 1.0 ).toVar();
-	const linearDepth = float( 1.0 ).toVar();
+	const linearDepth = float( 1e6 ).toVar();
 
 	// Accumulate per-sample alpha for transparent background (0.0 = env, 1.0 = geometry)
 	const pixelAlpha = float( 0.0 ).toVar();
@@ -321,10 +322,7 @@ export const pathTracerMain = ( params ) => {
 				If( traceResult.firstHitDistance.lessThan( 1e9 ), () => {
 
 					worldNormal.assign( normalize( traceResult.objectNormal ) );
-
-					linearDepth.assign( computeNDCDepth( {
-						worldPos: traceResult.firstHitPoint, cameraProjectionMatrix, cameraViewMatrix,
-					} ) );
+					linearDepth.assign( traceResult.firstHitDistance );
 
 				} );