rayzee 7.1.0 → 7.2.1

package/src/Stages/BilateralFilter.js

@@ -1,4 +1,4 @@
-import { Fn, wgslFn, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If, max, sqrt,
+import { Fn, wgslFn, vec3, vec4, float, int, uint, ivec2, uvec2, uniform, If, max, mix, sqrt,
 	textureLoad, textureStore, localId, workgroupId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, RGBAFormat, LinearFilter, Box2, Vector2 } from 'three';
@@ -59,6 +59,9 @@ export class BilateralFilter extends RenderStage {
 		this.renderer = renderer;
 		this.inputTextureName = options.inputTextureName || 'asvgf:demodulated';
 		this.normalDepthTextureName = options.normalDepthTextureName || 'pathtracer:normalDepth';
+		// Mapped (normal/bump-perturbed) normal for the normal edge-stop — geometric
+		// normals are flat across a normal-mapped surface so normW can't preserve bump detail.
+		this.shadingNormalTextureName = options.shadingNormalTextureName || 'pathtracer:shadingNormal';
 		this.albedoTextureName = options.albedoTextureName || 'pathtracer:albedo';
 		this.varianceTextureName = options.varianceTextureName || 'variance:output';
 		this.iterations = options.iterations ?? 4;
@@ -69,6 +72,10 @@ export class BilateralFilter extends RenderStage {
 		this.phiNormal = uniform( options.phiNormal ?? 128.0 );
 		this.phiDepth = uniform( options.phiDepth ?? 0.05 );
 		this.phiLuminance = uniform( options.phiLuminance ?? 4.0 );
+		// Blend Variance's spatial-variance channel into sigma_l (1 = max(temporal, spatial),
+		// 0 = temporal-only). Widens the luminance gate where history is thin but the
+		// neighbourhood is noisy (disocclusion). Default on — validated −1.7% RMSE @4spp.
+		this.spatialVarianceWeight = uniform( options.spatialVarianceWeight ?? 1.0 );
 		this.stepSizeU = uniform( 1, 'int' );
 		// 1 on the final iteration → multiply by albedo to remodulate.
 		this.isLastIterationU = uniform( 0, 'int' );
@@ -77,6 +84,7 @@ export class BilateralFilter extends RenderStage {
 
 		this._readTexNode = new TextureNode();
 		this._normalDepthTexNode = new TextureNode();
+		this._shadingNormalTexNode = new TextureNode();
 		this._albedoTexNode = new TextureNode();
 		this._varianceTexNode = new TextureNode();
 
@@ -133,12 +141,14 @@ export class BilateralFilter extends RenderStage {
 
 		const readTexNode = this._readTexNode;
 		const ndTexNode = this._normalDepthTexNode;
+		const snTexNode = this._shadingNormalTexNode;
 		const albedoTexNode = this._albedoTexNode;
 		const varTexNode = this._varianceTexNode;
 		const phiColor = this.phiColor;
 		const phiNormal = this.phiNormal;
 		const phiDepth = this.phiDepth;
 		const phiLuminance = this.phiLuminance;
+		const spatialVarianceWeight = this.spatialVarianceWeight;
 		const stepSize = this.stepSizeU;
 		const isLastIterationU = this.isLastIterationU;
 		const resW = this.resW;
@@ -165,7 +175,8 @@ export class BilateralFilter extends RenderStage {
 				const coord = ivec2( gx, gy );
 				const centerColor = textureLoad( readTexNode, coord ).xyz;
 				const centerND = textureLoad( ndTexNode, coord );
-				const centerNormal = centerND.xyz.mul( 2.0 ).sub( 1.0 );
+				// Normal edge-stop reads the mapped (shading) normal; depth gate stays geometric.
+				const centerNormal = textureLoad( snTexNode, coord ).xyz.mul( 2.0 ).sub( 1.0 );
 				const centerDepth = centerND.w;
 				const centerLum = luminance( centerColor );
 				const centerSafeAlbedo = max( textureLoad( albedoTexNode, coord ).xyz, vec3( ALBEDO_EPS ) );
@@ -176,7 +187,10 @@ export class BilateralFilter extends RenderStage {
 				// from demodulation — otherwise dark materials get an
 				// under-estimated sigma → over-strict luminance gate → no
 				// blending → silhouette dark-outline artifact.
-				const variance = textureLoad( varTexNode, coord ).z;
+				// .z = temporal variance, .w = spatial (3×3) variance. Blend toward
+				// max(temporal, spatial) so disoccluded/low-history pixels widen sigma_l.
+				const vSample = textureLoad( varTexNode, coord );
+				const variance = mix( vSample.z, max( vSample.z, vSample.w ), spatialVarianceWeight );
 				const sigmaL = phiLuminance
 					.mul( sqrt( max( variance, float( 0.0 ) ) ) )
 					.div( centerAlbedoLum )
@@ -201,7 +215,7 @@ export class BilateralFilter extends RenderStage {
 
 						const sColor = textureLoad( readTexNode, ivec2( sx, sy ) ).xyz;
 						const sND = textureLoad( ndTexNode, ivec2( sx, sy ) );
-						const sNormal = sND.xyz.mul( 2.0 ).sub( 1.0 );
+						const sNormal = textureLoad( snTexNode, ivec2( sx, sy ) ).xyz.mul( 2.0 ).sub( 1.0 );
 						const sDepth = sND.w;
 						const sLum = luminance( sColor );
 
@@ -253,6 +267,8 @@ export class BilateralFilter extends RenderStage {
 			|| context.getTexture( 'asvgf:output' )
 			|| context.getTexture( 'pathtracer:color' );
 		const ndTex = context.getTexture( this.normalDepthTextureName );
+		// Fall back to geometric normalDepth if the mapped normal isn't published.
+		const snTex = context.getTexture( this.shadingNormalTextureName ) || ndTex;
 		const albedoTex = context.getTexture( this.albedoTextureName );
 		const varTex = context.getTexture( this.varianceTextureName );
 
@@ -273,6 +289,7 @@ export class BilateralFilter extends RenderStage {
 
 		// RenderTarget textures — safe to bind before first-compile.
 		if ( ndTex ) this._normalDepthTexNode.value = ndTex;
+		if ( snTex ) this._shadingNormalTexNode.value = snTex;
 		if ( albedoTex ) this._albedoTexNode.value = albedoTex;
 
 		// First-frame compile while StorageTexture-typed nodes still hold
@@ -329,6 +346,7 @@ export class BilateralFilter extends RenderStage {
 		if ( params.phiNormal !== undefined ) this.phiNormal.value = params.phiNormal;
 		if ( params.phiDepth !== undefined ) this.phiDepth.value = params.phiDepth;
 		if ( params.phiLuminance !== undefined ) this.phiLuminance.value = params.phiLuminance;
+		if ( params.spatialVarianceWeight !== undefined ) this.spatialVarianceWeight.value = params.spatialVarianceWeight;
 		if ( params.atrousIterations !== undefined ) this.iterations = params.atrousIterations;
 
 	}
@@ -364,6 +382,7 @@ export class BilateralFilter extends RenderStage {
 		this._outputTarget?.dispose();
 		this._readTexNode?.dispose();
 		this._normalDepthTexNode?.dispose();
+		this._shadingNormalTexNode?.dispose();
 		this._albedoTexNode?.dispose();
 		this._varianceTexNode?.dispose();
 

package/src/Stages/NormalDepth.js

@@ -1,11 +1,13 @@
 import { Fn, vec3, vec4, float, int, uint, uvec2, uniform, normalize, mat3, storage, If,
-	textureStore, workgroupId, localId } from 'three/tsl';
+	texture, textureStore, workgroupId, localId } from 'three/tsl';
 import { RenderTarget, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, Matrix4, Box2, Vector2 } from 'three';
+import { HalfFloatType, RGBAFormat, NearestFilter, LinearFilter, DataArrayTexture, Matrix4, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
-import { Ray, HitInfo } from '../TSL/Struct.js';
+import { Ray, HitInfo, RayTracingMaterial, UVCache } from '../TSL/Struct.js';
 import { traverseBVH } from '../TSL/BVHTraversal.js';
+import { getMaterial } from '../TSL/Common.js';
+import { computeUVCache, processNormal, processBump } from '../TSL/TextureSampling.js';
 
 /**
  * NormalDepth — primary-ray G-buffer for SVGF gates.
@@ -21,7 +23,13 @@ import { traverseBVH } from '../TSL/BVHTraversal.js';
  * aliases current — without that aliasing prev would point at older data
  * while this frame's motion vector reflects zero motion → false rejection.
  *
- * Publishes: pathtracer:normalDepth, pathtracer:prevNormalDepth
+ * Also emits a SHADING normal (geometric normal perturbed by the normal/bump
+ * map, recomputed from the SAME deterministic hit — no extra ray) so the
+ * spatial denoiser's edge-stop can see normal-map detail the flat geometric
+ * normal hides. Deterministic ⇒ jitter-free, so it's safe for the gates.
+ *
+ * Publishes: pathtracer:normalDepth, pathtracer:prevNormalDepth,
+ *            pathtracer:shadingNormal
  */
 export class NormalDepth extends RenderStage {
 
@@ -52,6 +60,22 @@ export class NormalDepth extends RenderStage {
 		this._outputStorageTex.minFilter = NearestFilter;
 		this._outputStorageTex.magFilter = NearestFilter;
 
+		// Shading-normal output (geometric normal perturbed by normal/bump map).
+		// Single buffer — only the spatial filter (current frame) consumes it.
+		this._shadingStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+		this._shadingStorageTex.type = HalfFloatType;
+		this._shadingStorageTex.format = RGBAFormat;
+		this._shadingStorageTex.minFilter = NearestFilter;
+		this._shadingStorageTex.magFilter = NearestFilter;
+		this._shadingRT = new RenderTarget( w, h, {
+			type: HalfFloatType,
+			format: RGBAFormat,
+			minFilter: NearestFilter,
+			magFilter: NearestFilter,
+			depthBuffer: false,
+			stencilBuffer: false
+		} );
+
 		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
 
 		// Ping-pong RTs share format with the StorageTexture so copyTextureToTexture works.
@@ -73,11 +97,30 @@ export class NormalDepth extends RenderStage {
 
 		this._triStorageNode = null;
 		this._bvhStorageNode = null;
+		this._matStorageNode = null;
 		this._lastTriAttr = null;
 		this._lastBvhAttr = null;
+		this._lastMatAttr = null;
 		this._computeNode = null;
 		this._computeBuilt = false;
 
+		// Normal/bump map array nodes — persistent placeholders, value swapped to
+		// the real DataArrayTextures on model load. processNormal/processBump
+		// runtime-guard on map indices, so the placeholder is never sampled.
+		this._normalMapsTex = texture( this._makePlaceholderArray() );
+		this._bumpMapsTex = texture( this._makePlaceholderArray() );
+
+	}
+
+	_makePlaceholderArray() {
+
+		const t = new DataArrayTexture( new Uint8Array( [ 128, 128, 255, 255 ] ), 1, 1, 1 );
+		t.minFilter = LinearFilter;
+		t.magFilter = LinearFilter;
+		t.generateMipmaps = false;
+		t.needsUpdate = true;
+		return t;
+
 	}
 
 	setupEventListeners() {
@@ -102,10 +145,12 @@ export class NormalDepth extends RenderStage {
 		const pt = this.pathTracer;
 		if ( ! pt ) return false;
 
+		const matAttr = pt.materialData?.materialStorageAttr;
 		const triSwapped = pt.triangleStorageAttr && pt.triangleStorageAttr !== this._lastTriAttr;
 		const bvhSwapped = pt.bvhStorageAttr && pt.bvhStorageAttr !== this._lastBvhAttr;
+		const matSwapped = matAttr && matAttr !== this._lastMatAttr;
 
-		if ( triSwapped || bvhSwapped ) {
+		if ( triSwapped || bvhSwapped || matSwapped ) {
 
 			// Buffer identity changed → compute's bind group is stale; rebuild.
 			this._computeNode?.dispose?.();
@@ -113,6 +158,7 @@ export class NormalDepth extends RenderStage {
 			this._computeBuilt = false;
 			this._triStorageNode = null;
 			this._bvhStorageNode = null;
+			this._matStorageNode = null;
 			this._dirty = true;
 
 		}
@@ -133,10 +179,22 @@ export class NormalDepth extends RenderStage {
 
 		}
 
+		if ( matAttr && ! this._matStorageNode ) {
+
+			this._matStorageNode = storage( matAttr, 'vec4', matAttr.count ).toReadOnly();
+
+		}
+
+		// In-place map swaps (model change) — graph closes over the node, only .value changes.
+		const md = pt.materialData;
+		if ( md?.normalMaps ) this._normalMapsTex.value = md.normalMaps;
+		if ( md?.bumpMaps ) this._bumpMapsTex.value = md.bumpMaps;
+
 		this._lastTriAttr = pt.triangleStorageAttr || this._lastTriAttr;
 		this._lastBvhAttr = pt.bvhStorageAttr || this._lastBvhAttr;
+		this._lastMatAttr = matAttr || this._lastMatAttr;
 
-		return !! ( this._triStorageNode && this._bvhStorageNode );
+		return !! ( this._triStorageNode && this._bvhStorageNode && this._matStorageNode );
 
 	}
 
@@ -144,11 +202,15 @@ export class NormalDepth extends RenderStage {
 
 		const triStorage = this._triStorageNode;
 		const bvhStorage = this._bvhStorageNode;
+		const matStorage = this._matStorageNode;
+		const normalMaps = this._normalMapsTex;
+		const bumpMaps = this._bumpMapsTex;
 		const camWorld = this.cameraWorldMatrix;
 		const camProjInv = this.cameraProjectionMatrixInverse;
 		const resW = this.resolutionWidth;
 		const resH = this.resolutionHeight;
 		const outputTex = this._outputStorageTex;
+		const shadingTex = this._shadingStorageTex;
 
 		const WG_SIZE = 8;
 
@@ -195,6 +257,31 @@ export class NormalDepth extends RenderStage {
 					result
 				).toWriteOnly();
 
+				// Shading normal: perturb the geometric normal by the normal/bump map
+				// from the SAME hit (deterministic UV → jitter-free). Miss → geo default.
+				const shadingNormal = hit.normal.toVar();
+				If( hit.didHit, () => {
+
+					const material = RayTracingMaterial.wrap(
+						getMaterial( hit.materialIndex, matStorage )
+					).toVar();
+					const uvCache = UVCache.wrap( computeUVCache( hit.uv, material ) ).toVar();
+					const mapped = processNormal( normalMaps, hit.normal, material, uvCache ).toVar();
+					shadingNormal.assign( processBump( bumpMaps, mapped, material, uvCache ) );
+
+				} );
+
+				const shadingResult = hit.didHit.select(
+					vec4( shadingNormal.mul( 0.5 ).add( 0.5 ), depth ),
+					vec4( 0.0, 0.0, 0.0, float( 1e6 ) )
+				);
+
+				textureStore(
+					shadingTex,
+					uvec2( uint( gx ), uint( gy ) ),
+					shadingResult
+				).toWriteOnly();
+
 			} );
 
 		} );
@@ -233,6 +320,7 @@ export class NormalDepth extends RenderStage {
 			const currentRT = this._currentIdx === 0 ? this._rtA : this._rtB;
 			context.setTexture( 'pathtracer:normalDepth', currentRT.texture );
 			context.setTexture( 'pathtracer:prevNormalDepth', currentRT.texture );
+			context.setTexture( 'pathtracer:shadingNormal', this._shadingRT.texture );
 			return;
 
 		}
@@ -257,9 +345,10 @@ export class NormalDepth extends RenderStage {
 
 		this.renderer.compute( this._computeNode );
 
-		// Copy only the active region out of the over-allocated StorageTexture.
+		// Copy only the active region out of the over-allocated StorageTextures.
 		this._srcRegion.max.set( writeRT.width, writeRT.height );
 		this.renderer.copyTextureToTexture( this._outputStorageTex, writeRT.texture, this._srcRegion );
+		this.renderer.copyTextureToTexture( this._shadingStorageTex, this._shadingRT.texture, this._srcRegion );
 
 		// First dispatch: seed prev from current so ASVGF doesn't see false
 		// disocclusion on frame 1.
@@ -272,6 +361,7 @@ export class NormalDepth extends RenderStage {
 
 		context.setTexture( 'pathtracer:normalDepth', writeRT.texture );
 		context.setTexture( 'pathtracer:prevNormalDepth', prevRT.texture );
+		context.setTexture( 'pathtracer:shadingNormal', this._shadingRT.texture );
 
 		this._dirty = false;
 
@@ -294,6 +384,8 @@ export class NormalDepth extends RenderStage {
 		this._rtA.texture.needsUpdate = true;
 		this._rtB.setSize( width, height );
 		this._rtB.texture.needsUpdate = true;
+		this._shadingRT.setSize( width, height );
+		this._shadingRT.texture.needsUpdate = true;
 		this._hasHistory = false;
 		this.resolutionWidth.value = width;
 		this.resolutionHeight.value = height;
@@ -314,6 +406,8 @@ export class NormalDepth extends RenderStage {
 
 		this._computeNode?.dispose();
 		this._outputStorageTex?.dispose();
+		this._shadingStorageTex?.dispose();
+		this._shadingRT?.dispose();
 		this._rtA?.dispose();
 		this._rtB?.dispose();
 

package/src/Stages/PathTracer.js

@@ -754,6 +754,7 @@ export class PathTracer extends PathTracerStage {
 			totalTriangleCount: this.totalTriangleCount,
 			enableEmissiveTriangleSampling: this.enableEmissiveTriangleSampling,
 			lightBVHNodeCount: this.lightBVHNodeCount,
+			reverseMapVec4Offset: this.reverseMapVec4Offset,
 			currentBounce: this._wfCurrentBounce,
 			maxRayCount: this._wfMaxRayCount,
 		} );

package/src/Stages/PathTracerStage.js

@@ -198,9 +198,12 @@ export class PathTracerStage extends RenderStage {
 		this.lightStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 16 ), 4 );
 		this.lightStorageNode = storage( this.lightStorageAttr, 'vec4', 1 ).toReadOnly();
 
-		// Cached CPU-side data — rebuilt into the packed buffer whenever either source changes.
+		// Cached CPU-side data — rebuilt into the packed buffer whenever any source changes.
 		this._lbvhDataCache = null;
 		this._emissiveDataCache = null;
+		// Per-triangle bit-trail map (root→leaf Light BVH path, 1 float per triangleIndex); packed
+		// after the emissive entries so the bounce-hit MIS path can re-walk the descent pdf.
+		this._bitTrailMapCache = null;
 
 		// Per-mesh visibility is packed into the TLAS BLAS-pointer leaf's slot [2]
 		// (see TLASBuilder.flatten + BVHTraversal.js). The InstanceTable holds the
@@ -1296,14 +1299,18 @@ export class PathTracerStage extends RenderStage {
 		const LBVH_STRIDE = 4; // vec4s per LBVH node — must match LightBVHSampling.js
 		const lbvh = this._lbvhDataCache;
 		const emis = this._emissiveDataCache;
+		const trail = this._bitTrailMapCache;
 		const lbvhLen = lbvh ? lbvh.length : 0;
 		const emisLen = emis ? emis.length : 0;
+		// Bit-trail map packs 4 trails per vec4 → pad to a vec4 boundary.
+		const trailPadded = trail ? Math.ceil( trail.length / 4 ) * 4 : 0;
 
 		// Ensure at least a minimal non-empty buffer so GPU allocation remains valid.
-		const totalLen = Math.max( lbvhLen + emisLen, 4 );
+		const totalLen = Math.max( lbvhLen + emisLen + trailPadded, 4 );
 		const combined = new Float32Array( totalLen );
 		if ( lbvh ) combined.set( lbvh, 0 );
 		if ( emis ) combined.set( emis, lbvhLen );
+		if ( trail ) combined.set( trail, lbvhLen + emisLen );
 
 		this.lightStorageAttr = new StorageInstancedBufferAttribute( combined, 4 );
 		this.lightStorageNode.value = this.lightStorageAttr;
@@ -1311,14 +1318,18 @@ export class PathTracerStage extends RenderStage {
 
 		// Offset (in vec4 elements) where emissive data starts.
 		this.emissiveVec4Offset.value = ( this.lightBVHNodeCount.value || 0 ) * LBVH_STRIDE;
+		// Offset (in vec4 elements) where the bit-trail map starts (lbvhLen + emisLen are float
+		// counts, both multiples of 4, so this divides cleanly).
+		this.reverseMapVec4Offset.value = ( lbvhLen + emisLen ) / 4;
 
 	}
 
-	setEmissiveTriangleData( emissiveData, count, totalPower = 0 ) {
+	setEmissiveTriangleData( emissiveData, count, totalPower = 0, bitTrailMap = null ) {
 
 		if ( ! emissiveData ) return;
 
 		this._emissiveDataCache = emissiveData;
+		if ( bitTrailMap ) this._bitTrailMapCache = bitTrailMap;
 		this.emissiveTriangleCount.value = count;
 		this.emissiveTotalPower.value = totalPower;
 		this._rebuildLightBuffer();

package/src/Stages/Variance.js

@@ -1,4 +1,4 @@
-import { Fn, wgslFn, float, int, uint, ivec2, uvec2, uniform, If, max,
+import { Fn, wgslFn, float, int, uint, ivec2, uvec2, uniform, If, max, select,
 	textureLoad, textureStore, workgroupArray, workgroupBarrier, localId, workgroupId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { FloatType, RGBAFormat, LinearFilter, Box2, Vector2 } from 'three';
@@ -6,6 +6,10 @@ import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { luminance } from '../TSL/Common.js';
 import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
 
+// NaN/±Inf guard: a poisoned luminance would otherwise corrupt the moment EMA forever
+// (mean/meanSq → variance → BilateralFilter sigmaL). NaN (x!=x) → 0, ±Inf → [0,1e7].
+const sanitizeLum = ( x ) => select( x.equal( x ), x, float( 0.0 ) ).clamp( 0.0, 1e7 );
+
 // ── wgslFn helpers ──────────────────────────────────────────
 
 /**
@@ -203,7 +207,7 @@ export class Variance extends RenderStage {
 			const gy1 = tileOriginY.add( int( sy1 ) ).clamp( int( 0 ), int( resH ).sub( 1 ) );
 
 			const sColor1 = textureLoad( colorTex, ivec2( gx1, gy1 ) ).xyz;
-			sharedLum.element( linearIdx ).assign( luminance( sColor1 ) );
+			sharedLum.element( linearIdx ).assign( sanitizeLum( luminance( sColor1 ) ) );
 
 			// Load #2: threads 0-35 load positions 64-99
 			If( linearIdx.lessThan( uint( EXTRA_LOAD ) ), () => {
@@ -215,7 +219,7 @@ export class Variance extends RenderStage {
 				const gy2 = tileOriginY.add( int( sy2 ) ).clamp( int( 0 ), int( resH ).sub( 1 ) );
 
 				const sColor2 = textureLoad( colorTex, ivec2( gx2, gy2 ) ).xyz;
-				sharedLum.element( idx2 ).assign( luminance( sColor2 ) );
+				sharedLum.element( idx2 ).assign( sanitizeLum( luminance( sColor2 ) ) );
 
 			} );
 

package/src/TSL/EmissiveSampling.js

@@ -312,8 +312,9 @@ export const calculateEmissiveLightPdf = Fn( ( [
 	// Targeted material read: only fetch emissive data (2 vec4s instead of full 27)
 	const matData1 = getDatafromStorageBuffer( materialBuffer, triData.materialIndex, int( MATERIAL_SLOT.EMISSIVE_ROUGHNESS ), MATERIAL_SLOTS );
 	const matData2 = getDatafromStorageBuffer( materialBuffer, triData.materialIndex, int( MATERIAL_SLOT.IOR_TRANSMISSION ), MATERIAL_SLOTS );
-	const avgEmissive = matData1.x.add( matData1.y ).add( matData1.z ).div( 3.0 );
-	const power = max( avgEmissive.mul( matData2.a ).mul( area ), float( 1e-10 ) );
+	// Rec.709 luma — must match EmissiveTriangleBuilder's power weighting for MIS consistency.
+	const luma = matData1.x.mul( 0.2126 ).add( matData1.y.mul( 0.7152 ) ).add( matData1.z.mul( 0.0722 ) );
+	const power = max( luma.mul( matData2.a ).mul( area ), float( 1e-10 ) );
 	const selectionPdf = power.div( max( emissiveTotalPower, float( 1e-10 ) ) );
 
 	const result = float( 0.0 ).toVar();