rayzee 7.28.0 → 7.28.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.28.0",
+  "version": "7.28.1",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -10,7 +10,7 @@
  */
 export const RENDER_PROFILES = Object.freeze( {
 	viewer: Object.freeze( {
-		areaLightIntensityScale: 0.1, // authored RectAreaLight watts from glTF placeholders
+		areaLightIntensityScale: 0.1, // scales glTF placeholder area-light power (viewer tuning)
 		environmentRotation: 270.0, // degrees
 		toneMapping: 4, // ACESFilmicToneMapping
 		saturation: 1.2, // compensates for ACES desaturation — see Compositor

package/src/Processor/AssetLoader.js

@@ -1759,20 +1759,23 @@ export class AssetLoader extends EventDispatcher {
 
 				if ( userData.type === 'RectAreaLight' ) {
 
-					// Intensity is authored in Watts (Blender-style); emitted radiance
-					// is computed at render time as power/(π·area). Blender emission
-					// defaults: power-normalized, full Lambertian spread (π), rectangle.
-					// Viewer tuning, not physics — see RENDER_PROFILES.
+					// Authored intensity is three.js radiance (these files also carry power = intensity·w·h·π);
+					// convert to the engine's radiant power through the world area so Normalize reproduces it.
+					const worldScale = object.getWorldScale( new Vector3() );
+					const normalize = userData.normalize ?? true;
+					const shape = userData.shape ?? 'rectangle';
+					const shapeFactor = shape === 'ellipse' || shape === 'disk' ? Math.PI / 4 : 1;
+					const worldArea = shapeFactor * userData.width * worldScale.x * userData.height * worldScale.y;
+					const power = userData.intensity * Math.PI * ( normalize ? worldArea : 1 );
 					const light = new RectAreaLight(
 						new Color( ...userData.color ),
-						userData.intensity * this._profile.areaLightIntensityScale,
+						power * this._profile.areaLightIntensityScale,
 						userData.width,
 						userData.height
 					);
-					light.userData.normalize = userData.normalize ?? true;
+					light.userData.normalize = normalize;
 					light.userData.spread = Number.isFinite( userData.spread ) ? userData.spread : Math.PI;
-					light.userData.shape = userData.shape ?? 'rectangle';
-					light.position.z = - 2;
+					light.userData.shape = shape;
 					light.name = userData.name;
 					object.add( light );
 					visitedAreaLights.push( light.uuid );

package/src/TSL/EmissiveSampling.js

@@ -527,7 +527,7 @@ export const sampleEmissiveTriangle = Fn( ( [
 // products with the PDF call below.
 
 export const calculateEmissiveTriangleContributionDebug = Fn( ( [
-	hitPoint, normal, viewDir, material,
+	hitPoint, normal, geomNormal, viewDir, material,
 	bounceIndex, rngState,
 	pixelCoord, resolution, frame, dimBase,
 	emissiveBoost,
@@ -565,10 +565,10 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 		// Check geometric validity
 		const NoL = max( float( 0.0 ), dot( normal, emissiveSample.direction ) );
 
-		If( NoL.greaterThan( 0.0 ), () => {
+		If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, geomNormal ).greaterThan( 0.0 ) ), () => {
 
 			// Calculate ray offset for shadow ray
-			const rayOffset = calculateRayOffsetFn( hitPoint, normal, material );
+			const rayOffset = calculateRayOffsetFn( hitPoint, geomNormal, material );
 			const rayOrigin = hitPoint.add( rayOffset );
 
 			// Trace shadow ray
@@ -609,7 +609,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 
 // Wrapper that returns just the contribution vec3
 export const calculateEmissiveTriangleContribution = Fn( ( [
-	hitPoint, normal, viewDir, material,
+	hitPoint, normal, geomNormal, viewDir, material,
 	bounceIndex, rngState,
 	pixelCoord, resolution, frame, dimBase,
 	emissiveBoost,
@@ -620,7 +620,7 @@ export const calculateEmissiveTriangleContribution = Fn( ( [
 ] ) => {
 
 	const result = EmissiveContributionResult.wrap( calculateEmissiveTriangleContributionDebug(
-		hitPoint, normal, viewDir, material,
+		hitPoint, normal, geomNormal, viewDir, material,
 		bounceIndex, rngState,
 		pixelCoord, resolution, frame, dimBase,
 		emissiveBoost,

package/src/TSL/LightsDirect.js

@@ -341,8 +341,10 @@ export const estimateLightImportance = Fn( ( [ light, hitPoint, normal, material
 
 		If( lightFacing.greaterThan( 0.0 ), () => {
 
-			const solidAngle = light.area.div( max( distSq, 0.1 ) );
-			const power = light.intensity.mul( dot( light.color, REC709_LUMINANCE_COEFFICIENTS ) ).mul( light.area );
+			// Diffuse irradiance ∝ L·Ω·cosθ·cosθ′, Ω bounded by the hemisphere. Unit-free.
+			const solidAngle = min( light.area.div( max( distSq, 1e-12 ) ), float( 2.0 * Math.PI ) );
+			const invArea = select( light.normalize.greaterThan( 0.5 ), float( 1.0 ).div( max( light.area, 1e-10 ) ), float( 1.0 ) );
+			const radiance = light.intensity.mul( dot( light.color, REC709_LUMINANCE_COEFFICIENTS ) ).mul( invArea );
 
 			// Material-aware weighting
 			const materialFactor = float( 1.0 ).toVar();
@@ -358,20 +360,13 @@ export const estimateLightImportance = Fn( ( [ light, hitPoint, normal, material
 
 			} );
 
-			If( material.roughness.greaterThan( 0.6 ).and( material.metalness.lessThan( 0.3 ) ), () => {
-
-				const sizeBoost = min( light.area.mul( 2.0 ), float( 2.0 ) );
-				materialFactor.mulAssign( sizeBoost );
-
-			} );
-
 			If( material.transmission.greaterThan( 0.5 ), () => {
 
 				materialFactor.mulAssign( float( 1.0 ).add( material.transmission.mul( 0.3 ) ) );
 
 			} );
 
-			result.assign( power.mul( solidAngle ).mul( NoL ).mul( lightFacing ).mul( materialFactor ) );
+			result.assign( radiance.mul( solidAngle ).mul( NoL ).mul( lightFacing ).mul( materialFactor ) );
 
 		} );
 

package/src/TSL/LightsSampling.js

@@ -24,7 +24,6 @@ import {
 	int,
 	bool as tslBool,
 	max,
-	min,
 	abs,
 	sqrt,
 	cos,
@@ -33,6 +32,7 @@ import {
 	dot,
 	cross,
 	normalize,
+	length,
 	mix,
 	select,
 	If,
@@ -87,6 +87,9 @@ import {
 } from './Environment.js';
 
 const TWO_PI = 2.0 * PI;
+// Visibility rays stop this fraction short of the sampled light point: unit-free, and ≫ float
+// error, so an emitter coplanar with its fixture is never occluded by it.
+const SHADOW_END = 1.0 - 1e-4;
 
 // =============================================================================
 // Light Sampling Functions
@@ -768,7 +771,7 @@ export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material
 // Optimized direct lighting function with importance-based sampling and better MIS
 export const calculateDirectLightingUnified = Fn( ( [
 	// Surface hit data
-	hitPoint, hitNormal, material,
+	hitPoint, hitNormal, geomNormal, material,
 	// View direction
 	viewDir,
 	// BRDF sample (DirectionSample fields)
@@ -800,81 +803,80 @@ export const calculateDirectLightingUnified = Fn( ( [
 	const totalContribution = vec3( 0.0 ).toVar();
 	// Unoccluded reference (visibility forced to 1) — only filled when wantUnoccluded.
 	const unoccludedContribution = vec3( 0.0 ).toVar();
-	const rayOrigin = hitPoint.add( hitNormal.mul( 0.001 ) ).toVar();
+	const rayOrigin = hitPoint.add( geomNormal.mul( 0.001 ) ).toVar();
 
 	// Binds BVH params so shadow-ray sites at varying call depths use a 3-arg call
 	const shadow = Fn( ( [ origin, dir, maxDist ] ) =>
 		traceShadowRay( origin, dir, maxDist, traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer )
 	);
 
-	// Early exit for highly emissive surfaces
-	If( material.emissiveIntensity.lessThanEqual( 10.0 ), () => {
 
-		// NEE and BSDF-hit both run at every vertex, one sample each, so the MIS weights are the
-		// plain power heuristic over the raw densities. Picking one strategy stochastically and
-		// dividing by the selection probability was unbiased but cost 3× RMSE on an area light.
-		const totalLights = numDirectionalLights.add( numAreaLights ).add( numPointLights ).add( numSpotLights ).toVar();
-		const hasDiscreteLights = totalLights.greaterThan( int( 0 ) ).toVar();
+	// NEE and BSDF-hit both run at every vertex, one sample each, so the MIS weights are the
+	// plain power heuristic over the raw densities. Picking one strategy stochastically and
+	// dividing by the selection probability was unbiased but cost 3× RMSE on an area light.
+	const totalLights = numDirectionalLights.add( numAreaLights ).add( numPointLights ).add( numSpotLights ).toVar();
+	const hasDiscreteLights = totalLights.greaterThan( int( 0 ) ).toVar();
 
-		// Reservoir denominator from the NEE walk above; the BSDF-hit branch below reuses it
-		// rather than re-walking every light buffer to rebuild the same sum.
-		const neeTotalWeight = float( 0.0 ).toVar();
+	// Reservoir denominator from the NEE walk above; the BSDF-hit branch below reuses it
+	// rather than re-walking every light buffer to rebuild the same sum.
+	const neeTotalWeight = float( 0.0 ).toVar();
 
-		// =====================================================================
-		// LIGHT SAMPLING PATH
-		// =====================================================================
+	// =====================================================================
+	// LIGHT SAMPLING PATH
+	// =====================================================================
 
-		If( hasDiscreteLights, () => {
-
-			// Importance-weighted light sampling
-			const lightRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 2 ) ), rngState, resolution, frame ).toVar();
-			const lightSample = LightSample.wrap( sampleLightWithImportance(
-				rayOrigin, hitNormal, material, lightRandom, bounceIndex, rngState,
-				pixelCoord, resolution, frame, dimBase,
-				directionalLightsBuffer, numDirectionalLights,
-				areaLightsBuffer, numAreaLights,
-				pointLightsBuffer, numPointLights,
-				spotLightsBuffer, numSpotLights,
-			) );
+	If( hasDiscreteLights, () => {
 
-			neeTotalWeight.assign( lightSample.selectionTotalWeight );
+		// Importance-weighted light sampling
+		const lightRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 2 ) ), rngState, resolution, frame ).toVar();
+		const lightSample = LightSample.wrap( sampleLightWithImportance(
+			hitPoint, hitNormal, material, lightRandom, bounceIndex, rngState,
+			pixelCoord, resolution, frame, dimBase,
+			directionalLightsBuffer, numDirectionalLights,
+			areaLightsBuffer, numAreaLights,
+			pointLightsBuffer, numPointLights,
+			spotLightsBuffer, numSpotLights,
+		) );
 
-			If( lightSample.valid.and( lightSample.pdf.greaterThan( 0.0 ) ), () => {
+		neeTotalWeight.assign( lightSample.selectionTotalWeight );
 
-				const NoL = max( float( 0.0 ), dot( hitNormal, lightSample.direction ) ).toVar();
+		If( lightSample.valid.and( lightSample.pdf.greaterThan( 0.0 ) ), () => {
 
-				If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: lightSample.direction, surfaceNormal: hitNormal } ) ), () => {
+			const NoL = max( float( 0.0 ), dot( hitNormal, lightSample.direction ) ).toVar();
 
-					const shadowDistance = min( lightSample.distance.sub( 0.001 ), float( 1000.0 ) );
-					const visibility = shadow( rayOrigin, lightSample.direction, shadowDistance );
+			If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: lightSample.direction, surfaceNormal: geomNormal } ) ), () => {
 
-					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+				// Light geometry is measured from the hit point; only the visibility ray starts on the lifted
+				// origin, aimed at the sampled point and stopped a relative hair short of it.
+				const toSample = hitPoint.add( lightSample.direction.mul( lightSample.distance ) ).sub( rayOrigin ).toVar();
+				const shadowDistance = length( toSample ).toVar();
+				const visibility = shadow( rayOrigin, toSample.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
 
-						// Share H + dot products between BRDF eval and PDF — otherwise each
-						// would recompute normalize(V+L) + 5 dot products independently.
-						const sharedDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, lightSample.direction, material ) );
-						const brdfValue = evaluateMaterialResponseFromDots( material, sharedDots );
-						const bPdf = calculateMaterialPDFFromDots( material, sharedDots ).toVar();
+				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
-						// Power heuristic only for area lights — they are the only type the BRDF
-						// path can intersect, so elsewhere MIS would just delete energy.
-						const misW = float( 1.0 ).toVar();
+					// Share H + dot products between BRDF eval and PDF — otherwise each
+					// would recompute normalize(V+L) + 5 dot products independently.
+					const sharedDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, lightSample.direction, material ) );
+					const brdfValue = evaluateMaterialResponseFromDots( material, sharedDots );
+					const bPdf = calculateMaterialPDFFromDots( material, sharedDots ).toVar();
 
-						If( bPdf.greaterThan( 0.0 ).and( lightSample.lightType.equal( int( LIGHT_TYPE_AREA ) ) ), () => {
+					// Power heuristic only for area lights — they are the only type the BRDF
+					// path can intersect, so elsewhere MIS would just delete energy.
+					const misW = float( 1.0 ).toVar();
 
-							misW.assign( powerHeuristic( { pdf1: lightSample.pdf, pdf2: bPdf } ) );
+					If( bPdf.greaterThan( 0.0 ).and( lightSample.lightType.equal( int( LIGHT_TYPE_AREA ) ) ), () => {
 
-						} );
+						misW.assign( powerHeuristic( { pdf1: lightSample.pdf, pdf2: bPdf } ) );
 
-						// Base contribution WITHOUT visibility; shadowed = base × visibility (identical to the
-						// pre-dual-sum math), unoccluded = base × 1 (shadow-catcher reference only).
-						const baseContribution = lightSample.emission.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) );
-						totalContribution.addAssign( baseContribution.mul( visibility ) );
-						If( wantUnoccluded, () => {
+					} );
 
-							unoccludedContribution.addAssign( baseContribution );
+					// Base contribution WITHOUT visibility; shadowed = base × visibility (identical to the
+					// pre-dual-sum math), unoccluded = base × 1 (shadow-catcher reference only).
+					const baseContribution = lightSample.emission.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( lightSample.pdf, 1e-10 ) );
+					totalContribution.addAssign( baseContribution.mul( visibility ) );
+					If( wantUnoccluded, () => {
 
-						} );
+						unoccludedContribution.addAssign( baseContribution );
 
 					} );
 
@@ -884,88 +886,89 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 		} );
 
-		// =====================================================================
-		// BRDF SAMPLING PATH
-		// =====================================================================
+	} );
 
-		If( brdfSamplePdf.greaterThan( 0.0 ).and( numAreaLights.greaterThan( int( 0 ) ) ), () => {
+	// =====================================================================
+	// BRDF SAMPLING PATH
+	// =====================================================================
 
-			const NoL = max( float( 0.0 ), dot( hitNormal, brdfSampleDirection ) ).toVar();
+	If( brdfSamplePdf.greaterThan( 0.0 ).and( numAreaLights.greaterThan( int( 0 ) ) ), () => {
 
-			If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: brdfSampleDirection, surfaceNormal: hitNormal } ) ), () => {
+		const NoL = max( float( 0.0 ), dot( hitNormal, brdfSampleDirection ) ).toVar();
 
-				// Nearest hit — the ray stops at the first emitter, so a brighter one behind it is
-				// the wrong emitter and the wrong pdf. No importance gate: skipping a light drops
-				// energy the NEE partner's MIS weight already counted on, and estimateLightImportance
-				// reads zero across the terminator band of a large light (its CENTRE is below the
-				// horizon while half of it is still visible).
-				const nearestT = float( 1e30 ).toVar();
-				const nearestLight = int( - 1 ).toVar();
+		If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: brdfSampleDirection, surfaceNormal: geomNormal } ) ), () => {
 
-				Loop( { start: int( 0 ), end: numAreaLights, type: 'int', condition: '<' }, ( { i } ) => {
+			// Nearest hit — the ray stops at the first emitter, so a brighter one behind it is
+			// the wrong emitter and the wrong pdf. No importance gate: skipping a light drops
+			// energy the NEE partner's MIS weight already counted on, and estimateLightImportance
+			// reads zero across the terminator band of a large light (its CENTRE is below the
+			// horizon while half of it is still visible).
+			const nearestT = float( 1e30 ).toVar();
+			const nearestLight = int( - 1 ).toVar();
 
-					const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, i ) );
+			Loop( { start: int( 0 ), end: numAreaLights, type: 'int', condition: '<' }, ( { i } ) => {
 
-					If( light.intensity.greaterThan( 0.0 ), () => {
+				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, i ) );
 
-						const hitDistance = intersectAreaLight( light, rayOrigin, brdfSampleDirection ).toVar();
+				If( light.intensity.greaterThan( 0.0 ), () => {
 
-						If( hitDistance.greaterThan( 0.0 ).and( hitDistance.lessThan( nearestT ) ), () => {
+					const hitDistance = intersectAreaLight( light, hitPoint, brdfSampleDirection ).toVar();
 
-							nearestT.assign( hitDistance );
-							nearestLight.assign( i );
+					If( hitDistance.greaterThan( 0.0 ).and( hitDistance.lessThan( nearestT ) ), () => {
 
-						} );
+						nearestT.assign( hitDistance );
+						nearestLight.assign( i );
 
 					} );
 
 				} );
 
-				If( nearestLight.greaterThanEqual( int( 0 ) ), () => {
-
-					const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, nearestLight ) );
-					const shadowDistance = min( nearestT.sub( 0.001 ), float( 1000.0 ) );
-					const visibility = shadow( rayOrigin, brdfSampleDirection, shadowDistance );
+			} );
 
-					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+			If( nearestLight.greaterThanEqual( int( 0 ) ), () => {
 
-						const lightFacing = max( float( 0.0 ), dot( brdfSampleDirection, light.normal ).negate() ).toVar();
+				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, nearestLight ) );
+				const toLight = hitPoint.add( brdfSampleDirection.mul( nearestT ) ).sub( rayOrigin ).toVar();
+				const shadowDistance = length( toLight ).toVar();
+				const visibility = shadow( rayOrigin, toLight.div( shadowDistance ), shadowDistance.mul( SHADOW_END ) );
 
-						If( lightFacing.greaterThan( 0.0 ), () => {
+				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
-							// Directional pdf must match the NEE sampler: 1/S (spherical-rect) for
-							// rectangles, dist²/(area·cos) for disk/ellipse + degenerate rects.
-							const corner = light.position.sub( light.u ).sub( light.v );
-							const sAngle = sphQuadSolidAngle( rayOrigin, corner, light.u.mul( 2.0 ), light.v.mul( 2.0 ) ).toVar();
-							const areaPdf = nearestT.mul( nearestT ).div( max( light.area.mul( lightFacing ), EPSILON ) );
-							const dirPdf = select(
-								light.shape.lessThan( 0.5 ).and( sAngle.greaterThan( 1e-5 ) ),
-								float( 1.0 ).div( max( sAngle, 1e-10 ) ),
-								areaPdf,
-							).toVar();
+					const lightFacing = max( float( 0.0 ), dot( brdfSampleDirection, light.normal ).negate() ).toVar();
 
-							// The NEE partner's selection pdf, rebuilt from the reservoir denominator it
-							// already accumulated. Uniform 1/N only when total importance is zero, matching
-							// the reservoir's own fallback; 0 for a light NEE can never pick, which hands
-							// this strategy the full MIS weight — as it must.
-							const selImp = estimateLightImportance( light, rayOrigin, hitNormal, material );
-							const selPdf = select(
-								neeTotalWeight.greaterThan( 0.0 ),
-								selImp.div( max( neeTotalWeight, 1e-10 ) ),
-								float( 1.0 ).div( max( float( totalLights ), 1.0 ) ),
-							);
-							const lightPdf = dirPdf.mul( selPdf ).toVar();
-							const misW = powerHeuristic( { pdf1: brdfSamplePdf, pdf2: lightPdf } ).toVar();
+					If( lightFacing.greaterThan( 0.0 ), () => {
 
-							const lightEmission = areaLightRadiance( light ).mul( areaLightSpreadAttenuation( lightFacing, light.spread ) );
-							// Base contribution WITHOUT visibility (see discrete-light site).
-							const baseContribution = lightEmission.mul( brdfSampleValue ).mul( NoL ).mul( misW ).div( max( brdfSamplePdf, 1e-10 ) );
-							totalContribution.addAssign( baseContribution.mul( visibility ) );
-							If( wantUnoccluded, () => {
+						// Directional pdf must match the NEE sampler: 1/S (spherical-rect) for
+						// rectangles, dist²/(area·cos) for disk/ellipse + degenerate rects.
+						const corner = light.position.sub( light.u ).sub( light.v );
+						const sAngle = sphQuadSolidAngle( hitPoint, corner, light.u.mul( 2.0 ), light.v.mul( 2.0 ) ).toVar();
+						const areaPdf = nearestT.mul( nearestT ).div( max( light.area.mul( lightFacing ), EPSILON ) );
+						const dirPdf = select(
+							light.shape.lessThan( 0.5 ).and( sAngle.greaterThan( 1e-5 ) ),
+							float( 1.0 ).div( max( sAngle, 1e-10 ) ),
+							areaPdf,
+						).toVar();
 
-								unoccludedContribution.addAssign( baseContribution );
+						// The NEE partner's selection pdf, rebuilt from the reservoir denominator it
+						// already accumulated. Uniform 1/N only when total importance is zero, matching
+						// the reservoir's own fallback; 0 for a light NEE can never pick, which hands
+						// this strategy the full MIS weight — as it must.
+						const selImp = estimateLightImportance( light, hitPoint, hitNormal, material );
+						const selPdf = select(
+							neeTotalWeight.greaterThan( 0.0 ),
+							selImp.div( max( neeTotalWeight, 1e-10 ) ),
+							float( 1.0 ).div( max( float( totalLights ), 1.0 ) ),
+						);
+						const lightPdf = dirPdf.mul( selPdf ).toVar();
+						const misW = powerHeuristic( { pdf1: brdfSamplePdf, pdf2: lightPdf } ).toVar();
+
+						const lightEmission = areaLightRadiance( light ).mul( areaLightSpreadAttenuation( lightFacing, light.spread ) );
+						// Base contribution WITHOUT visibility (see discrete-light site).
+						const baseContribution = lightEmission.mul( brdfSampleValue ).mul( NoL ).mul( misW ).div( max( brdfSamplePdf, 1e-10 ) );
+						totalContribution.addAssign( baseContribution.mul( visibility ) );
+						If( wantUnoccluded, () => {
 
-							} );
+							unoccludedContribution.addAssign( baseContribution );
 
 						} );
 
@@ -976,58 +979,58 @@ export const calculateDirectLightingUnified = Fn( ( [
 			} );
 
 		} );
-		// =====================================================================
-		// DETERMINISTIC ENVIRONMENT NEE
-		// Always runs (not stochastic) — forms a two-strategy Veach MIS
-		// estimator together with the implicit miss check in the main loop.
-		// =====================================================================
 
-		If( enableEnvironmentLight, () => {
+	} );
+	// =====================================================================
+	// DETERMINISTIC ENVIRONMENT NEE
+	// Always runs (not stochastic) — forms a two-strategy Veach MIS
+	// estimator together with the implicit miss check in the main loop.
+	// =====================================================================
 
-			const envRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ).toVar();
-			const envColor = vec3( 0.0 ).toVar();
+	If( enableEnvironmentLight, () => {
 
-			// Sample direction + PDF + color from importance-sampled environment
-			const envSampleResult = sampleEquirectProbability(
-				envTexture, envCDFTexture,
-				envMatrix, environmentIntensity, envTotalSum, envCompensationDelta, envResolution, envRandom, envColor
-			).toVar();
+		const envRandom = getRandomSample2D( pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ).toVar();
+		const envColor = vec3( 0.0 ).toVar();
 
-			const envDirection = envSampleResult.xyz.toVar();
-			const envPdf = envSampleResult.w.toVar();
+		// Sample direction + PDF + color from importance-sampled environment
+		const envSampleResult = sampleEquirectProbability(
+			envTexture, envCDFTexture,
+			envMatrix, environmentIntensity, envTotalSum, envCompensationDelta, envResolution, envRandom, envColor
+		).toVar();
 
-			If( envPdf.greaterThan( 0.0 ), () => {
+		const envDirection = envSampleResult.xyz.toVar();
+		const envPdf = envSampleResult.w.toVar();
 
-				const NoL = max( float( 0.0 ), dot( hitNormal, envDirection ) ).toVar();
+		If( envPdf.greaterThan( 0.0 ), () => {
 
-				If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: envDirection, surfaceNormal: hitNormal } ) ), () => {
+			const NoL = max( float( 0.0 ), dot( hitNormal, envDirection ) ).toVar();
 
-					const visibility = shadow( rayOrigin, envDirection, float( 1000.0 ) );
+			If( NoL.greaterThan( 0.0 ).and( isDirectionValid( { direction: envDirection, surfaceNormal: geomNormal } ) ), () => {
 
-					If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
+				const visibility = shadow( rayOrigin, envDirection, float( 1e20 ) );
 
-						// Share H + dots between env BRDF/PDF — same redundancy fix as the
-						// discrete-light path above.
-						const envDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, envDirection, material ) );
-						const brdfValue = evaluateMaterialResponseFromDots( material, envDots );
-						const bPdf = calculateMaterialPDFFromDots( material, envDots ).toVar();
+				If( visibility.greaterThan( 0.0 ).or( wantUnoccluded ), () => {
 
-						// Balance heuristic for env MIS — optimal for MIS-compensated PDFs (Karlík et al. 2019).
-						// The implicit path uses material combinedPdf as prevBouncePdf at the miss check.
-						const misW = select(
-							bPdf.greaterThan( 0.0 ),
-							balanceHeuristic( { pdf1: envPdf, pdf2: bPdf } ),
-							float( 1.0 )
-						).toVar();
+					// Share H + dots between env BRDF/PDF — same redundancy fix as the
+					// discrete-light path above.
+					const envDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, envDirection, material ) );
+					const brdfValue = evaluateMaterialResponseFromDots( material, envDots );
+					const bPdf = calculateMaterialPDFFromDots( material, envDots ).toVar();
 
-						// Base contribution WITHOUT visibility (deterministic estimator; no stochastic scaling).
-						const baseContribution = envColor.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( envPdf, 1e-10 ) );
-						totalContribution.addAssign( baseContribution.mul( visibility ) );
-						If( wantUnoccluded, () => {
+					// Balance heuristic for env MIS — optimal for MIS-compensated PDFs (Karlík et al. 2019).
+					// The implicit path uses material combinedPdf as prevBouncePdf at the miss check.
+					const misW = select(
+						bPdf.greaterThan( 0.0 ),
+						balanceHeuristic( { pdf1: envPdf, pdf2: bPdf } ),
+						float( 1.0 )
+					).toVar();
 
-							unoccludedContribution.addAssign( baseContribution );
+					// Base contribution WITHOUT visibility (deterministic estimator; no stochastic scaling).
+					const baseContribution = envColor.mul( brdfValue ).mul( NoL ).mul( misW ).div( max( envPdf, 1e-10 ) );
+					totalContribution.addAssign( baseContribution.mul( visibility ) );
+					If( wantUnoccluded, () => {
 
-						} );
+						unoccludedContribution.addAssign( baseContribution );
 
 					} );
 
@@ -1037,7 +1040,8 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 		} );
 
-	} ); // End emissiveIntensity check
+	} );
+
 
 	// EMISSIVE TRIANGLE DIRECT LIGHTING
 	// NOTE: Emissive triangle sampling is handled separately in pathtracer_core.fs

package/src/TSL/ShadeKernel.js

@@ -255,7 +255,7 @@ export function buildShadeKernel( params ) {
 					// Reuse the full NEE estimator; the diffuse BRDF is constant and cancels in the
 					// ratio, so this yields an irradiance-weighted shadow density across all lights + env.
 					const dual = DirectLightingDual.wrap( calculateDirectLightingUnified(
-						planePoint, planeN, planeMat, planeV,
+						planePoint, planeN, planeN, planeMat, planeV,
 						bDir, bPdf, bVal,
 						bounceIndex, rngState,
 						_pixelCoord, resolution, frame, dimBase,
@@ -1044,16 +1044,24 @@ export function buildShadeKernel( params ) {
 
 		// BRDF sample (needed by both direct + indirect)
 		const V = direction.negate().toVar();
+		// face-forwarded geometric normal: horizon guard for NEE and the bounce continuation
+		const Ngeo = normalize( hitNormal );
+		const NgeoFF = select( dot( Ngeo, V ).lessThan( 0.0 ), Ngeo.negate(), Ngeo ).toVar();
 
-		// Two-sided shading: opaque path only (transmissive/SSS already continued), so this never disturbs
-		// dielectric enter/exit. Flip N toward the viewer when back-facing — rescues double-sided / inward-
-		// normal imported meshes (GLB/PBRT) that otherwise shade black (NoL collapses). Megakernel: PathTracerCore.js:1054.
-		If( dot( N, V ).lessThan( 0.0 ), () => {
+		// Two-sided shading: opaque path only (transmissive/SSS already continued). Decide the flip on the
+		// GEOMETRIC normal — an inward-normal / double-sided mesh (GLB/PBRT) faces away as a whole — so a
+		// normal-map overshoot is not mistaken for a back face and folded into the surface.
+		If( dot( Ngeo, V ).lessThan( 0.0 ), () => {
 
 			N.assign( N.negate() );
 
 		} );
 
+		// A normal-mapped N may still face away from the viewer at grazing angles. Like Cycles' diffuse
+		// closure it is used as is: NEE and the bounce continuation already reject directions below the
+		// geometric horizon. (Cycles raises N for glossy closures only — ensure_valid_specular_reflection;
+		// with one shared N that would lift the diffuse term on every away-facing flank, measured +17.6 %.)
+
 		// ─── DDFA opaque aux decision: commit at the first diffuse-enough surface, defer through smooth
 		// mirror/metal so the guide describes what the mirror reflects, not the mirror itself. N is already
 		// viewer-facing (two-sided flip above); depth read back + re-packed (idempotent snorm — no drift). ───
@@ -1139,7 +1147,7 @@ export function buildShadeKernel( params ) {
 		} );
 
 		const directLight = DirectLightingDual.wrap( calculateDirectLightingUnified(
-			hitPoint, N, material, V,
+			hitPoint, N, NgeoFF, material, V,
 			brdfDir, brdfPdf, brdfValue,
 			bounceIndex, rngState,
 			_pixelCoord, resolution, frame, dimBase,
@@ -1205,9 +1213,9 @@ export function buildShadeKernel( params ) {
 
 							const NoL = max( float( 0.0 ), dot( N, emissiveSample.direction ) );
 
-							If( NoL.greaterThan( 0.0 ), () => {
+							If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, NgeoFF ).greaterThan( 0.0 ) ), () => {
 
-								const rayOffset = calculateRayOffset( hitPoint, N, material );
+								const rayOffset = calculateRayOffset( hitPoint, NgeoFF, material );
 								const rayOrigin = hitPoint.add( rayOffset );
 								const shadowDist = emissiveSample.distance.sub( 0.001 );
 								const visibility = traceShadowRayWrapped(
@@ -1248,7 +1256,7 @@ export function buildShadeKernel( params ) {
 					} ).Else( () => {
 
 						const emissiveLight = calculateEmissiveTriangleContribution(
-							hitPoint, N, V, material,
+							hitPoint, N, NgeoFF, V, material,
 							bounceIndex, rngState,
 							_pixelCoord, resolution, frame, dimBase,
 							emissiveBoost,
@@ -1291,7 +1299,6 @@ export function buildShadeKernel( params ) {
 
 		// Shading-normal leak guard: a normal-mapped lobe can sample below the geometric surface;
 		// tracing that ray tunnels through single-sided shells onto whatever sits behind them.
-		const NgeoFF = select( dot( hitNormal, V ).lessThan( 0.0 ), hitNormal.negate(), hitNormal );
 		If( brdfIsTransmission.not().and( dot( bounceDir, NgeoFF ).lessThanEqual( 0.0 ) ), () => {
 
 			commitDeferredAux( N );