rayzee 7.2.0 → 7.2.1

package/package.json

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

package/src/PathTracerApp.js

@@ -1190,8 +1190,13 @@ export class PathTracerApp extends EventDispatcher {
 			if ( result ) {
 
 				this.stages.pathTracer.setEmissiveTriangleData(
-					result.rawData, result.emissiveCount, result.totalPower,
+					result.rawData, result.emissiveCount, result.totalPower, result.bitTrailMap,
 				);
+				if ( result.lightBVHNodeData ) {
+
+					this.stages.pathTracer.setLightBVHData( result.lightBVHNodeData, result.lightBVHNodeCount );
+
+				}
 
 			}
 

package/src/Processor/EmissiveTriangleBuilder.js

@@ -22,6 +22,10 @@ export class EmissiveTriangleBuilder {
 		this.cdfArray = null;
 		this.lightBVHNodeData = null;
 		this.lightBVHNodeCount = 0;
+		// Per-triangle bit-trail (root→leaf path through the Light BVH), indexed by absolute
+		// triangleIndex, -1 for non-emissive. Lets the GPU re-walk the descent pdf for MIS.
+		this.emissiveBitTrailMap = null;
+		this._totalTriangleCount = 0;
 
 	}
 
@@ -37,6 +41,7 @@ export class EmissiveTriangleBuilder {
 
 		this.emissiveTriangles = [];
 		this.totalEmissivePower = 0;
+		this._totalTriangleCount = triangleCount;
 
 		const FLOATS_PER_TRIANGLE = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 		const MATERIAL_INDEX_OFFSET = TRIANGLE_DATA_LAYOUT.UV_C_MAT_OFFSET + 2; // materialIndex within vec4
@@ -74,9 +79,21 @@ export class EmissiveTriangleBuilder {
 
 				const area = this._calculateTriangleArea( v0x, v0y, v0z, v1x, v1y, v1z, v2x, v2y, v2z );
 
-				// Calculate emissive power (luminance * intensity * area)
-				const avgEmissive = ( emissive.r + emissive.g + emissive.b ) / 3.0;
-				const power = avgEmissive * emissiveIntensity * area;
+				// Calculate emissive power (Rec.709 luminance * intensity * area) — must match the
+				// shader's calculateEmissiveLightPdf luma weighting for MIS consistency.
+				const luma = 0.2126 * emissive.r + 0.7152 * emissive.g + 0.0722 * emissive.b;
+				const power = luma * emissiveIntensity * area;
+
+				// Geometric normal (emission cone axis). BackSide flips it; DoubleSide → two-sided.
+				let nx = ( v1y - v0y ) * ( v2z - v0z ) - ( v1z - v0z ) * ( v2y - v0y );
+				let ny = ( v1z - v0z ) * ( v2x - v0x ) - ( v1x - v0x ) * ( v2z - v0z );
+				let nz = ( v1x - v0x ) * ( v2y - v0y ) - ( v1y - v0y ) * ( v2x - v0x );
+				const nl = Math.sqrt( nx * nx + ny * ny + nz * nz ) || 1;
+				const sideSign = material.side === 1 ? - 1 : 1; // THREE.BackSide flips emission normal
+				nx = nx / nl * sideSign;
+				ny = ny / nl * sideSign;
+				nz = nz / nl * sideSign;
+				const twoSided = material.side === 2; // THREE.DoubleSide
 
 				// Centroid for BVH split decisions
 				const cx = ( v0x + v1x + v2x ) / 3;
@@ -100,6 +117,7 @@ export class EmissiveTriangleBuilder {
 					emissiveIntensity: emissiveIntensity,
 					cx, cy, cz,
 					bMinX, bMinY, bMinZ, bMaxX, bMaxY, bMaxZ,
+					nx, ny, nz, twoSided,
 				} );
 
 				this.totalEmissivePower += power;
@@ -459,22 +477,34 @@ export class EmissiveTriangleBuilder {
 
 		if ( this.emissiveCount === 0 ) {
 
-			// Dummy single leaf node
+			// Dummy single leaf node (whole-sphere cone)
 			this.lightBVHNodeData = new Float32Array( 16 );
 			this.lightBVHNodeData[ 7 ] = 1.0; // isLeaf
+			this.lightBVHNodeData[ 14 ] = 1.0; // cone axis z
+			this.lightBVHNodeData[ 15 ] = - 1.0; // cosThetaO = whole sphere
 			this.lightBVHNodeCount = 1;
+			this.emissiveBitTrailMap = new Float32Array( Math.max( this._totalTriangleCount, 1 ) ).fill( - 1 );
 			return 1;
 
 		}
 
 		const builder = new LightBVHBuilder();
-		const { nodeData, nodeCount, sortedPerm } = builder.build( this.emissiveTriangles );
+		const { nodeData, nodeCount, sortedPerm, bitTrails } = builder.build( this.emissiveTriangles );
 		this.lightBVHNodeData = nodeData;
 		this.lightBVHNodeCount = nodeCount;
 
 		// Rebuild emissive raw data in sorted leaf order so node start/count refs are valid
 		this._rebuildSortedEmissiveData( sortedPerm );
 
+		// Build the per-triangle bit-trail map (indexed by absolute triangleIndex; -1 = non-emissive)
+		this.emissiveBitTrailMap = new Float32Array( Math.max( this._totalTriangleCount, 1 ) ).fill( - 1 );
+		for ( let i = 0; i < sortedPerm.length; i ++ ) {
+
+			const triIndex = this.emissiveTriangles[ sortedPerm[ i ] ].triangleIndex;
+			this.emissiveBitTrailMap[ triIndex ] = bitTrails[ i ];
+
+		}
+
 		return nodeCount;
 
 	}
@@ -544,6 +574,10 @@ export class EmissiveTriangleBuilder {
 		this.cdfArray = null;
 		this.lightBVHNodeData = null;
 		this.lightBVHNodeCount = 0;
+		// Per-triangle bit-trail (root→leaf path through the Light BVH), indexed by absolute
+		// triangleIndex, -1 for non-emissive. Lets the GPU re-walk the descent pdf for MIS.
+		this.emissiveBitTrailMap = null;
+		this._totalTriangleCount = 0;
 
 	}
 

package/src/Processor/LightBVHBuilder.js

@@ -4,14 +4,20 @@
  * CPU-side BVH builder over emissive triangles for spatially-aware light sampling.
  * Each node occupies 4 vec4s (16 floats, BVH_STRIDE=4):
  *
- *   vec4[0]: [aabb.minX, aabb.minY, aabb.minZ, totalPower]
- *   vec4[1]: [aabb.maxX, aabb.maxY, aabb.maxZ, isLeaf]   // isLeaf: 0.0=inner, 1.0=leaf
+ *   vec4[0]: [aabb.minX, aabb.minY, aabb.minZ, totalPower]   // power = Rec.709 luma-weighted
+ *   vec4[1]: [aabb.maxX, aabb.maxY, aabb.maxZ, isLeaf]       // isLeaf: 0.0=inner, 1.0=leaf
  *   vec4[2]: inner → [leftChildIdx, rightChildIdx, 0, 0]
  *            leaf  → [emissiveStart, emissiveCount, 0, 0]
- *   vec4[3]: [0, 0, 0, 0]
+ *   vec4[3]: [coneAxisX, coneAxisY, coneAxisZ, cosThetaO]    // emission orientation cone (Conty-Kulla)
+ *
+ * The orientation cone bounds the emission directions of the cluster (θ_o = spread of emitter
+ * normals; θ_e = π/2 assumed for diffuse emitters, applied at sample time). cosThetaO = -1 means
+ * "whole sphere" (mixed/two-sided cluster → never culled by orientation).
  *
  * Build algorithm: median split on longest centroid AABB axis, maxLeafSize=8.
- * Output: pre-order flattened array with right child pushed first (so left is processed first).
+ * Output: pre-order flattened array with left child immediately after parent.
+ * Also emits a per-(sorted)-triangle bit-trail: the sequence of left(0)/right(1) child choices
+ * from the root to that triangle's leaf, so the GPU can re-walk the exact descent for MIS.
  */
 export class LightBVHBuilder {
 
@@ -26,19 +32,22 @@ export class LightBVHBuilder {
 	 *
 	 * @param {Array} emissiveTriangles - Array of objects:
 	 *   { triangleIndex, power, area, emissive, emissiveIntensity, cx, cy, cz,
-	 *     bMinX, bMinY, bMinZ, bMaxX, bMaxY, bMaxZ }
-	 * @returns {{ nodeData: Float32Array, nodeCount: number, sortedPerm: Int32Array }}
+	 *     bMinX, bMinY, bMinZ, bMaxX, bMaxY, bMaxZ, nx, ny, nz, twoSided }
+	 * @returns {{ nodeData: Float32Array, nodeCount: number, sortedPerm: Int32Array, bitTrails: Float32Array }}
 	 *   sortedPerm[i] = original index in emissiveTriangles for position i in sorted leaf order
+	 *   bitTrails[i]  = root→leaf bit-trail for the triangle now at sorted position i (as a float-encoded int)
 	 */
 	build( emissiveTriangles ) {
 
 		const n = emissiveTriangles.length;
 		if ( n === 0 ) {
 
-			// Dummy leaf node
+			// Dummy leaf node — whole-sphere cone so importance never culls it
 			const nodeData = new Float32Array( 16 );
 			nodeData[ 7 ] = 1.0; // isLeaf
-			return { nodeData, nodeCount: 1, sortedPerm: new Int32Array( 0 ) };
+			nodeData[ 14 ] = 1.0; // cone axis z
+			nodeData[ 15 ] = - 1.0; // cosThetaO = whole sphere
+			return { nodeData, nodeCount: 1, sortedPerm: new Int32Array( 0 ), bitTrails: new Float32Array( 0 ) };
 
 		}
 
@@ -52,8 +61,11 @@ export class LightBVHBuilder {
 		const nodeData = new Float32Array( maxNodes * 16 );
 		let nodeCount = 0;
 
-		// Recursively build; returns node index
-		const buildRecursive = ( start, end ) => {
+		// bit-trail per sorted position (filled at leaves). 24-bit safe → tree depth < 24 (≈16M leaf clusters).
+		const bitTrails = new Float32Array( n );
+
+		// Recursively build; returns { nodeIndex, cone }. `trail`/`depth` accumulate the root→leaf path.
+		const buildRecursive = ( start, end, trail, depth ) => {
 
 			const nodeIndex = nodeCount ++;
 			const nodeOffset = nodeIndex * 16;
@@ -95,16 +107,11 @@ export class LightBVHBuilder {
 			nodeData[ nodeOffset + 4 ] = maxX;
 			nodeData[ nodeOffset + 5 ] = maxY;
 			nodeData[ nodeOffset + 6 ] = maxZ;
-			// nodeData[nodeOffset + 7] = isLeaf — set below
-
-			// vec4[3]: zeros (reserved)
-			nodeData[ nodeOffset + 12 ] = 0;
-			nodeData[ nodeOffset + 13 ] = 0;
-			nodeData[ nodeOffset + 14 ] = 0;
-			nodeData[ nodeOffset + 15 ] = 0;
 
 			const count = end - start;
 
+			let cone;
+
 			if ( count <= this.maxLeafSize ) {
 
 				// LEAF NODE
@@ -114,6 +121,18 @@ export class LightBVHBuilder {
 				nodeData[ nodeOffset + 10 ] = 0;
 				nodeData[ nodeOffset + 11 ] = 0;
 
+				// Cone = union of this leaf's triangle emission cones; write this leaf's bit-trail
+				cone = null;
+				for ( let i = start; i < end; i ++ ) {
+
+					const tri = emissiveTriangles[ indices[ i ] ];
+					cone = coneUnion( cone, triangleCone( tri ) );
+					bitTrails[ i ] = trail;
+
+				}
+
+				if ( ! cone ) cone = { ax: 0, ay: 0, az: 1, cosO: - 1 };
+
 			} else {
 
 				// INNER NODE — find longest centroid axis and split at median
@@ -135,24 +154,31 @@ export class LightBVHBuilder {
 
 				nodeData[ nodeOffset + 7 ] = 0.0; // isLeaf = false (inner)
 
-				// Build children (right first so left is processed first in pre-order)
-				// We need left index first but must build in correct pre-order order
-				// Build left child immediately after this node
-				const leftChildIdx = buildRecursive( start, mid );
-				const rightChildIdx = buildRecursive( mid, end );
+				// Build left child immediately after this node (pre-order), then right.
+				// Trail bit at `depth`: 0 for left, 1 for right.
+				const left = buildRecursive( start, mid, trail, depth + 1 );
+				const right = buildRecursive( mid, end, trail + Math.pow( 2, depth ), depth + 1 );
 
-				nodeData[ nodeOffset + 8 ] = leftChildIdx;
-				nodeData[ nodeOffset + 9 ] = rightChildIdx;
+				nodeData[ nodeOffset + 8 ] = left.nodeIndex;
+				nodeData[ nodeOffset + 9 ] = right.nodeIndex;
 				nodeData[ nodeOffset + 10 ] = 0;
 				nodeData[ nodeOffset + 11 ] = 0;
 
+				cone = coneUnion( left.cone, right.cone );
+
 			}
 
-			return nodeIndex;
+			// vec4[3]: [coneAxisX, coneAxisY, coneAxisZ, cosThetaO]
+			nodeData[ nodeOffset + 12 ] = cone.ax;
+			nodeData[ nodeOffset + 13 ] = cone.ay;
+			nodeData[ nodeOffset + 14 ] = cone.az;
+			nodeData[ nodeOffset + 15 ] = cone.cosO;
+
+			return { nodeIndex, cone };
 
 		};
 
-		buildRecursive( 0, n );
+		buildRecursive( 0, n, 0, 0 );
 
 		// sortedPerm: the rearranged indices array (leaf order)
 		const sortedPerm = new Int32Array( n );
@@ -164,7 +190,7 @@ export class LightBVHBuilder {
 
 		console.log( `[LightBVHBuilder] Built BVH: ${nodeCount} nodes for ${n} emissive triangles` );
 
-		return { nodeData: trimmedData, nodeCount, sortedPerm };
+		return { nodeData: trimmedData, nodeCount, sortedPerm, bitTrails };
 
 	}
 
@@ -217,3 +243,63 @@ export class LightBVHBuilder {
 	}
 
 }
+
+// ================================================================================
+// ORIENTATION CONE HELPERS (Conty-Estevez & Kulla 2018 / PBRT-v4 DirectionCone)
+// ================================================================================
+
+// Per-triangle emission cone: axis = geometric normal, θ_o = 0 (single direction).
+// Two-sided emitters emit into both hemispheres → whole sphere (cosO = -1).
+function triangleCone( tri ) {
+
+	if ( tri.twoSided ) return { ax: tri.nx, ay: tri.ny, az: tri.nz, cosO: - 1 };
+	return { ax: tri.nx, ay: tri.ny, az: tri.nz, cosO: 1 };
+
+}
+
+// Union of two direction cones (PBRT-v4 DirectionCone::Union). cosO === -1 ⇒ whole sphere.
+function coneUnion( a, b ) {
+
+	if ( ! a ) return b;
+	if ( ! b ) return a;
+	if ( a.cosO <= - 1 ) return a; // a is already whole sphere
+	if ( b.cosO <= - 1 ) return b;
+
+	const cosA = Math.min( Math.max( a.cosO, - 1 ), 1 );
+	const cosB = Math.min( Math.max( b.cosO, - 1 ), 1 );
+	const thetaA = Math.acos( cosA );
+	const thetaB = Math.acos( cosB );
+	const dotAB = Math.min( Math.max( a.ax * b.ax + a.ay * b.ay + a.az * b.az, - 1 ), 1 );
+	const thetaD = Math.acos( dotAB );
+
+	// One cone already contains the other
+	if ( Math.min( thetaD + thetaB, Math.PI ) <= thetaA ) return a;
+	if ( Math.min( thetaD + thetaA, Math.PI ) <= thetaB ) return b;
+
+	const thetaO = ( thetaA + thetaB + thetaD ) * 0.5;
+	if ( thetaO >= Math.PI ) return { ax: a.ax, ay: a.ay, az: a.az, cosO: - 1 };
+
+	const thetaR = thetaO - thetaA;
+
+	// Rotation axis = normalize(cross(a, b))
+	let wx = a.ay * b.az - a.az * b.ay;
+	let wy = a.az * b.ax - a.ax * b.az;
+	let wz = a.ax * b.ay - a.ay * b.ax;
+	const wl = Math.sqrt( wx * wx + wy * wy + wz * wz );
+	if ( wl < 1e-8 ) return { ax: a.ax, ay: a.ay, az: a.az, cosO: - 1 }; // (anti)parallel → whole sphere
+	wx /= wl; wy /= wl; wz /= wl;
+
+	// Rodrigues: rotate a.axis around (wx,wy,wz) by thetaR
+	const c = Math.cos( thetaR ), s = Math.sin( thetaR );
+	const kdotv = wx * a.ax + wy * a.ay + wz * a.az;
+	const cx = wy * a.az - wz * a.ay;
+	const cy = wz * a.ax - wx * a.az;
+	const cz = wx * a.ay - wy * a.ax;
+	const ax = a.ax * c + cx * s + wx * kdotv * ( 1 - c );
+	const ay = a.ay * c + cy * s + wy * kdotv * ( 1 - c );
+	const az = a.az * c + cz * s + wz * kdotv * ( 1 - c );
+	const al = Math.sqrt( ax * ax + ay * ay + az * az ) || 1;
+
+	return { ax: ax / al, ay: ay / al, az: az / al, cosO: Math.cos( thetaO ) };
+
+}

package/src/Processor/SceneProcessor.js

@@ -90,6 +90,7 @@ export class SceneProcessor {
 		this.emissiveTriangleCount = 0;
 		this.lightBVHNodeData = null;
 		this.lightBVHNodeCount = 0;
+		this.emissiveBitTrailMap = null;
 
 		// Initialize processing components
 		this._initProcessors();
@@ -818,6 +819,8 @@ export class SceneProcessor {
 		this.lightBVHNodeCount = this.emissiveTriangleBuilder.lightBVHNodeCount;
 		// Replace emissiveTriangleData with sorted version (LBVH reorders it)
 		this.emissiveTriangleData = this.emissiveTriangleBuilder.emissiveTriangleData || this.emissiveTriangleData;
+		// Per-triangle bit-trail map for the bounce-hit MIS re-walk
+		this.emissiveBitTrailMap = this.emissiveTriangleBuilder.emissiveBitTrailMap;
 
 	}
 
@@ -872,6 +875,7 @@ export class SceneProcessor {
 		this.instanceTable = null;
 		this.lightBVHNodeData = null;
 		this.lightBVHNodeCount = 0;
+		this.emissiveBitTrailMap = null;
 
 		// Reset performance metrics
 		this.performanceMetrics = {
@@ -1406,6 +1410,7 @@ export class SceneProcessor {
 				this.emissiveTriangleData,
 				this.emissiveTriangleCount,
 				this.emissiveTotalPower,
+				this.emissiveBitTrailMap,
 			);
 
 		}
@@ -1450,10 +1455,23 @@ export class SceneProcessor {
 
 		if ( ! changed ) return null;
 
+		// Rebuild the Light BVH + sorted emissive data + bit-trail map so the stochastic descent and
+		// the bounce-hit MIS re-walk stay consistent after powers / the emissive set change.
+		this.emissiveTriangleBuilder.buildLightBVH();
+		this.lightBVHNodeData = this.emissiveTriangleBuilder.lightBVHNodeData;
+		this.lightBVHNodeCount = this.emissiveTriangleBuilder.lightBVHNodeCount;
+		this.emissiveTriangleData = this.emissiveTriangleBuilder.emissiveTriangleData;
+		this.emissiveBitTrailMap = this.emissiveTriangleBuilder.emissiveBitTrailMap;
+		this.emissiveTriangleCount = this.emissiveTriangleBuilder.emissiveCount;
+		this.emissiveTotalPower = this.emissiveTriangleBuilder.totalEmissivePower;
+
 		return {
-			rawData: this.emissiveTriangleBuilder.createEmissiveRawData(),
+			rawData: this.emissiveTriangleBuilder.emissiveTriangleData,
 			emissiveCount: this.emissiveTriangleBuilder.emissiveCount,
 			totalPower: this.emissiveTriangleBuilder.totalEmissivePower,
+			bitTrailMap: this.emissiveBitTrailMap,
+			lightBVHNodeData: this.lightBVHNodeData,
+			lightBVHNodeCount: this.lightBVHNodeCount,
 		};
 
 	}

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/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();