rayzee 10.0.0 → 11.0.0

package/src/TSL/ShadeKernel.js

@@ -7,35 +7,48 @@
 import {
 	Fn, float, vec2, vec3, vec4, int, uint,
 	bool as tslBool,
-	If, Loop, normalize, max, min, exp, log, clamp, dot, length, select, smoothstep, acos,
+	If, Loop, normalize, max, min, exp, log, clamp, dot, length, select, smoothstep, acos, abs, cross,
 	instanceIndex,
 	sampler,
 	atomicLoad, atomicStore,
 	Return,
 } from 'three/tsl';
 
-import { sampleEnvironment, sampleEquirect, groundProjectedEnvDir } from './Environment.js';
-import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial, offsetRayOrigin, SHADOW_END, triangleRow, MIN_ROUGHNESS } from './Common.js';
+import { sampleEnvironment, groundProjectedEnvDir, sampleEnvironmentExact, environmentPdfExact } from './Environment.js';
+import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial, offsetRayOrigin, SHADOW_END, triangleRow, MIN_ROUGHNESS, MIN_PDF } from './Common.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
 import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, getTransformedUV, triangleUVTangent } from './TextureSampling.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
-import { calculateDirectLightingUnified, calculateMaterialPDF } from './LightsSampling.js';
-import { traceShadowRay } from './LightsDirect.js';
+import {
+	calculateDirectLightingUnified, calculateDirectLightingThroughSurfaces, calculateMaterialPDF,
+	calculateDirectLightingPicked,
+	sampleDirectionalLight, sampleRectAreaLight, samplePointLightWithAttenuation, sampleSpotLightWithRadius,
+	areaLightRadiance, areaLightSpreadAttenuation,
+} from './LightsSampling.js';
+import { traceShadowRay, traceShadowRayRefractiveOpaque, estimateLightImportance } from './LightsDirect.js';
 import { shadowTerminatorOrigin } from './ShadowTerminator.js';
-import { unpackHitFacet } from './HitFacet.js';
+import { hitFacet, unpackHitFacet, windingNormal } from './HitFacet.js';
 import { traverseBVHShadow, triangleSide, sideAccepts } from './BVHTraversal.js';
+import { visibilityCell } from './LightVisibility.js';
 import { handleMaterialTransparency, MaterialInteractionResult } from './MaterialTransmission.js';
 import { sampleChromaticCollision, sampleHenyeyGreenstein, subsurfaceCoefficients, CollisionSample, MediumCoeffs } from './Subsurface.js';
+import { ALL_MATERIAL_LAYERS } from './SceneResources.js';
 import { calculateIndirectLighting } from './LightsIndirect.js';
-import { IndirectLightingResult, sampleCone } from './LightsCore.js';
-import { sunRadianceToward } from './Sun.js';
-import { regularizePathContribution, generateSampledDirection, computeNDCDepth, handleRussianRoulette } from './PathTracerCore.js';
+import {
+	IndirectLightingResult, sampleCone, LightSample, DirectionalLight, AreaLight, PointLight, SpotLight,
+	getDirectionalLight, getAreaLight, getPointLight, getSpotLight, intersectAreaLight, getDistanceAttenuation, sampleDirectionalGoboMask,
+	LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_AREA, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT,
+} from './LightsCore.js';
+import { sunRadianceToward, sampleSunDisc } from './Sun.js';
+import { regularizePathContribution, generateSampledDirection, computeNDCDepth, handleRussianRoulette, DELTA_PDF } from './PathTracerCore.js';
 import { evaluateSpecularDFG, baseFresnelParams } from './MaterialProperties.js';
-import { NRD_HIT_DIST_A, NRD_HIT_DIST_B } from '../EngineDefaults.js';
 import { sampleClearcoat, ClearcoatResult } from './Clearcoat.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
-import { calculateEmissiveTriangleContribution, calculateEmissiveLightPdf, EmissiveSample } from './EmissiveSampling.js';
-import { sampleLightBVHTriangle, calculateLightBVHPdf } from './LightBVHSampling.js';
+import {
+	calculateEmissiveTriangleContribution, calculateEmissiveLightPdf, EmissiveSample, EmissiveSampleIndexed,
+	sampleEmissiveTriangle, sampleEmissiveTriangleIndexed, fetchTriangleData, TriangleData,
+} from './EmissiveSampling.js';
+import { sampleLightBVHTriangle, sampleLightBVHTriangleIndexed, calculateLightBVHPdf } from './LightBVHSampling.js';
 import {
 	Ray,
 	HitInfo,
@@ -65,6 +78,7 @@ import {
 	readRayRadiance,
 	readFeatureThroughput, writeFeatureThroughput,
 	readRngState, writeRngState,
+	readMisState, writeRngMis, pendingVertex, cachedVertex, writeVertexRecord, writeLightPathLength, readLightOrigin,
 } from '../Processor/PackedRayBuffer.js';
 
 const WG_SIZE = 256;
@@ -88,7 +102,7 @@ export function buildShadeKernel( params ) {
 		enableEnvironmentLight,
 		groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight, groundProjectionLevel,
 		enableGroundCatcher, groundCatcherHeight,
-		envTotalSum, envCompensationDelta, envResolution,
+		envTotalSum, envResolution,
 		directionalLightsBuffer, numDirectionalLights,
 		areaLightsBuffer, numAreaLights,
 		pointLightsBuffer, numPointLights,
@@ -110,15 +124,37 @@ export function buildShadeKernel( params ) {
 		emissiveBoost, enableEmissiveTriangleSampling,
 		lightBVHNodeCount, reverseMapVec4Offset,
 		maxRayCount,
-		// Aux G-buffer (normal/depth/albedo + surface ID) feeds only the denoiser/OIDN MRT. Gated by a
-		// live uniform (1 = denoiser on) so the wavefront skips these writes when nothing consumes them.
-		auxGBufferEnabled,
+		// Aux G-buffer (normal/depth/albedo + surface ID) feeds only the denoiser/OIDN MRT. Compiled in only when
+		// requested (PathTracer.requestOutput( 'gBuffer' )); then a live uniform (1 = denoiser on) skips the writes
+		// while nothing consumes them.
+		auxGBufferEnabled, gBuffer = true,
 		hasSun, sunDirection, sunRadiance, sunParams,
+		// Bidirectional: light subpaths shade here too; camera vertices leave connections for ConnectKernel.
+		bidirectional: bdpt = null,
+		// The hit-distance output, when a stage asked for it (PathTracer.requestOutput).
+		hitDistanceEncode = null,
+		// The material layers some material uses (MaterialDataManager.materialLayers); the rest compile out. Bidirectional
+		// always leaves diffuse transmission out: its connections and light tracing do not cross surfaces yet.
+		materialLayers: layers = ALL_MATERIAL_LAYERS,
+		// Fewer shadow rays a hit, emitters included: null (one per light kind) or a lightPick variant; path tracing only.
+		shadowRays = null,
+		cameraWorldMatrix = null,
 	} = params;
+	const diffuseTransmission = layers.diffuseTransmission;
 
-	const auxOn = auxGBufferEnabled.greaterThan( uint( 0 ) );
+	// The bidirectional shading functions come with the integrator's uniforms (BidirectionalIntegrator), only used where bdpt is.
+	const {
+		mis, misOnHit, misOnSpecular, misOnScatter, misPartial, misWeight, emitterSideProbability, emitterAreaPdf, lightEndCosine, mergeVmAt, strategyWeight, sunEmissionPdf, STRATEGY, LIGHT_PIXEL_ROW_OFFSET, sourcePick, lampSource, sourceLampType, sourceLampIndex, SOURCE, guidedDiscPdf, recordEscape, LampPick, pickLamp, lampPickPdf, lampCount, spotConeSolidAngle, directionalConeSolidAngle, areaLightDirectPdfW,
+	} = bdpt?.lib ?? {};
+
+	const auxOn = gBuffer ? auxGBufferEnabled.greaterThan( uint( 0 ) ) : null;
 
 	const useEmissiveNEE = lightBuffer !== undefined;
+	const picksLights = shadowRays && ! bdpt;
+	const lamps = {
+		directional: directionalLightsBuffer, numDirectional: numDirectionalLights, area: areaLightsBuffer, numArea: numAreaLights,
+		point: pointLightsBuffer, numPoint: numPointLights, spot: spotLightsBuffer, numSpot: numSpotLights,
+	};
 
 	// Stochastic cone-jitter blur of an env backdrop lookup. Plain JS inliner (NOT a Fn — an rng Fn-param
 	// would freeze; see TSL pitfalls) so it mutates the caller's rngState .toVar() directly. Shared by the
@@ -150,6 +186,29 @@ export function buildShadeKernel( params ) {
 
 	};
 
+	// Emissive NEE's solid-angle density for a triangle's point, from whichever sampler it runs.
+	const emissiveNEEPdf = ( triangle, dist, toLight, from, instanceLeaf ) => {
+
+		const pdf = float( 0.0 ).toVar();
+		If( lightBVHNodeCount.greaterThan( int( 0 ) ), () => {
+
+			pdf.assign( calculateLightBVHPdf(
+				triangle, dist, toLight, from,
+				lightBuffer, emissiveVec4Offset, reverseMapVec4Offset, triangleBuffer, bvhBuffer,
+			) );
+
+		} ).Else( () => {
+
+			pdf.assign( calculateEmissiveLightPdf(
+				triangle, dist, toLight, from,
+				triangleBuffer, materialBuffer, emissiveTotalPower, bvhBuffer, instanceLeaf,
+			) );
+
+		} );
+		return pdf;
+
+	};
+
 	const computeFn = Fn( () => {
 
 		const threadIdx = instanceIndex;
@@ -186,6 +245,11 @@ export function buildShadeKernel( params ) {
 
 		} );
 
+		// A light subpath gathers nothing; camera-only work is gated on it.
+		const isLight = bdpt ? flags.bitAnd( uint( RAY_FLAG.LIGHT_PATH ) ).notEqual( uint( 0 ) ).toVar() : null;
+		const cameraOnly = ( cond ) => ( bdpt ? cond.and( isLight.not() ) : cond );
+		const aux = auxOn ? cameraOnly( auxOn ) : null;
+
 		// Backdrop-view = the ray still travels the original camera direction (only alpha/transparent passthrough
 		// since the camera, REDIRECTED still clear). Captured at ARRIVAL (before the opaque/redirect bitOr below)
 		// so it stays valid for both the miss branch and the emissive-hit scale. This — not bounceIndex==0 — is
@@ -200,6 +264,11 @@ export function buildShadeKernel( params ) {
 		// One ray per pixel: rayID is the pixel index.
 		const pixelIndex = rayID;
 		const rngState = readRngState( hitBufferRW, rayID ).toVar();
+		const subpathState = bdpt ? readMisState( hitBufferRW, rayID ) : null;
+		const subpath = bdpt ? { dVCM: subpathState.dVCM.toVar(), dVC: subpathState.dVC.toVar(), vm: null } : null;
+		const persistRng = () => ( bdpt
+			? writeRngMis( hitBufferRW, rayID, rngState, subpath.dVCM, subpath.dVC )
+			: writeRngState( hitBufferRW, rayID, rngState ) );
 
 		// Samples key on the GLOBAL pixel. pixelIndex is the LOCAL path slot; the global pixel
 		// = chunkRowBase·W + localSlot, so sequences stay aligned across row-band chunks
@@ -207,9 +276,10 @@ export function buildShadeKernel( params ) {
 		// Hoisted here rather than at the BSDF draw because the ground catcher runs NEE far earlier.
 		const _resX = int( resolution.x ).toVar();
 		const _globalPixel = int( pixelIndex ).add( chunkRowBase.mul( _resX ) );
+		const _pixelRow = float( _globalPixel.div( _resX ) ).add( 0.5 );
 		const _pixelCoord = vec2(
 			float( _globalPixel.mod( _resX ) ).add( 0.5 ),
-			float( _globalPixel.div( _resX ) ).add( 0.5 ),
+			bdpt ? _pixelRow.add( select( isLight, float( LIGHT_PIXEL_ROW_OFFSET ), float( 0.0 ) ) ) : _pixelRow,
 		);
 		// This bounce's block of sampler dimensions — see the budget table in Random.js.
 		const dimBase = int( currentBounce ).mul( int( SAMPLER_DIMS_PER_BOUNCE ) );
@@ -217,7 +287,7 @@ export function buildShadeKernel( params ) {
 		// DDFA see-through aux tint carried across smooth glass/mirror; committed into the OIDN/ASVGF
 		// albedo guide at the first diffuse-enough surface (or env). Mutated locally, persisted on every
 		// deferring continue (a missed persist = stale tint). 1 = untinted (direct hit → today's albedo).
-		const featCarry = readFeatureThroughput( rayBufferRW, rayID ).toVar();
+		const featCarry = aux ? readFeatureThroughput( rayBufferRW, rayID ).toVar() : null;
 
 		const hitDist = readHitDistance( hitBufferRW, rayID ).toVar();
 		const hitNormal = readHitNormal( hitBufferRW, rayID ).toVar();
@@ -234,14 +304,13 @@ export function buildShadeKernel( params ) {
 		const sssSteps = readSssSteps( rayBufferRW, rayID ).toVar();
 		const transparentCount = readTransparentCount( rayBufferRW, rayID ).toVar();
 
-		// NRD guide: first segment after the primary scatter, plus any alpha-skip run so a cutout hole
+		// Hit distance: first segment after the primary scatter, plus any alpha-skip run so a cutout hole
 		// doesn't shorten it. Unconditional at depth 1, so the post-skip segment wins.
-		If( auxOn.and( cameraDepth.equal( 1 ) ), () => {
+		if ( hitDistanceEncode && aux ) If( aux.and( cameraDepth.equal( 1 ) ), () => {
 
 			const scatterViewZ = cameraViewMatrix.mul( vec4( origin, 1.0 ) ).z.abs();
-			const norm = scatterViewZ.mul( NRD_HIT_DIST_B ).add( NRD_HIT_DIST_A );
 			const total = readMisRayT( rayBufferRW, rayID ).add( min( hitDist, float( 1e6 ) ) );
-			writeGBufferHitDist( gBufferRW, pixelIndex, total.div( max( norm, float( 1e-4 ) ) ).clamp( 0.0, 1.0 ) );
+			writeGBufferHitDist( gBufferRW, pixelIndex, hitDistanceEncode( total, scatterViewZ ) );
 
 		} );
 
@@ -252,7 +321,7 @@ export function buildShadeKernel( params ) {
 		// ratio in alpha (rgb = 0) so it composites as bg·ratio over a transparent background.
 		// Shadows are caught by the EXISTING NEE shadow ray into real geometry — the plane itself
 		// never enters the BVH. Secondary bounces ignore it entirely.
-		If( enableGroundCatcher.and( bounceIndex.equal( 0 ) ), () => {
+		If( cameraOnly( enableGroundCatcher.and( bounceIndex.equal( 0 ) ) ), () => {
 
 			const dirY = direction.y.toVar();
 			If( dirY.abs().greaterThan( float( EPSILON ) ), () => {
@@ -286,7 +355,7 @@ export function buildShadeKernel( params ) {
 						bvhBuffer, triangleBuffer, materialBuffer,
 						envTexture, environmentIntensity, envMatrix,
 						envCDFTexture,
-						envTotalSum, envCompensationDelta, envResolution,
+						envTotalSum, envResolution,
 						enableEnvironmentLight,
 						tslBool( true ), // wantUnoccluded
 						vec3( 0.0 ), planeN, float( 0.0 ),
@@ -351,7 +420,7 @@ export function buildShadeKernel( params ) {
 					// The catcher is a real ground surface for the denoiser — write the plane's normal/depth
 					// + a neutral albedo (black albedo would break OIDN demodulation) and mark the pixel a
 					// valid surface, so OIDN/ASVGF don't smear the caught shadow as a background miss.
-					If( auxOn, () => {
+					if ( aux ) If( aux, () => {
 
 						const planeDepth = computeNDCDepth( { worldPos: planePoint, cameraProjectionMatrix, cameraViewMatrix } );
 						writeGBuffer( gBufferRW, pixelIndex, planeN, planeDepth, vec3( 1.0 ) );
@@ -361,7 +430,7 @@ export function buildShadeKernel( params ) {
 					writeRayRadiance( rayBufferRW, rayID, vec4( outRgb, outAlpha ) );
 					// DDFA: the plane's aux (written above) is a committed surface — lock it (cosmetic; ray dies here).
 					writeRayDirFlags( rayBufferRW, rayID, direction, flags.bitOr( uint( RAY_FLAG.AUX_LOCKED ) ).bitAnd( uint( ~ RAY_FLAG.ACTIVE ) ) );
-					writeRngState( hitBufferRW, rayID, rngState );
+					persistRng();
 					Return();
 
 				} );
@@ -372,6 +441,13 @@ export function buildShadeKernel( params ) {
 
 		If( hitDist.greaterThan( MISS_DIST ), () => {
 
+			if ( bdpt ) If( isLight, () => {
+
+				writeRayDirFlags( rayBufferRW, rayID, direction, flags.bitAnd( uint( ~ RAY_FLAG.ACTIVE ) ) );
+				Return();
+
+			} );
+
 			// Background and environment-lighting are decoupled (independent axes):
 			//  • Visible backdrop: a PRIMARY ray draws the env image only when showBackground — regardless
 			//    of enableEnvironmentLight (so you can show the HDRI without it lighting the scene).
@@ -381,12 +457,19 @@ export function buildShadeKernel( params ) {
 			// is the direct backdrop", so env seen through alpha-cutout foliage holes is treated identically to
 			// the open sky (blur, intensity, show/hide, color-mode, ground projection all match).
 			// isBackdropView was captured at arrival (above) so it survives the REDIRECTED bitOr on opaque hits.
+			// A camera path out to the sky: where light from infinity gets in (LightGuide.js).
+			if ( bdpt ) If( isBackdropView.not().and( isLight.not() ), () => {
+
+				recordEscape( counters, bdpt, direction, origin );
+
+			} );
+
 			const wantBackdrop = isBackdropView.and( showBackground ); // draw env image as backdrop
 			const wantEnvLight = isBackdropView.not().and( enableEnvironmentLight ); // env as light on redirected bounces
 
 			// DDFA: env colour a redirected ray escaping to the environment sees (e.g. smooth glass over
 			// sky). Committed (tinted by featCarry) into the aux G-buffer before the miss Return below.
-			const escapedAuxAlbedo = vec3( 0.0 ).toVar();
+			const escapedAuxAlbedo = aux ? vec3( 0.0 ).toVar() : null;
 
 			If( wantBackdrop.or( wantEnvLight ), () => {
 
@@ -428,19 +511,27 @@ export function buildShadeKernel( params ) {
 
 				// DDFA: remember the (clamped) env colour this escaped ray sees, for the redirected-escape
 				// aux commit below (tinted by the accumulated see-through throughput).
-				escapedAuxAlbedo.assign( clamp( envColor, vec3( 0.0 ), vec3( 1.0 ) ) );
+				if ( aux ) escapedAuxAlbedo.assign( clamp( envColor, vec3( 0.0 ), vec3( 1.0 ) ) );
 
 				// MIS weight for implicit env hit — prevents double-counting with NEE
 				const envMisWeight = float( 1.0 ).toVar();
-				If( isBackdropView.not(), () => {
+				if ( bdpt ) If( isBackdropView.not(), () => {
+
+					// Georgiev (43) for the environment at infinity, from the exact table its NEE and light paths draw from.
+					const pdfW = select( bdpt.envTable.greaterThan( uint( 0 ) ), environmentPdfExact( envCDFTexture, envMatrix, envResolution, direction ), float( 0.0 ) ).toVar();
+					const directPdfW = select( flags.bitAnd( uint( RAY_FLAG.SUN_NEE ) ).notEqual( uint( 0 ) ), pdfW, float( 0.0 ) );
+					const emissionPdfW = select( bdpt.lightPaths.greaterThan( uint( 0 ) ),
+						bdpt.envPick.mul( pdfW ).mul( guidedDiscPdf( bdpt, bdpt.guideTexture, direction, origin ) ), float( 0.0 ) );
+					envMisWeight.assign( strategyWeight( bdpt.strategyView, STRATEGY.HIT,
+						misWeight( float( 0.0 ), mis( directPdfW ).mul( subpath.dVCM ).add( mis( emissionPdfW ).mul( subpath.dVC ) ) ) ) );
+
+				} );
+				else If( isBackdropView.not(), () => {
 
 					const prevBouncePdf = readRayPdf( rayBufferRW, rayID );
-					If( prevBouncePdf.greaterThan( 0.0 ), () => {
+					If( prevBouncePdf.greaterThan( 0.0 ).and( envTotalSum.greaterThan( 0.0 ) ), () => {
 
-						const envEval = sampleEquirect(
-							envTexture, direction, envMatrix, envTotalSum, envCompensationDelta, envResolution,
-						);
-						const envPdf = envEval.w;
+						const envPdf = environmentPdfExact( envCDFTexture, envMatrix, envResolution, direction ).toVar();
 						If( envPdf.greaterThan( 0.0 ), () => {
 
 							envMisWeight.assign( balanceHeuristic( { pdf1: prevBouncePdf, pdf2: envPdf } ) ); // megakernel parity (PathTracerCore.js:774): env NEE also uses balance
@@ -498,11 +589,29 @@ export function buildShadeKernel( params ) {
 					If( sunL.x.add( sunL.y ).add( sunL.z ).greaterThan( 0.0 ), () => {
 
 						const sunW = float( 1.0 ).toVar();
-						If( isBackdropView.not().and( flags.bitAnd( uint( RAY_FLAG.SUN_NEE ) ).notEqual( uint( 0 ) ) ), () => {
+						if ( bdpt ) {
 
-							sunW.assign( powerHeuristic( { pdf1: readRayPdf( rayBufferRW, rayID ), pdf2: float( 1.0 ).div( sunParams.y ) } ) );
+							// Georgiev (43) for a light at infinity: no distance, and NEE's density is solid angle.
+							If( isBackdropView.not(), () => {
+
+								const directPdfW = select( flags.bitAnd( uint( RAY_FLAG.SUN_NEE ) ).notEqual( uint( 0 ) ), float( 1.0 ).div( sunParams.y ), float( 0.0 ) );
+								const emissionPdfW = select( bdpt.lightPaths.greaterThan( uint( 0 ) ),
+									sunEmissionPdf( bdpt, sunParams, guidedDiscPdf( bdpt, bdpt.guideTexture, direction, origin ) ), float( 0.0 ) );
+								sunW.assign( strategyWeight( bdpt.strategyView, STRATEGY.HIT,
+									misWeight( float( 0.0 ), mis( directPdfW ).mul( subpath.dVCM ).add( mis( emissionPdfW ).mul( subpath.dVC ) ) ) ) );
+
+							} );
+
+						} else {
+
+							If( isBackdropView.not().and( flags.bitAnd( uint( RAY_FLAG.SUN_NEE ) ).notEqual( uint( 0 ) ) ), () => {
+
+								sunW.assign( powerHeuristic( { pdf1: readRayPdf( rayBufferRW, rayID ), pdf2: float( 1.0 ).div( sunParams.y ) } ) );
+
+							} );
+
+						}
 
-						} );
 						const vertex = max( bounceIndex.sub( 1 ), int( 0 ) );
 						const sunScale = select( isBackdropView, backgroundIntensity,
 							sunW.mul( select( vertex.greaterThan( int( 0 ) ), globalIlluminationIntensity, float( 1.0 ) ) ) );
@@ -553,7 +662,7 @@ export function buildShadeKernel( params ) {
 			// per pixel → OIDN sees structure tracking the refracted view); depth kept at the primary hit.
 			// AUX_LOCKED-clear alone means "never committed" — the old black-probe is redundant. A direct
 			// backdrop (REDIRECTED clear) keeps Generate's black/far default (regression-safe sky guide).
-			If( auxOn
+			if ( aux ) If( aux
 				.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) )
 				.and( flags.bitAnd( uint( RAY_FLAG.REDIRECTED ) ).notEqual( uint( 0 ) ) ), () => {
 
@@ -568,8 +677,110 @@ export function buildShadeKernel( params ) {
 
 		} );
 
+		// On the triangle's plane: Extend stores the distance to it (ExtendKernel).
 		const hitPoint = origin.add( direction.mul( hitDist ) ).toVar();
+		// Vertex merging: a merge here, weighed in every sum this vertex ends or scatters.
+		if ( bdpt?.merging ) subpath.vm = mergeVmAt( bdpt, hitPoint ).toVar();
 		const N = normalize( hitNormal ).toVar();
+		// The hit record's facet is 11-bit; light tracing's and connections' grazing geometry terms need it exact.
+		const exactFacetN = bdpt ? hitFacet( {
+			triangleBuffer, bvhBuffer, triIdx: int( hitTriIdx ), instanceLeaf: hitInstance, hitPoint,
+			smoothNormal: N, viewDir: direction.negate(), didHit: tslBool( true ), liftEnabled: tslBool( false ),
+		} ).faceN : null;
+
+		// Where a lamp's light path first lands: its falloff and a directional gobo apply here.
+		const lampLanding = bdpt ? { source: int( - 1 ).toVar(), dist: float( 0.0 ).toVar() } : null;
+		const landLampPath = ( dist ) => {
+
+			const start = readLightOrigin( hitBufferRW, rayID );
+			const source = int( - 1 ).sub( start.triangle ).toVar();
+			If( start.triangle.lessThan( int( 0 ) ).and( source.greaterThanEqual( int( SOURCE.LAMPS ) ) ), () => {
+
+				const type = sourceLampType( bdpt, source ).toVar();
+				const index = sourceLampIndex( bdpt, source, type ).toVar();
+				If( type.equal( int( LIGHT_TYPE_DIRECTIONAL ) ), () => {
+
+					throughput.mulAssign( sampleDirectionalGoboMask( DirectionalLight.wrap( getDirectionalLight( directionalLightsBuffer, index ) ), hitPoint ) );
+
+				} ).ElseIf( type.equal( int( LIGHT_TYPE_POINT ) ), () => {
+
+					const light = PointLight.wrap( getPointLight( pointLightsBuffer, index ) );
+					throughput.mulAssign( getDistanceAttenuation( { lightDistance: dist, cutoffDistance: light.distance, decayExponent: light.decay } ).mul( dist.mul( dist ) ) );
+
+				} ).ElseIf( type.equal( int( LIGHT_TYPE_SPOT ) ), () => {
+
+					const light = SpotLight.wrap( getSpotLight( spotLightsBuffer, index ) );
+					throughput.mulAssign( getDistanceAttenuation( { lightDistance: dist, cutoffDistance: light.distance, decayExponent: light.decay } ).mul( dist.mul( dist ) ) );
+
+				} );
+				lampLanding.source.assign( source );
+				lampLanding.dist.assign( dist );
+
+			} );
+
+		};
+
+		// Georgiev (43) for the rect light a continuation reaches. Lamps are not geometry, so the new ray is tested
+		// here, after any scatter, with glass blocking as it does NEE's. `nearPick` gives NEE's pick of it here.
+		const bidirectionalAreaHit = ( from, dir, nearPick ) => {
+
+			const nearestT = float( 1e30 ).toVar();
+			const nearest = int( - 1 ).toVar();
+			Loop( { start: int( 0 ), end: numAreaLights, type: 'int', condition: '<' }, ( { i } ) => {
+
+				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, i ) );
+				If( light.intensity.greaterThan( 0.0 ), () => {
+
+					const t = intersectAreaLight( light, hitPoint, dir ).toVar();
+					If( t.greaterThan( 0.0 ).and( t.lessThan( nearestT ) ), () => {
+
+						nearestT.assign( t );
+						nearest.assign( i );
+
+					} );
+
+				} );
+
+			} );
+
+			If( nearest.greaterThanEqual( int( 0 ) ), () => {
+
+				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, nearest ) );
+				const cosLight = dot( dir, light.normal ).negate().toVar();
+				const toLight = hitPoint.add( dir.mul( nearestT ) ).sub( from ).toVar();
+				const len = length( toLight ).toVar();
+				const visibility = traceShadowRayRefractiveOpaque(
+					from, toLight.div( len ), len.mul( SHADOW_END ), traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer,
+				).toVar();
+
+				If( visibility.greaterThan( 0.0 ).and( cosLight.greaterThan( 0.0 ) ), () => {
+
+					const arrived = { dVCM: subpath.dVCM.toVar(), dVC: subpath.dVC.toVar() };
+					misOnHit( arrived, nearestT, cosLight );
+					const neePdfA = nearPick
+						? nearPick( light ).mul( areaLightDirectPdfW( light, hitPoint, nearestT, cosLight ) ).mul( cosLight ).div( max( nearestT.mul( nearestT ), 1e-30 ) )
+						: float( 0.0 );
+					const emissionPdf = select( bdpt.lightPaths.greaterThan( uint( 0 ) ),
+						sourcePick( bdpt, lampSource( bdpt, int( LIGHT_TYPE_AREA ), nearest ) ).div( max( light.area, 1e-20 ) ).mul( cosLight ).div( Math.PI ), float( 0.0 ) );
+					const weight = strategyWeight( bdpt.strategyView, STRATEGY.HIT,
+						misWeight( float( 0.0 ), mis( neePdfA ).mul( arrived.dVCM ).add( mis( emissionPdf ).mul( arrived.dVC ) ) ) );
+
+					currentRadiance.assign( vec4(
+						currentRadiance.xyz.add(
+							regularizePathContribution(
+								areaLightRadiance( light ).mul( areaLightSpreadAttenuation( cosLight, light.spread ) ).mul( throughput ).mul( visibility ).mul( weight )
+									.mul( select( bounceIndex.greaterThan( 0 ), globalIlluminationIntensity, float( 1.0 ) ) ),
+								float( bounceIndex ), fireflyThreshold, int( accumFrame ),
+							),
+						),
+						currentRadiance.w,
+					) );
+
+				} );
+
+			} );
+
+		};
 
 		// medium stack read once here; reused by the transparency block below
 		const medStack = readMediumStack( rayBufferRW, rayID );
@@ -585,23 +796,33 @@ export function buildShadeKernel( params ) {
 		If( mediumStackDepth.greaterThan( 0 ), () => {
 
 			const mSigmaA = readMediumSigmaA( rayBufferRW, rayID ).toVar();
-			const sssMed = readSSSMedium( rayBufferRW, rayID );
-			const mSigmaS = sssMed.sigmaS.toVar();
-			const mG = sssMed.g.toVar();
-
-			If( max( max( mSigmaS.x, mSigmaS.y ), mSigmaS.z ).lessThanEqual( 0.0 ), () => {
+			const absorb = () => {
 
 				// glass: Beer-Lambert absorption
 				const beer = exp( mSigmaA.mul( hitDist ).negate() ).toVar();
 				throughput.mulAssign( beer );
 				// DDFA: colored-glass volume tints the deferred aux guide by the same absorption.
-				If( auxOn.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
+				if ( aux ) If( aux.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
 
 					featCarry.mulAssign( beer );
 
 				} );
 
-			} ).Else( () => {
+			};
+
+			// Without subsurface materials every medium is glass (scattering 0).
+			if ( ! layers.subsurface ) {
+
+				absorb();
+				return;
+
+			}
+
+			const sssMed = readSSSMedium( rayBufferRW, rayID );
+			const mSigmaS = sssMed.sigmaS.toVar();
+			const mG = sssMed.g.toVar();
+
+			If( max( max( mSigmaS.x, mSigmaS.y ), mSigmaS.z ).lessThanEqual( 0.0 ), absorb ).Else( () => {
 
 				// subsurface: chromatic collision-distance sampling
 				const mSigmaT = mSigmaA.add( mSigmaS );
@@ -628,7 +849,7 @@ export function buildShadeKernel( params ) {
 
 						writeRayRadiance( rayBufferRW, rayID, currentRadiance );
 						writeRayDirFlags( rayBufferRW, rayID, direction, flags.bitAnd( uint( ~ RAY_FLAG.ACTIVE ) ) );
-						writeRngState( hitBufferRW, rayID, rngState );
+						persistRng();
 						Return();
 
 					} );
@@ -645,7 +866,7 @@ export function buildShadeKernel( params ) {
 					// fires the next hit's env/emissive MIS, down-weighting SSS-then-env/emitter views.
 					writeRayThroughputPdf( rayBufferRW, rayID, throughput, readRayPdf( rayBufferRW, rayID ) );
 					writeRayRadiance( rayBufferRW, rayID, currentRadiance );
-					writeRngState( hitBufferRW, rayID, rngState );
+					persistRng();
 					Return();
 
 				} );
@@ -659,6 +880,33 @@ export function buildShadeKernel( params ) {
 		const material = RayTracingMaterial.wrap(
 			getMaterial( int( hitMatIdx ), materialBuffer )
 		).toVar();
+		if ( ! diffuseTransmission || bdpt ) {
+
+			material.diffuseTransmission.assign( 0.0 );
+			material.diffuseTransmissionMapIndex.assign( int( - 1 ) );
+			material.diffuseTransmissionColorMapIndex.assign( int( - 1 ) );
+
+		}
+
+		// A layer no material has is 0 in every material; saying so lets the compiler fold what still reads it.
+		for ( const layer of [ 'clearcoat', 'sheen', 'iridescence', 'anisotropy', 'subsurface', 'dispersion' ] ) {
+
+			if ( ! layers[ layer ] ) material[ layer ].assign( 0.0 );
+
+		}
+
+		// The segment past the last bounce is traced only for the light it hits: an opaque surface that does not glow
+		// ends it before any texture is read (emission is factor × map, so a zero factor is zero).
+		If( flags.bitAnd( uint( RAY_FLAG.EMISSION_ONLY ) ).notEqual( uint( 0 ) )
+			.and( material.alphaMode.equal( int( 0 ) ) ).and( material.transmission.lessThanEqual( 0.0 ) ).and( material.subsurface.lessThanEqual( 0.0 ) )
+			.and( max( max( material.emissive.x, material.emissive.y ), material.emissive.z ).mul( material.emissiveIntensity ).lessThanEqual( 0.0 ) ), () => {
+
+			writeRayRadiance( rayBufferRW, rayID, currentRadiance );
+			writeRayDirFlags( rayBufferRW, rayID, direction, flags.bitAnd( uint( ~ RAY_FLAG.ACTIVE ) ) );
+			persistRng();
+			Return();
+
+		} );
 
 		// displacement: analytical ray-height marching refines hitPoint/UV/normal; no-op without a map
 		const samplingUV = hitUV.toVar();
@@ -715,7 +963,7 @@ export function buildShadeKernel( params ) {
 		const extUV = getTransformedUV( { uv: samplingUV, transform: material.albedoTransform } ).toVar();
 
 		// Fold the anisotropy texture (if any) into the scalar anisotropy/rotation used by the BRDF
-		If( material.anisotropyMapIndex.greaterThanEqual( int( 0 ) ), () => {
+		if ( layers.anisotropy ) If( material.anisotropyMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
 			const aniso = processAnisotropyMap( material, extUV ).toVar();
 			material.anisotropy.assign( aniso.x );
@@ -736,6 +984,8 @@ export function buildShadeKernel( params ) {
 		material.iridescenceThicknessRange.assign( vec2( material.iridescenceThicknessRange.x, extMaps.iridescenceThickness ) );
 		material.specularIntensity.assign( extMaps.specularIntensity );
 		material.specularColor.assign( extMaps.specularColor );
+		material.diffuseTransmission.assign( extMaps.diffuseTransmission );
+		material.diffuseTransmissionColor.assign( extMaps.diffuseTransmissionColor );
 
 		// Below the floor the GGX peak is past f32, so a plain reflector reflects exactly: roughness 0
 		// is the delta-lobe marker the sampler and evaluator read. The other lobes keep the floor.
@@ -769,19 +1019,19 @@ export function buildShadeKernel( params ) {
 		const metal = material.metalness.toVar();
 		const trans = material.transmission.toVar();
 		const roughFrac = smoothstep( float( 0.0 ), float( 0.15 ), rawRough ).toVar();
-		const auxCommit = clamp(
+		const auxCommit = aux ? clamp(
 			float( 1.0 ).sub( metal ).mul( float( 1.0 ).sub( trans ) )
 				.add( roughFrac.mul( metal.mul( float( 1.0 ).sub( trans ) ).add( trans ) ) ),
 			0.0, 1.0,
-		).greaterThanEqual( float( 0.25 ) ).toVar();
-		const featPrefix = featCarry.toVar();
+		).greaterThanEqual( float( 0.25 ) ).toVar() : null;
+		const featPrefix = aux ? featCarry.toVar() : null;
 
 		// DDFA terminal fallback: a ray dying while still deferring (e.g. a mirror maze) commits its last
 		// surface instead of leaving a black guide OIDN would demod-amplify.
 		// Plain JS inliner, not an Fn — it closes over albedo/featPrefix/flags .toVar()s.
 		const commitDeferredAux = ( normal ) => {
 
-			If( auxOn.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
+			if ( aux ) If( aux.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
 
 				const primaryDepth = gbDecodeNormalDepth( readGBuffer( gBufferRW, pixelIndex ) ).w;
 				writeGBuffer( gBufferRW, pixelIndex, normal, primaryDepth, clamp( albedo.mul( featPrefix ), vec3( 0.0 ), vec3( 1.0 ) ) );
@@ -795,14 +1045,14 @@ export function buildShadeKernel( params ) {
 
 			writeRayRadiance( rayBufferRW, rayID, currentRadiance );
 			writeRayDirFlags( rayBufferRW, rayID, direction, flags.bitAnd( uint( ~ RAY_FLAG.ACTIVE ) ) );
-			writeRngState( hitBufferRW, rayID, rngState );
+			persistRng();
 
 		};
 
 		// first-hit MRT data (bounce 0 only): write the primary DEPTH now with the default normal/albedo.
 		// The real normal/albedo are committed by the DDFA decision blocks below (which re-pack this depth);
 		// they may defer through smooth glass/mirror and commit at the first diffuse-enough surface or the env.
-		If( bounceIndex.equal( 0 ).and( auxOn ), () => {
+		if ( aux ) If( bounceIndex.equal( 0 ).and( aux ), () => {
 
 			const linearDepth = computeNDCDepth( {
 				worldPos: hitPoint,
@@ -847,14 +1097,14 @@ export function buildShadeKernel( params ) {
 		// ─── DDFA aux decision at a transmissive / alpha / SSS interaction. Runs for BOTH the continuing and
 		// the BLEND fall-through paths, so it sits before If(continueRay). If/ElseIf chaining so BLEND wins
 		// over the transmission branch (fixes the BLEND-glass per-frame flicker + the BLEND+transmission case). ───
-		If( auxOn.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
+		if ( aux ) If( aux.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
 
 			const primaryDepth = gbDecodeNormalDepth( readGBuffer( gBufferRW, pixelIndex ) ).w;
 			// N here is the mapped normal — faceforward it (a ray exiting glass sees a back-facing N).
 			const Nff = select( dot( N, direction.negate() ).lessThan( 0.0 ), N.negate(), N ).toVar();
 			const auxAlbedo = clamp( albedo.mul( featPrefix ), vec3( 0.0 ), vec3( 1.0 ) ).toVar();
 
-			If( material.alphaMode.equal( int( 2 ) ), () => {
+			let auxCases = If( material.alphaMode.equal( int( 2 ) ), () => {
 
 				// BLEND: deterministic own-surface commit on BOTH stochastic skip + shade frames (no flicker).
 				writeGBuffer( gBufferRW, pixelIndex, Nff, primaryDepth, auxAlbedo );
@@ -864,13 +1114,15 @@ export function buildShadeKernel( params ) {
 
 				// MASK cutout passthrough: keep deferring, tint unchanged (backdrop through the hole commits later).
 
-			} ).ElseIf( interaction.isSubsurface, () => {
+			} );
+			if ( layers.subsurface ) auxCases = auxCases.ElseIf( interaction.isSubsurface, () => {
 
 				// SSS boundary: force-commit the skin surface as diffuse.
 				writeGBuffer( gBufferRW, pixelIndex, Nff, primaryDepth, auxAlbedo );
 				flags.assign( flags.bitOr( uint( RAY_FLAG.AUX_LOCKED ) ) );
 
-			} ).ElseIf( interaction.isTransmissive, () => {
+			} );
+			auxCases.ElseIf( interaction.isTransmissive, () => {
 
 				If( auxCommit.or( material.dispersion.greaterThan( 0.0 ) ), () => {
 
@@ -941,7 +1193,7 @@ export function buildShadeKernel( params ) {
 			} );
 
 			// subsurface boundary: push the scattering medium on enter, pop on exit; free bounce
-			If( interaction.isSubsurface.and( interaction.didReflect.not() ), () => {
+			if ( layers.subsurface ) If( interaction.isSubsurface.and( interaction.didReflect.not() ), () => {
 
 				If( interaction.entering, () => {
 
@@ -994,6 +1246,15 @@ export function buildShadeKernel( params ) {
 
 			throughput.mulAssign( interaction.throughput );
 
+			// Importance, unlike radiance, is not rescaled by refraction.
+			if ( bdpt ) If( isLight.and( interaction.isTransmissive.or( interaction.isSubsurface ) ).and( interaction.didReflect.not() ), () => {
+
+				const n1 = select( interaction.entering, currentMediumIOR, material.ior );
+				const n2 = select( interaction.entering, material.ior, previousMediumIOR );
+				throughput.mulAssign( n2.mul( n2 ).div( max( n1.mul( n1 ), EPSILON ) ) );
+
+			} );
+
 			// Off the side of the facet the new ray leaves on: reflection stays, transmission and alpha skip cross.
 			const Ng = unpackHitFacet( readHitFacet( hitBufferRW, rayID ) ).faceN;
 			const crossesFacet = dot( Ng, interaction.direction ).lessThan( 0.0 ).toVar();
@@ -1010,6 +1271,25 @@ export function buildShadeKernel( params ) {
 				flags.assign( flags.sub( flags.bitAnd( uint( RAY_FLAG.UNDER_SURFACE ) ) ).bitOr( uint( RAY_FLAG.REDIRECTED ) )
 					.bitOr( select( underSurface, uint( RAY_FLAG.UNDER_SURFACE ), uint( 0 ) ) ) );
 
+				// Not connectible; an alpha skip is no vertex at all.
+				if ( bdpt ) {
+
+					misOnHit( subpath, hitDist.add( readMisRayT( rayBufferRW, rayID ) ), abs( dot( exactFacetN, direction ) ) );
+					misOnSpecular( subpath, abs( dot( exactFacetN, interaction.direction ) ) );
+					If( flags.bitAnd( uint( RAY_FLAG.LIGHT_EMITTED ) ).notEqual( uint( 0 ) ), () => {
+
+						landLampPath( hitDist.add( readMisRayT( rayBufferRW, rayID ) ) );
+
+					} );
+					flags.assign( flags.sub( flags.bitAnd( uint( RAY_FLAG.LIGHT_EMITTED ) ) ) );
+					If( isLight.not().and( numAreaLights.greaterThan( int( 0 ) ) ), () => {
+
+						bidirectionalAreaHit( newOrigin, interaction.direction, null );
+
+					} );
+
+				}
+
 			} ).Else( () => {
 
 				// Alpha passthrough: charge the guard. N is faceforwarded for the aux commit (a ray
@@ -1037,12 +1317,12 @@ export function buildShadeKernel( params ) {
 			writeMediumStack( rayBufferRW, rayID, uint( mediumStackDepth ), uint( transTraversals ), mediumStack_ior_1, mediumStack_ior_2, mediumStack_ior_3, uint( pathWavelength.add( 0.5 ) ) );
 			// DDFA: persist the (possibly tinted) see-through throughput for the next bounce. MUST run after
 			// the writeMediumSigmaA above — both RMW slot 5 (sigmaA.xyz / featTP.w). Gated AUX_LOCKED-clear.
-			If( auxOn.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
+			if ( aux ) If( aux.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
 
 				writeFeatureThroughput( rayBufferRW, rayID, featCarry );
 
 			} );
-			writeRngState( hitBufferRW, rayID, rngState );
+			persistRng();
 			Return();
 
 		} );
@@ -1055,18 +1335,59 @@ export function buildShadeKernel( params ) {
 		// so any later env-escape is redirected light, not the direct backdrop). Single positive bitOr.
 		flags.assign( flags.bitOr( uint( RAY_FLAG.HAS_HIT_OPAQUE | RAY_FLAG.REDIRECTED ) ) );
 
+		if ( bdpt ) {
+
+			const arrivalDist = hitDist.add( readMisRayT( rayBufferRW, rayID ) ).toVar();
+
+			// A light path's NEE density needs its first vertex.
+			If( flags.bitAnd( uint( RAY_FLAG.LIGHT_EMITTED ) ).notEqual( uint( 0 ) ), () => {
+
+				const start = readLightOrigin( hitBufferRW, rayID );
+				const neePdfA = float( 0.0 ).toVar();
+				If( start.triangle.lessThan( int( 0 ) ), () => {
+
+					// A light at infinity has no distance to square. The sun's NEE density is in already; a lamp's
+					// depends on this vertex's material, below.
+					const source = int( - 1 ).sub( start.triangle );
+					neePdfA.assign( select( source.lessThan( int( SOURCE.LAMPS ) ).or( sourceLampType( bdpt, source ).equal( int( LIGHT_TYPE_DIRECTIONAL ) ) ),
+						float( 1.0 ).div( max( arrivalDist.mul( arrivalDist ), 1e-30 ) ), float( 1.0 ) ) );
+					landLampPath( arrivalDist );
+
+				} ).Else( () => {
+
+					// NEE draws a triangle on every side it emits from, as the light path left it.
+					if ( useEmissiveNEE ) If( enableEmissiveTriangleSampling.equal( int( 1 ) )
+						.and( emissiveTriangleCount.greaterThan( int( 0 ) ) ), () => {
+
+						neePdfA.assign( emissiveNEEPdf( start.triangle, arrivalDist, direction.negate(), hitPoint, start.instanceLeaf )
+							.mul( abs( start.cosLight ) ).div( arrivalDist.mul( arrivalDist ) ) );
+
+					} );
+
+				} );
+				subpath.dVCM.mulAssign( mis( neePdfA ) );
+				flags.assign( flags.sub( flags.bitAnd( uint( RAY_FLAG.LIGHT_EMITTED ) ) ) );
+
+			} );
+
+			misOnHit( subpath, arrivalDist, abs( dot( exactFacetN, direction ) ) );
+
+		}
+
 		const emissive = matSamples.emissive.toVar();
-		// NEE samples only a single-sided emitter's lit side, so from behind (bounce rays) it is a dark occluder.
-		If( isBackdropView.not().and( length( emissive ).greaterThan( 0.0 ) ), () => {
+		// NEE samples only a single-sided emitter's lit side, so from behind (bounce rays) it is a dark occluder. The side
+		// is the facet's, as NEE's: the interpolated normal turns away near a coarse mesh's silhouette.
+		If( cameraOnly( isBackdropView.not().and( length( emissive ).greaterThan( 0.0 ) ) ), () => {
 
-			If( sideAccepts( triangleSide( triangleRow( triangleBuffer, int( hitTriIdx ), 4 ).z ), dot( direction, hitNormal ) ).not(), () => {
+			If( sideAccepts( triangleSide( triangleRow( triangleBuffer, int( hitTriIdx ), 4 ).z ),
+				dot( direction, windingNormal( triangleBuffer, bvhBuffer, int( hitTriIdx ), hitInstance ) ) ).not(), () => {
 
 				emissive.assign( vec3( 0.0 ) );
 
 			} );
 
 		} );
-		If( length( emissive ).greaterThan( 0.0 ), () => {
+		If( cameraOnly( length( emissive ).greaterThan( 0.0 ) ), () => {
 
 			// Key on backdrop-view (not bounceIndex>0) so an emitter seen DIRECTLY through an alpha-cutout hole
 			// renders at full intensity (1.0) like a direct view, consistent with env-through-hole — instead of
@@ -1078,7 +1399,34 @@ export function buildShadeKernel( params ) {
 			// two estimators. Without it emissive geometry / area lights double-count (~2x bright + noisier).
 			// Primary hits keep weight 1.0 (the wavefront's bounce-0 stored pdf is the Generate init, not a NEE pdf).
 			const emissiveMISWeight = float( 1.0 ).toVar();
-			if ( useEmissiveNEE ) {
+			if ( bdpt ) {
+
+				// Georgiev (43): NEE from the previous vertex, and every light subpath strategy.
+				If( isBackdropView.not(), () => {
+
+					const misT = readMisRayT( rayBufferRW, rayID ).toVar();
+					const misDist = hitDist.add( misT ).toVar();
+					const tri = TriangleData.wrap( fetchTriangleData( int( hitTriIdx ), triangleBuffer, bvhBuffer, hitInstance ) );
+					const cosToward = dot( direction.negate(), normalize( cross( tri.v1.sub( tri.v0 ), tri.v2.sub( tri.v0 ) ) ) ).toVar();
+					const areaPdf = emitterAreaPdf( material.emissive.mul( material.emissiveIntensity ), emissiveTotalPower ).toVar();
+					const emissionPdf = select( bdpt.lightPaths.greaterThan( uint( 0 ) ),
+						areaPdf.mul( float( 1.0 ).sub( bdpt.sunPick ) ).mul( emitterSideProbability( triangleSide( triangleRow( triangleBuffer, int( hitTriIdx ), 4 ).z ), cosToward ) )
+							.mul( abs( cosToward ) ).div( Math.PI ),
+						float( 0.0 ) );
+					const neePdfA = float( 0.0 ).toVar();
+					if ( useEmissiveNEE ) If( enableEmissiveTriangleSampling.equal( int( 1 ) ).and( emissiveTriangleCount.greaterThan( int( 0 ) ) )
+						.and( areaPdf.greaterThan( 0.0 ) ), () => {
+
+						neePdfA.assign( emissiveNEEPdf( int( hitTriIdx ), misDist, direction, origin.sub( direction.mul( misT ) ), hitInstance )
+							.mul( abs( cosToward ) ).div( misDist.mul( misDist ) ) );
+
+					} );
+					emissiveMISWeight.assign( strategyWeight( bdpt.strategyView, STRATEGY.HIT,
+						misWeight( float( 0.0 ), mis( neePdfA ).mul( subpath.dVCM ).add( mis( emissionPdf ).mul( subpath.dVC ) ) ) ) );
+
+				} );
+
+			} else if ( useEmissiveNEE ) {
 
 				If( enableEmissiveTriangleSampling.equal( int( 1 ) )
 					.and( emissiveTriangleCount.greaterThan( int( 0 ) ) )
@@ -1133,6 +1481,13 @@ export function buildShadeKernel( params ) {
 
 		} );
 
+		If( flags.bitAnd( uint( RAY_FLAG.EMISSION_ONLY ) ).notEqual( uint( 0 ) ), () => {
+
+			terminatePath();
+			Return();
+
+		} );
+
 		// BRDF sample (needed by both direct + indirect)
 		const V = direction.negate().toVar();
 		// face-forwarded geometric normal: horizon guard for NEE and the bounce continuation
@@ -1146,6 +1501,13 @@ export function buildShadeKernel( params ) {
 			hitPoint, offsetNormal: facetN, lift: terminatorLift, faceN: facetN, smoothN: NgeoFF, L,
 			cutoff: shadowTerminatorOffset,
 		} );
+		// Light from behind a surface that passes light through diffusely: its rays leave from the other side.
+		// Compiled in only with the lobe (see `diffuseTransmission`).
+		const transmitting = diffuseTransmission && ! bdpt;
+		const transmitsDiffusely = transmitting ? material.diffuseTransmission.greaterThan( 0.0 ) : tslBool( false );
+		const throughSurface = L => ( transmitting ? transmitsDiffusely.and( dot( N, L ).lessThan( 0.0 ) ).and( dot( L, NgeoFF ).lessThan( 0.0 ) ) : tslBool( false ) );
+		const backOrigin = transmitting ? offsetRayOrigin( hitPoint, facetN.negate() ) : null;
+		const originFor = ( L, front ) => ( transmitting ? select( throughSurface( L ), backOrigin, front ) : front );
 
 		// 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
@@ -1164,7 +1526,7 @@ export function buildShadeKernel( params ) {
 		// ─── 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). ───
-		If( auxOn.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
+		if ( aux ) If( aux.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
 
 			const primaryDepth = gbDecodeNormalDepth( readGBuffer( gBufferRW, pixelIndex ) ).w;
 			If( auxCommit, () => {
@@ -1211,8 +1573,28 @@ export function buildShadeKernel( params ) {
 		const brdfPdf = float( 0.0 ).toVar();
 		const brdfIsTransmission = tslBool( false ).toVar();
 		const brdfColorWeight = vec3( 1.0 ).toVar();
+		const brdfIsDiffuseTransmission = tslBool( false ).toVar();
+
+		const sampleLobes = () => {
+
+			const bs = DirectionSample.wrap( generateSampledDirection(
+				V, N, material, xi, lobeXi, rngState,
+				_pixelCoord, resolution, frame, dimBase,
+				mc,
+				false, emptyWeights,
+				false, emptyCache,
+			) );
+			brdfDir.assign( bs.direction );
+			brdfValue.assign( bs.value );
+			brdfPdf.assign( bs.pdf );
+			brdfIsTransmission.assign( bs.isTransmission );
+			brdfColorWeight.assign( bs.colorWeight );
+			brdfIsDiffuseTransmission.assign( bs.isDiffuseTransmission );
+
+		};
 
-		If( material.clearcoat.greaterThan( 0.0 ), () => {
+		if ( ! layers.clearcoat ) sampleLobes();
+		else If( material.clearcoat.greaterThan( 0.0 ), () => {
 
 			const ccRay = Ray( { origin, direction } );
 			const ccHit = HitInfo( {
@@ -1227,25 +1609,89 @@ export function buildShadeKernel( params ) {
 			brdfDir.assign( ccResult.L );
 			brdfValue.assign( ccResult.brdf );
 			brdfPdf.assign( ccResult.pdf );
+			brdfIsDiffuseTransmission.assign( ccResult.isDiffuseTransmission );
 
-		} ).Else( () => {
+		} ).Else( sampleLobes );
 
-			const bs = DirectionSample.wrap( generateSampledDirection(
-				V, N, material, xi, lobeXi, rngState,
-				_pixelCoord, resolution, frame, dimBase,
-				mc,
-				false, emptyWeights,
-				false, emptyCache,
-			) );
-			brdfDir.assign( bs.direction );
-			brdfValue.assign( bs.value );
-			brdfPdf.assign( bs.pdf );
-			brdfIsTransmission.assign( bs.isTransmission );
-			brdfColorWeight.assign( bs.colorWeight );
+		const emitterCandidate = () => {
 
-		} );
+			const value = vec3( 0.0 ).toVar();
+			const from = vec3( 0.0 ).toVar();
+			const dir = vec3( 0.0, 1.0, 0.0 ).toVar();
+			const dist = float( 0.0 ).toVar();
+			if ( ! useEmissiveNEE ) return [ value, from, dir, dist ];
+
+			If( enableEmissiveTriangleSampling.equal( int( 1 ) ).and( emissiveTriangleCount.greaterThan( int( 0 ) ) ), () => {
+
+				const position = vec3( 0.0 ).toVar();
+				const direction = vec3( 0.0, 1.0, 0.0 ).toVar();
+				const emission = vec3( 0.0 ).toVar();
+				const pdf = float( 0.0 ).toVar();
+				const valid = tslBool( false ).toVar();
+				const take = ( sample ) => {
+
+					const e = EmissiveSample.wrap( sample );
+					position.assign( e.position );
+					direction.assign( e.direction );
+					emission.assign( e.emission );
+					pdf.assign( e.pdf );
+					valid.assign( e.valid );
+
+				};
+
+				If( lightBVHNodeCount.greaterThan( int( 0 ) ), () => {
+
+					take( sampleLightBVHTriangle(
+						hitPoint, N, rngState, _pixelCoord, resolution, frame, dimBase,
+						lightBuffer, lightBuffer, emissiveVec4Offset, triangleBuffer, bvhBuffer, transmitsDiffusely,
+					) );
+
+				} ).Else( () => {
+
+					take( sampleEmissiveTriangle(
+						hitPoint, N, rngState, _pixelCoord, resolution, frame, dimBase,
+						lightBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, triangleBuffer, bvhBuffer, transmitsDiffusely,
+					) );
+
+				} );
+
+				If( valid.and( pdf.greaterThan( 0.0 ) ), () => {
+
+					const back = throughSurface( direction ).toVar();
+					const NoL = transmitting ? abs( dot( N, direction ) ) : max( float( 0.0 ), dot( N, direction ) );
+					const inFront = NoL.greaterThan( 0.0 ).and( dot( N, direction ).greaterThan( 0.0 ) )
+						.and( dot( direction, NgeoFF ).greaterThan( 0.0 ) );
+
+					If( transmitting ? back.or( inFront ) : inFront, () => {
 
-		const directLight = DirectLightingDual.wrap( calculateDirectLightingUnified(
+						from.assign( originFor( direction, lightShadowOrigin( direction ) ) );
+						const toSample = position.sub( from ).toVar();
+						const span = length( toSample ).toVar();
+						dir.assign( toSample.div( span ) );
+						dist.assign( span.mul( SHADOW_END ) );
+
+						const bPdf = calculateMaterialPDF( V, direction, N, material );
+						const misW = select( bPdf.greaterThan( 0.0 ), powerHeuristic( { pdf1: pdf, pdf2: bPdf } ), float( 1.0 ) );
+						value.assign( emission.mul( evaluateMaterialResponse( V, direction, N, material ) ).mul( NoL )
+							.div( pdf ).mul( emissiveBoost ).mul( misW ) );
+
+					} );
+
+				} );
+
+			} );
+
+			return [ value, from, dir, dist ];
+
+		};
+
+		const pickArgs = picksLights
+			? [ ...emitterCandidate(), counters, visibilityCell( hitPoint, NgeoFF, vec3( cameraWorldMatrix[ 3 ] ) ) ]
+			: [];
+		const directLightingFn = picksLights
+			? calculateDirectLightingPicked( transmitting, shadowRays )
+			: ( transmitting ? calculateDirectLightingThroughSurfaces : calculateDirectLightingUnified );
+		const directLighting = () => DirectLightingDual.wrap( directLightingFn(
 			hitPoint, N, NgeoFF, material, V,
 			brdfDir, brdfPdf, brdfValue,
 			bounceIndex, rngState,
@@ -1257,18 +1703,21 @@ export function buildShadeKernel( params ) {
 			bvhBuffer, triangleBuffer, materialBuffer,
 			envTexture, environmentIntensity, envMatrix,
 			envCDFTexture,
-			envTotalSum, envCompensationDelta, envResolution,
+			envTotalSum, envResolution,
 			enableEnvironmentLight,
 			tslBool( false ), // wantUnoccluded: false on real surfaces — dead-codes the unoccluded sum
 			terminatorLift, facetN, shadowTerminatorOffset,
 			hasSun, sunDirection, sunRadiance, sunParams,
-		) ).shadowed.toVar();
+			...pickArgs,
+		) ).shadowed;
+		// Bidirectional mode samples every light itself, below.
+		const directLight = bdpt ? null : directLighting().toVar();
 
 		const giScale = select( bounceIndex.greaterThan( 0 ), globalIlluminationIntensity, float( 1.0 ) );
 		// Per-term firefly suppression (megakernel parity: PathTracerCore.js:1164) — wrap the direct-light add
 		// like every other contribution (env/emissive-hit/emissive-NEE). This replaces the cumulative catch-all
 		// that re-suppressed already-wrapped terms + prior-bounce radiance — suppress(a+b) ≠ suppress(a)+suppress(b) (gap #13).
-		currentRadiance.assign( vec4(
+		if ( ! bdpt ) currentRadiance.assign( vec4(
 			currentRadiance.xyz.add(
 				regularizePathContribution(
 					throughput.mul( directLight ).mul( giScale ),
@@ -1278,8 +1727,319 @@ export function buildShadeKernel( params ) {
 			currentRadiance.w
 		) );
 
+		// Georgiev (44)-(45). Glass blocks the shadow ray: light through it arrives on the light subpaths.
+		const bidirectionalEmissiveNEE = () => {
+
+			const position = vec3( 0.0 ).toVar();
+			const lightDir = vec3( 0.0 ).toVar();
+			const emission = vec3( 0.0 ).toVar();
+			const lightPdf = float( 0.0 ).toVar();
+			const valid = tslBool( false ).toVar();
+			const lightTriangle = int( 0 ).toVar();
+			const windingN = vec3( 0.0 ).toVar();
+			const take = ( sample ) => {
+
+				const e = EmissiveSampleIndexed.wrap( sample );
+				position.assign( e.position );
+				lightDir.assign( e.direction );
+				emission.assign( e.emission );
+				lightPdf.assign( e.pdf );
+				valid.assign( e.valid );
+				lightTriangle.assign( e.triangleIndex );
+				windingN.assign( e.faceNormal );
+
+			};
+
+			If( lightBVHNodeCount.greaterThan( int( 0 ) ), () => {
+
+				take( sampleLightBVHTriangleIndexed(
+					hitPoint, N, rngState, _pixelCoord, resolution, frame, dimBase,
+					lightBuffer, lightBuffer, emissiveVec4Offset, triangleBuffer, bvhBuffer, tslBool( false ),
+				) );
+
+			} ).Else( () => {
+
+				take( sampleEmissiveTriangleIndexed(
+					hitPoint, N, rngState, _pixelCoord, resolution, frame, dimBase,
+					lightBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, triangleBuffer, bvhBuffer, tslBool( false ),
+				) );
+
+			} );
+
+			const NoL = max( float( 0.0 ), dot( N, lightDir ) ).toVar();
+			const side = triangleSide( triangleRow( triangleBuffer, lightTriangle, 4 ).z ).toVar();
+			If( valid.and( lightPdf.greaterThan( 0.0 ) ).and( NoL.greaterThan( 0.0 ) ).and( dot( lightDir, NgeoFF ).greaterThan( 0.0 ) )
+				.and( sideAccepts( side, dot( lightDir, windingN ) ) ), () => {
+
+				const rayOrigin = lightShadowOrigin( lightDir ).toVar();
+				const toSample = position.sub( rayOrigin ).toVar();
+				const shadowDist = length( toSample ).toVar();
+				const visibility = traceShadowRayRefractiveOpaque(
+					rayOrigin, toSample.div( shadowDist ), shadowDist.mul( SHADOW_END ),
+					traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer,
+				).toVar();
+
+				If( visibility.greaterThan( 0.0 ), () => {
+
+					const brdfVal = evaluateMaterialResponse( V, lightDir, N, material );
+					const forward = calculateMaterialPDF( V, lightDir, N, material );
+					const reverse = calculateMaterialPDF( lightDir, V, N, material );
+					// Emission density over NEE's, both seen from here; the light's cosine cancels.
+					const emissionOverDirect = select( bdpt.lightPaths.greaterThan( uint( 0 ) ),
+						emitterAreaPdf( emission, emissiveTotalPower, float( 1.0 ).sub( bdpt.sunPick ) )
+							.mul( emitterSideProbability( side, dot( lightDir.negate(), windingN ) ) )
+							.mul( abs( dot( lightDir, exactFacetN ) ) ).div( lightPdf.mul( Math.PI ) ),
+						float( 0.0 ) );
+					const wLight = mis( forward.div( lightPdf ) );
+					const wCamera = misPartial( emissionOverDirect, subpath, reverse );
+
+					currentRadiance.assign( vec4(
+						currentRadiance.xyz.add(
+							regularizePathContribution(
+								emission.mul( brdfVal ).mul( NoL ).div( lightPdf ).mul( visibility ).mul( emissiveBoost )
+									.mul( strategyWeight( bdpt.strategyView, STRATEGY.NEE, misWeight( wLight, wCamera ) ) ).mul( throughput ).mul( giScale ),
+								float( bounceIndex ), fireflyThreshold, int( accumFrame ),
+							),
+						),
+						currentRadiance.w,
+					) );
+
+				} );
+
+			} );
+
+		};
+
+		// Georgiev (44)-(45) for the sun; as for emitters, glass blocks the shadow ray.
+		const bidirectionalSunNEE = () => {
+
+			const lightDir = sampleSunDisc( sunDirection, sunParams, getRandomSample2D( _pixelCoord, int( 0 ), dimBase.add( int( 9 ) ), rngState, resolution, frame ) ).toVar();
+			const radiance = sunRadianceToward( lightDir, sunDirection, sunRadiance, sunParams ).mul( environmentIntensity ).toVar();
+			const NoL = max( float( 0.0 ), dot( N, lightDir ) ).toVar();
+			If( radiance.x.add( radiance.y ).add( radiance.z ).greaterThan( 0.0 ).and( NoL.greaterThan( 0.0 ) ).and( dot( lightDir, NgeoFF ).greaterThan( 0.0 ) ), () => {
+
+				const visibility = traceShadowRayRefractiveOpaque(
+					lightShadowOrigin( lightDir ), lightDir, float( 1e20 ),
+					traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer,
+				).toVar();
+
+				If( visibility.greaterThan( 0.0 ), () => {
+
+					const brdfVal = evaluateMaterialResponse( V, lightDir, N, material );
+					const forward = calculateMaterialPDF( V, lightDir, N, material );
+					const reverse = calculateMaterialPDF( lightDir, V, N, material );
+					const emissionOverDirect = select( bdpt.lightPaths.greaterThan( uint( 0 ) ),
+						sunEmissionPdf( bdpt, sunParams, guidedDiscPdf( bdpt, bdpt.guideTexture, lightDir, hitPoint ) ).mul( sunParams.y ).mul( abs( dot( lightDir, exactFacetN ) ) ), float( 0.0 ) );
+					const weight = misWeight( mis( forward.mul( sunParams.y ) ), misPartial( emissionOverDirect, subpath, reverse ) );
+
+					currentRadiance.assign( vec4(
+						currentRadiance.xyz.add(
+							regularizePathContribution(
+								radiance.mul( brdfVal ).mul( NoL ).mul( sunParams.y ).mul( visibility )
+									.mul( strategyWeight( bdpt.strategyView, STRATEGY.NEE, weight ) ).mul( throughput ).mul( giScale ),
+								float( bounceIndex ), fireflyThreshold, int( accumFrame ),
+							),
+						),
+						currentRadiance.w,
+					) );
+
+				} );
+
+			} );
+
+		};
+
+		if ( bdpt ) If( isLight.not().and( hasSun.greaterThan( int( 0 ) ) ).and( enableEnvironmentLight ), () => {
+
+			bidirectionalSunNEE();
+
+		} );
+
+		// Georgiev (44)-(45) for the environment, drawn exactly (environmentPdfExact); glass blocks it as it does the sun's.
+		const bidirectionalEnvironmentNEE = () => {
+
+			const drawn = sampleEnvironmentExact( envCDFTexture, envMatrix, envResolution,
+				getRandomSample2D( _pixelCoord, int( 0 ), dimBase.add( int( 1 ) ), rngState, resolution, frame ) );
+			const lightDir = drawn.direction.toVar();
+			const lightPdf = drawn.pdf.toVar();
+			const radiance = sampleEnvironment( {
+				tex: envTexture, samp: sampler( envTexture ), direction: lightDir, environmentMatrix: envMatrix, environmentIntensity, enableEnvironmentLight: float( 1.0 ),
+			} ).xyz.toVar();
+			const NoL = max( float( 0.0 ), dot( N, lightDir ) ).toVar();
+			If( lightPdf.greaterThan( 0.0 ).and( radiance.x.add( radiance.y ).add( radiance.z ).greaterThan( 0.0 ) ).and( NoL.greaterThan( 0.0 ) )
+				.and( dot( lightDir, NgeoFF ).greaterThan( 0.0 ) ), () => {
+
+				const visibility = traceShadowRayRefractiveOpaque(
+					lightShadowOrigin( lightDir ), lightDir, float( 1e20 ), traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer,
+				).toVar();
+
+				If( visibility.greaterThan( 0.0 ), () => {
+
+					const brdfVal = evaluateMaterialResponse( V, lightDir, N, material );
+					const forward = calculateMaterialPDF( V, lightDir, N, material );
+					const reverse = calculateMaterialPDF( lightDir, V, N, material );
+					const lead = select( bdpt.lightPaths.greaterThan( uint( 0 ) ),
+						bdpt.envPick.mul( guidedDiscPdf( bdpt, bdpt.guideTexture, lightDir, hitPoint ) ).mul( abs( dot( lightDir, exactFacetN ) ) ), float( 0.0 ) );
+					const weight = misWeight( mis( forward.div( lightPdf ) ), misPartial( lead, subpath, reverse ) );
+
+					currentRadiance.assign( vec4(
+						currentRadiance.xyz.add(
+							regularizePathContribution(
+								radiance.mul( brdfVal ).mul( NoL ).div( lightPdf ).mul( visibility )
+									.mul( strategyWeight( bdpt.strategyView, STRATEGY.NEE, weight ) ).mul( throughput ).mul( giScale ),
+								float( bounceIndex ), fireflyThreshold, int( accumFrame ),
+							),
+						),
+						currentRadiance.w,
+					) );
+
+				} );
+
+			} );
+
+		};
+
+		if ( bdpt ) If( isLight.not().and( enableEnvironmentLight ).and( bdpt.envTable.greaterThan( uint( 0 ) ) ), () => {
+
+			bidirectionalEnvironmentNEE();
+
+		} );
+
+		// The lamps' reservoir total here, for the BSDF-hit partner at the continuation.
+		const lampTotal = bdpt ? float( 0.0 ).toVar() : null;
+
+		// Georgiev (44)-(45) for a lamp, picked as the path tracer picks it. A point, a spot or a directional light no
+		// camera path can hit; a rect light's partner is the continuation's hit (bidirectionalAreaHit).
+		const bidirectionalLampNEE = () => {
+
+			const lightRandom = getRandomSample2D( _pixelCoord, int( 0 ), dimBase.add( int( 2 ) ), rngState, resolution, frame ).toVar();
+			const pick = LampPick.wrap( pickLamp( lamps, hitPoint, N, material, lightRandom.x,
+				( dim ) => getRandomSample1D( _pixelCoord, int( 0 ), dim, rngState, resolution, frame ) ) ).toVar();
+			lampTotal.assign( pick.total );
+
+			const valid = tslBool( false ).toVar();
+			const lightDir = vec3( 0.0, 1.0, 0.0 ).toVar();
+			const emission = vec3( 0.0 ).toVar();
+			const dist = float( 0.0 ).toVar();
+			const lightPdf = float( 0.0 ).toVar();
+			// Emission density over NEE's, but for the cosine here.
+			const emissionOverDirect = float( 0.0 ).toVar();
+			const take = ( sample ) => {
+
+				const ls = LightSample.wrap( sample );
+				valid.assign( ls.valid );
+				lightDir.assign( ls.direction );
+				emission.assign( ls.emission );
+				dist.assign( ls.distance );
+				lightPdf.assign( ls.pdf );
+
+			};
+
+			const pE = sourcePick( bdpt, lampSource( bdpt, pick.kind, pick.index ) ).toVar();
+
+			If( pick.kind.equal( int( LIGHT_TYPE_DIRECTIONAL ) ), () => {
+
+				const light = DirectionalLight.wrap( getDirectionalLight( directionalLightsBuffer, pick.index ) );
+				take( sampleDirectionalLight( light, hitPoint, pick.pdf, lightRandom.y,
+					getRandomSample1D( _pixelCoord, int( 0 ), dimBase.add( int( 14 ) ), rngState, resolution, frame ) ) );
+				emissionOverDirect.assign( pE.mul( guidedDiscPdf( bdpt, bdpt.guideTexture, lightDir, hitPoint ) ).div( max( pick.pdf, 1e-30 ) ) );
+
+			} ).ElseIf( pick.kind.equal( int( LIGHT_TYPE_AREA ) ), () => {
+
+				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, pick.index ) );
+				take( sampleRectAreaLight( light, hitPoint,
+					vec2( lightRandom.y, getRandomSample1D( _pixelCoord, int( 0 ), dimBase.add( int( 15 ) ), rngState, resolution, frame ) ), pick.pdf ) );
+				emissionOverDirect.assign( pE.div( max( light.area.mul( Math.PI ).mul( lightPdf ), 1e-30 ) ) );
+
+			} ).ElseIf( pick.kind.equal( int( LIGHT_TYPE_POINT ) ), () => {
+
+				take( samplePointLightWithAttenuation( PointLight.wrap( getPointLight( pointLightsBuffer, pick.index ) ), hitPoint, pick.pdf ) );
+				emissionOverDirect.assign( pE.div( max( float( 4 * Math.PI ).mul( pick.pdf ).mul( dist ).mul( dist ), 1e-30 ) ) );
+
+			} ).Else( () => {
+
+				const light = SpotLight.wrap( getSpotLight( spotLightsBuffer, pick.index ) );
+				take( sampleSpotLightWithRadius( light, hitPoint, pick.pdf ) );
+				emissionOverDirect.assign( pE.div( max( spotConeSolidAngle( light ).mul( pick.pdf ).mul( dist ).mul( dist ), 1e-30 ) ) );
+
+			} );
+
+			const NoL = max( float( 0.0 ), dot( N, lightDir ) ).toVar();
+			If( valid.and( lightPdf.greaterThan( 0.0 ) ).and( NoL.greaterThan( 0.0 ) ).and( dot( lightDir, NgeoFF ).greaterThan( 0.0 ) ), () => {
+
+				const atInfinity = pick.kind.equal( int( LIGHT_TYPE_DIRECTIONAL ) );
+				const shadowOrigin = lightShadowOrigin( lightDir ).toVar();
+				const toSample = hitPoint.add( lightDir.mul( dist ) ).sub( shadowOrigin ).toVar();
+				const shadowDist = length( toSample ).toVar();
+				const visibility = traceShadowRayRefractiveOpaque(
+					shadowOrigin, select( atInfinity, lightDir, toSample.div( shadowDist ) ), select( atInfinity, float( 1e20 ), shadowDist.mul( SHADOW_END ) ),
+					traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer,
+				).toVar();
+
+				If( visibility.greaterThan( 0.0 ), () => {
+
+					const brdfVal = evaluateMaterialResponse( V, lightDir, N, material );
+					const forward = calculateMaterialPDF( V, lightDir, N, material );
+					const reverse = calculateMaterialPDF( lightDir, V, N, material );
+					const lead = select( bdpt.lightPaths.greaterThan( uint( 0 ) ), emissionOverDirect.mul( abs( dot( lightDir, exactFacetN ) ) ), float( 0.0 ) );
+					const wLight = select( pick.kind.equal( int( LIGHT_TYPE_AREA ) ), mis( forward.div( lightPdf ) ), float( 0.0 ) );
+
+					currentRadiance.assign( vec4(
+						currentRadiance.xyz.add(
+							regularizePathContribution(
+								emission.mul( brdfVal ).mul( NoL ).div( lightPdf ).mul( visibility )
+									.mul( strategyWeight( bdpt.strategyView, STRATEGY.NEE, misWeight( wLight, misPartial( lead, subpath, reverse ) ) ) ).mul( throughput ).mul( giScale ),
+								float( bounceIndex ), fireflyThreshold, int( accumFrame ),
+							),
+						),
+						currentRadiance.w,
+					) );
+
+				} );
+
+			} );
+
+		};
+
+		if ( bdpt ) If( isLight.not().and( lampCount( lamps ).greaterThan( int( 0 ) ) ), () => {
+
+			bidirectionalLampNEE();
+
+		} );
+
+		// NEE's density for a lamp's light path depends on this vertex's material.
+		if ( bdpt ) If( isLight.and( lampLanding.source.greaterThanEqual( int( SOURCE.LAMPS ) ) ), () => {
+
+			const type = sourceLampType( bdpt, lampLanding.source ).toVar();
+			const index = sourceLampIndex( bdpt, lampLanding.source, type ).toVar();
+			const d = lampLanding.dist;
+			const direct = lampPickPdf( lamps, type, index, hitPoint, N, material ).toVar();
+			If( type.equal( int( LIGHT_TYPE_DIRECTIONAL ) ), () => {
+
+				const light = DirectionalLight.wrap( getDirectionalLight( directionalLightsBuffer, index ) );
+				direct.divAssign( select( light.angle.greaterThan( 0.0 ), directionalConeSolidAngle( light ), float( 1.0 ) ) );
+
+			} ).ElseIf( type.equal( int( LIGHT_TYPE_AREA ) ), () => {
+
+				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, index ) );
+				const cosLight = dot( direction, light.normal ).toVar();
+				direct.mulAssign( areaLightDirectPdfW( light, hitPoint, d, cosLight ).mul( cosLight ).div( max( d.mul( d ), 1e-30 ) ) );
+
+			} );
+			subpath.dVCM.mulAssign( mis( direct ) );
+
+		} );
+
 		// emissive triangle NEE: light-BVH fast path when available, flat-CDF fallback otherwise
-		if ( useEmissiveNEE ) {
+		if ( useEmissiveNEE && bdpt ) {
+
+			If( isLight.not().and( enableEmissiveTriangleSampling.equal( int( 1 ) ) ).and( emissiveTriangleCount.greaterThan( int( 0 ) ) ), () => {
+
+				bidirectionalEmissiveNEE();
+
+			} );
+
+		} else if ( useEmissiveNEE && ! picksLights ) {
 
 			If(
 				enableEmissiveTriangleSampling.equal( int( 1 ) )
@@ -1306,18 +2066,22 @@ export function buildShadeKernel( params ) {
 							lightBuffer,
 							emissiveVec4Offset,
 							triangleBuffer, bvhBuffer,
+							transmitsDiffusely,
 						) );
 
 						// No rough-diffuse secondary-bounce skip here: dropping NEE while the emissive-hit
 						// MIS still down-weights BSDF hits deletes emitter energy from deep GI.
 						If( emissiveSample.valid.and( emissiveSample.pdf.greaterThan( 0.0 ) ), () => {
 
-							const NoL = max( float( 0.0 ), dot( N, emissiveSample.direction ) );
+							const back = throughSurface( emissiveSample.direction ).toVar();
+							const NoL = transmitting ? abs( dot( N, emissiveSample.direction ) ) : max( float( 0.0 ), dot( N, emissiveSample.direction ) );
+							const inFront = NoL.greaterThan( 0.0 ).and( dot( N, emissiveSample.direction ).greaterThan( 0.0 ) )
+								.and( dot( emissiveSample.direction, NgeoFF ).greaterThan( 0.0 ) );
 
-							If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, NgeoFF ).greaterThan( 0.0 ) ), () => {
+							If( transmitting ? back.or( inFront ) : inFront, () => {
 
 								// Aimed at the sampled point and stopped a relative hair short, as for area lights.
-								const rayOrigin = lightShadowOrigin( emissiveSample.direction ).toVar();
+								const rayOrigin = originFor( emissiveSample.direction, lightShadowOrigin( emissiveSample.direction ) ).toVar();
 								const toSample = emissiveSample.position.sub( rayOrigin ).toVar();
 								const shadowDist = length( toSample ).toVar();
 								const visibility = traceShadowRayWrapped(
@@ -1365,7 +2129,7 @@ export function buildShadeKernel( params ) {
 							lightBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 							triangleBuffer, bvhBuffer,
 							traceShadowRayWrapped,
-							Fn( ( [ p, , L ] ) => lightShadowOrigin( L ).sub( p ) ),
+							Fn( ( [ p, , L ] ) => originFor( L, lightShadowOrigin( L ) ).sub( p ) ),
 						);
 
 						currentRadiance.assign( vec4(
@@ -1389,10 +2153,46 @@ export function buildShadeKernel( params ) {
 		// per-term (env / emissive-hit / direct-light / emissive-NEE), matching the megakernel which never
 		// re-suppresses the running radiance.
 
+		if ( bdpt ) {
+
+			// Light from below the shading normal: a camera path neither samples it nor lets NEE take it.
+			If( isLight.and( dot( V, N ).lessThanEqual( 0.0 ) ), () => {
+
+				terminatePath();
+				Return();
+
+			} );
+
+			If( isLight, () => {
+
+				// The path's vertex count rides in its first slot.
+				const first = rayID.mul( bdpt.slotsPerPath ).toVar();
+				writeVertexRecord( hitBufferRW, cachedVertex( first.add( uint( cameraDepth ) ) ), {
+					position: hitPoint, tag: uint( 0 ), throughput: throughput.mul( readLightOrigin( hitBufferRW, rayID ).scale ),
+					V, N, facetN: exactFacetN, materialIndex: hitMatIdx, uv: samplingUV, dVCM: subpath.dVCM, dVC: subpath.dVC,
+					// 1: a camera on this side would cull the face, so light tracing must not show it.
+					extra: select( sideAccepts( triangleSide( triangleRow( triangleBuffer, int( hitTriIdx ), 4 ).z ),
+						dot( direction, windingNormal( triangleBuffer, bvhBuffer, int( hitTriIdx ), hitInstance ) ) ), uint( 0 ), uint( 1 ) ),
+				} );
+				writeLightPathLength( hitBufferRW, cachedVertex( first ), bdpt.lightTag, uint( cameraDepth ).add( uint( 1 ) ) );
+
+			} ).ElseIf( bdpt.lightPaths.greaterThan( uint( 0 ) ).and( bdpt.merging ? cameraDepth.lessThanEqual( maxBounceCount ) : cameraDepth.lessThan( maxBounceCount ) ), () => {
+
+				// For ConnectKernel (and MergeKernel); a light vertex must still fit in the bounce budget.
+				writeVertexRecord( hitBufferRW, pendingVertex( rayID ), {
+					position: hitPoint, tag: bdpt.passTag, throughput,
+					V, N, facetN: exactFacetN, materialIndex: hitMatIdx, uv: samplingUV, dVCM: subpath.dVCM, dVC: subpath.dVC, extra: uint( cameraDepth ),
+				} );
+
+			} );
+
+		}
+
 		const indirectResult = IndirectLightingResult.wrap( calculateIndirectLighting(
 			N, material,
 			brdfDir, brdfPdf, brdfValue,
 			brdfIsTransmission, brdfColorWeight,
+			brdfIsDiffuseTransmission,
 			rngState,
 			_pixelCoord, resolution, frame, dimBase,
 		) ).toVar();
@@ -1400,8 +2200,10 @@ export function buildShadeKernel( params ) {
 		const bounceDir = indirectResult.direction.toVar();
 
 		// 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.
-		If( brdfIsTransmission.not().and( dot( bounceDir, NgeoFF ).lessThanEqual( 0.0 ) ), () => {
+		// tracing that ray tunnels through single-sided shells onto whatever sits behind them. A diffuse
+		// transmission draw is the mirror case: it must cross the surface.
+		If( select( brdfIsDiffuseTransmission, dot( bounceDir, NgeoFF ).greaterThanEqual( 0.0 ),
+			brdfIsTransmission.not().and( dot( bounceDir, NgeoFF ).lessThanEqual( 0.0 ) ) ), () => {
 
 			commitDeferredAux( N );
 			terminatePath();
@@ -1410,7 +2212,35 @@ export function buildShadeKernel( params ) {
 		} );
 		// combinedPdf is stored as next bounce's prevBouncePdf for NEE↔implicit-env MIS
 		const bouncePdf = max( indirectResult.combinedPdf, 0.001 ).toVar();
-		throughput.mulAssign( indirectResult.throughput );
+		const specularScatter = bdpt ? brdfIsTransmission.or( brdfPdf.greaterThanEqual( DELTA_PDF * 0.5 ) ).toVar() : null;
+		if ( bdpt ) {
+
+			If( isLight, () => {
+
+				// Light flows V → bounceDir; the BSDF is not reciprocal. Shading-normal correction: Veach 5.3.2.
+				const correction = lightEndCosine( V, N, exactFacetN, bounceDir ).div( max( abs( dot( bounceDir, N ) ), 1e-4 ) ).toVar();
+				If( specularScatter.or( brdfPdf.greaterThan( 0.0 ).not() ), () => {
+
+					throughput.mulAssign( indirectResult.throughput.mul( correction ) );
+
+				} ).Else( () => {
+
+					throughput.mulAssign( evaluateMaterialResponse( bounceDir, V, N, material )
+						.mul( max( dot( N, bounceDir ), 0.0 ) ).div( max( brdfPdf, MIN_PDF ) ).mul( correction ) );
+
+				} );
+
+			} ).Else( () => {
+
+				throughput.mulAssign( indirectResult.throughput );
+
+			} );
+
+		} else {
+
+			throughput.mulAssign( indirectResult.throughput );
+
+		}
 
 		// Adaptive Russian roulette (gap #7) — material-importance + throughput + env-direction aware, replacing
 		// the flat clamp(maxThroughput,0.05,0.95). depth = bounceIndex (path length, per gap #4); rayDirection =
@@ -1434,17 +2264,50 @@ export function buildShadeKernel( params ) {
 		If( cameraDepth.greaterThanEqual( maxBounceCount ), () => {
 
 			commitDeferredAux( N );
-			terminatePath();
-			Return();
+			// One segment more, for the light it may hit: light sampled here keeps its BSDF-hit partner (and its MIS
+			// weight), and bidirectional strategies all reach the longest paths.
+			if ( bdpt ) If( isLight, () => {
+
+				terminatePath();
+				Return();
+
+			} );
+			flags.assign( flags.bitOr( uint( RAY_FLAG.EMISSION_ONLY | RAY_FLAG.AUX_LOCKED ) ) );
 
 		} );
 
+		if ( bdpt ) {
+
+			const cosOut = abs( dot( bounceDir, exactFacetN ) );
+			If( specularScatter, () => {
+
+				misOnSpecular( subpath, cosOut );
+
+			} ).Else( () => {
+
+				misOnScatter( subpath, cosOut, calculateMaterialPDF( V, bounceDir, N, material ), calculateMaterialPDF( bounceDir, V, N, material ) );
+
+			} );
+
+		}
+
 		const underFacet = dot( facetN, bounceDir ).lessThan( 0.0 ).toVar();
 		const newOrigin = offsetRayOrigin( hitPoint, select( underFacet, facetN.negate(), facetN ) );
 
+		if ( bdpt ) If( isLight.not().and( numAreaLights.greaterThan( int( 0 ) ) ), () => {
+
+			const connectible = specularScatter.not().and( dot( N, bounceDir ).greaterThan( 0.0 ) ).and( dot( bounceDir, NgeoFF ).greaterThan( 0.0 ) );
+			bidirectionalAreaHit( newOrigin, bounceDir, ( light ) => select( connectible, select( lampTotal.greaterThan( 0.0 ),
+				estimateLightImportance( light, hitPoint, N, material ).div( max( lampTotal, 1e-30 ) ),
+				float( 1.0 ).div( max( float( lampCount( lamps ) ), 1.0 ) ) ), float( 0.0 ) ) );
+
+		} );
+
 		// Whether this vertex's sun NEE could have drawn bounceDir, so a sun hit at the miss knows its MIS partner.
-		const sunNEE = brdfIsTransmission.not().and( dot( N, bounceDir ).greaterThan( 0.0 ) );
-		const underSurface = brdfIsTransmission.not().and( underFacet );
+		// Through a diffusely transmitting surface it samples the far side too.
+		const sunNEE = brdfIsTransmission.not().and( dot( N, bounceDir ).greaterThan( 0.0 ).or( brdfIsDiffuseTransmission ) );
+		// Diffuse transmission crosses the surface on purpose; the next hit is an ordinary bounce's.
+		const underSurface = brdfIsTransmission.not().and( brdfIsDiffuseTransmission.not() ).and( underFacet );
 		flags.assign( flags.sub( flags.bitAnd( uint( RAY_FLAG.SUN_NEE | RAY_FLAG.UNDER_SURFACE ) ) )
 			.bitOr( select( sunNEE, uint( RAY_FLAG.SUN_NEE ), uint( 0 ) ) )
 			.bitOr( select( underSurface, uint( RAY_FLAG.UNDER_SURFACE ), uint( 0 ) ) ) );
@@ -1456,12 +2319,12 @@ export function buildShadeKernel( params ) {
 		writeRayRadiance( rayBufferRW, rayID, currentRadiance );
 		writeMediumStack( rayBufferRW, rayID, uint( mediumStackDepth ), uint( transTraversals ), mediumStack_ior_1, mediumStack_ior_2, mediumStack_ior_3, uint( pathWavelength.add( 0.5 ) ) );
 		// DDFA: persist the (possibly mirror-tinted) see-through throughput for the next bounce.
-		If( auxOn.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
+		if ( aux ) If( aux.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) ), () => {
 
 			writeFeatureThroughput( rayBufferRW, rayID, featCarry );
 
 		} );
-		writeRngState( hitBufferRW, rayID, rngState );
+		persistRng();
 
 	} );