rayzee 10.0.0 → 11.0.0

package/src/TSL/ConnectKernel.js

@@ -0,0 +1,147 @@
+/**
+ * ConnectKernel.js — connects each camera vertex Shade left pending to one vertex of a random light
+ * path, weighted by how many of that path's vertices fit the bounce budget (Davidovič et al. 2014).
+ */
+
+import {
+	Fn, float, vec2, vec4, int, uint, If, instanceIndex, atomicLoad, Return, dot, sqrt, min, max, length,
+} from 'three/tsl';
+
+import { getRandomSample1D, pcgHash, SAMPLER_DIMS_PER_BOUNCE } from './Random.js';
+import { evaluateMaterialResponse } from './MaterialEvaluation.js';
+import { calculateMaterialPDF } from './LightsSampling.js';
+import { traceShadowRayRefractiveOpaque } from './LightsDirect.js';
+import { traverseBVHShadow } from './BVHTraversal.js';
+import { offsetRayOrigin, SHADOW_END, luminance } from './Common.js';
+import { regularizePathContribution } from './PathTracerCore.js';
+import {
+	resolveSurfaceMaterial, lightEndCosine, misPartial, misWeight, strategyWeight, STRATEGY, DIM_CONNECT_PATH, DIM_CONNECT_VERTEX,
+} from './Bidirectional.js';
+import { COUNTER } from '../Processor/QueueManager.js';
+import {
+	readRayRadiance, writeRayRadiance, readRngState,
+	pendingVertex, cachedVertex, readVertexTag, readVertexRecord, readLightPathLength,
+} from '../Processor/PackedRayBuffer.js';
+
+const WG_SIZE = 256;
+
+export function buildConnectKernel( params ) {
+
+	const {
+		rayBufferRW, hitBufferRO, activeIndicesRO, counters,
+		bvhBuffer, triangleBuffer, materialBuffer,
+		resolution, frame, accumFrame, currentBounce, chunkRowBase,
+		lightPaths, slotsPerPath, lightTag, passTag, strategyView,
+		maxBounceCount, globalIlluminationIntensity, fireflyThreshold,
+		// Vertex merging's η² at a point (Bidirectional.js mergeVmAt), or null without it.
+		mergeVm = null,
+	} = params;
+
+	return Fn( () => {
+
+		const tid = instanceIndex;
+		If( tid.greaterThanEqual( atomicLoad( counters.element( uint( COUNTER.ENTERING_COUNT ) ) ) ), () => {
+
+			Return();
+
+		} );
+
+		const rayID = activeIndicesRO.element( tid ).toVar();
+		const pending = pendingVertex( rayID );
+		If( readVertexTag( hitBufferRO, pending ).notEqual( passTag ), () => {
+
+			Return();
+
+		} );
+
+		const camRecord = readVertexRecord( hitBufferRO, pending );
+		const cam = { ...camRecord, vm: mergeVm?.( camRecord.position ) ?? null };
+		const cameraVertices = int( cam.extra ).add( int( 1 ) ).toVar();
+
+		const resX = int( resolution.x );
+		const globalPixel = int( rayID ).add( chunkRowBase.mul( resX ) );
+		const pixel = vec2( float( globalPixel.mod( resX ) ).add( 0.5 ), float( globalPixel.div( resX ) ).add( 0.5 ) ).toVar();
+		const dimBase = int( currentBounce ).mul( int( SAMPLER_DIMS_PER_BOUNCE ) );
+		// Only PCG reads it; hashed so the path's own stream, already saved by Shade, is not replayed.
+		const rng = pcgHash( { state: readRngState( hitBufferRO, rayID ).bitXor( uint( 0x9E3779B9 ) ) } ).toVar();
+		const uPath = getRandomSample1D( pixel, int( 0 ), dimBase.add( int( DIM_CONNECT_PATH ) ), rng, resolution, frame ).toVar();
+		const uVertex = getRandomSample1D( pixel, int( 0 ), dimBase.add( int( DIM_CONNECT_VERTEX ) ), rng, resolution, frame ).toVar();
+
+		const path = min( uint( float( lightPaths ).mul( uPath ) ), lightPaths.sub( uint( 1 ) ) ).toVar();
+		const first = path.mul( slotsPerPath ).toVar();
+		const stored = int( readLightPathLength( hitBufferRO, cachedVertex( first ), lightTag ) );
+		const usable = min( stored, int( maxBounceCount ).add( int( 1 ) ).sub( cameraVertices ) ).toVar();
+		If( usable.lessThan( int( 1 ) ), () => {
+
+			Return();
+
+		} );
+
+		const c = min( int( float( usable ).mul( uVertex ) ), usable.sub( int( 1 ) ) ).toVar();
+		const lightRecord = readVertexRecord( hitBufferRO, cachedVertex( first.add( uint( c ) ) ) );
+		const light = { ...lightRecord, vm: mergeVm?.( lightRecord.position ) ?? null };
+
+		const toLight = light.position.sub( cam.position ).toVar();
+		const dist2 = max( dot( toLight, toLight ), 1e-12 ).toVar();
+		const dir = toLight.div( sqrt( dist2 ) ).toVar();
+
+		const cosCamera = dot( dir, cam.N ).toVar();
+		const cosCameraFacet = dot( dir, cam.facetN ).toVar();
+		const cosLightFacet = dot( dir, light.facetN ).negate().toVar();
+		// The camera end tests as NEE does; at the light end the camera vertex is the viewer, which only the facet bounds.
+		If( cosCamera.lessThanEqual( 0.0 ).or( cosCameraFacet.lessThanEqual( 0.0 ) ).or( cosLightFacet.lessThanEqual( 0.0 ) ), () => {
+
+			Return();
+
+		} );
+
+		const cameraMaterial = resolveSurfaceMaterial( cam.materialIndex, cam.uv, cam.N, materialBuffer );
+		const lightMaterial = resolveSurfaceMaterial( light.materialIndex, light.uv, light.N, materialBuffer );
+		const toCamera = dir.negate();
+
+		const fCamera = evaluateMaterialResponse( cam.V, dir, cam.N, cameraMaterial ).toVar();
+		const fLight = evaluateMaterialResponse( toCamera, light.V, light.N, lightMaterial ).toVar();
+		const geometry = cosCamera.mul( lightEndCosine( light.V, light.N, light.facetN, toCamera ) ).div( dist2 );
+
+		const cameraForward = calculateMaterialPDF( cam.V, dir, cam.N, cameraMaterial );
+		const cameraReverse = calculateMaterialPDF( dir, cam.V, cam.N, cameraMaterial );
+		const lightForward = calculateMaterialPDF( light.V, toCamera, light.N, lightMaterial );
+		const lightReverse = calculateMaterialPDF( toCamera, light.V, light.N, lightMaterial );
+
+		// Georgiev (40)-(41): each side's sum, from the other side's density of reaching it.
+		const wLight = misPartial( cameraForward.mul( cosLightFacet ).div( dist2 ), light, lightReverse );
+		const wCamera = misPartial( lightForward.mul( cosCameraFacet ).div( dist2 ), cam, cameraReverse );
+
+		const scattering = cameraVertices.add( c ).add( int( 1 ) );
+		// Alone, a path of k scattering vertices is reached by k − 1 connections.
+		const weight = strategyWeight( strategyView, STRATEGY.CONNECT, misWeight( wLight, wCamera ), float( 1.0 ).div( float( scattering.sub( int( 1 ) ) ) ) );
+		const contribution = regularizePathContribution(
+			cam.throughput.mul( fCamera ).mul( fLight ).mul( light.throughput )
+				.mul( geometry.mul( weight ).mul( float( usable ) ).mul( globalIlluminationIntensity ) ),
+			float( scattering.sub( int( 1 ) ) ), fireflyThreshold, int( accumFrame ),
+		).toVar();
+
+		If( luminance( contribution ).greaterThan( 0.0 ), () => {
+
+			const origin = offsetRayOrigin( cam.position, cam.facetN ).toVar();
+			const segment = offsetRayOrigin( light.position, light.facetN ).sub( origin ).toVar();
+			const segmentLength = length( segment ).toVar();
+			const visibility = traceShadowRayRefractiveOpaque(
+				origin, segment.div( segmentLength ), segmentLength.mul( SHADOW_END ),
+				traverseBVHShadow, bvhBuffer, triangleBuffer, materialBuffer,
+			);
+
+			If( visibility.greaterThan( 0.0 ), () => {
+
+				const radiance = readRayRadiance( rayBufferRW, rayID ).toVar();
+				writeRayRadiance( rayBufferRW, rayID, vec4( radiance.xyz.add( contribution.mul( visibility ) ), radiance.w ) );
+
+			} );
+
+		} );
+
+	} );
+
+}
+
+export { WG_SIZE as CONNECT_WG_SIZE };

package/src/TSL/Debugger.js

@@ -72,7 +72,7 @@ export const TraceDebugMode = Fn( ( [
 	visMode, debugVisScale,
 	// Screen info
 	pixelCoord, resolution,
-	// Material textures are read from the module-level bucket nodes (setMaterialBucketTextures).
+	// Material textures come from the kernel's SceneResources.
 	// Camera matrices (for depth debug mode)
 	cameraProjectionMatrix, cameraViewMatrix,
 	// Frame counter (for stochastic debug modes)

package/src/TSL/Displacement.js

@@ -1,8 +1,9 @@
+import { sceneResources } from './SceneResources.js';
 import { Fn, float, vec2, int, If, Loop, abs, normalize, dot, max, uintBitsToFloat } from 'three/tsl';
 
 import { struct } from './patches.js';
 import { triangleRow, instanceRows, instanceDirToWorld } from './Common.js';
-import { sampleDisplacementMap, bucketTexelSize, getLinearBucketTextures } from './TextureSampling.js';
+import { sampleDisplacementMap, bucketTexelSize } from './TextureSampling.js';
 
 // Ray-displacement intersection configuration
 const MAX_MARCH_STEPS = 32;
@@ -32,7 +33,7 @@ export const DisplacementResult = struct( {
  */
 export const refineDisplacedIntersection = Fn( ( [
 	ray, hitInfo, triangleBuffer, material, bounceIndex, bvhBuffer, instanceLeaf
-] ) => {
+], builder ) => {
 
 	const resultHitPoint = hitInfo.hitPoint.toVar();
 	const resultUV = hitInfo.uv.toVar();
@@ -205,7 +206,7 @@ export const refineDisplacedIntersection = Fn( ( [
 
 				// Compute displaced normal from height-field gradients using UV tangent vectors.
 				// Finite-difference step = one texel of the SELECTED bucket array's real dimensions.
-				const texel = bucketTexelSize( getLinearBucketTextures(), material.displacementMapIndex ).toVar();
+				const texel = bucketTexelSize( sceneResources( builder ).linearBuckets, material.displacementMapIndex ).toVar();
 				const hC = finalHeight;
 				const hU = sampleDisplacementMap(
 					material.displacementMapIndex, finalUV.add( vec2( texel.x, 0.0 ) ), material.displacementTransform,

package/src/TSL/EmissiveSampling.js

@@ -32,11 +32,13 @@ import {
 	computeDotProductsAniso, instanceRows, instanceNormalToWorld, instancePointToWorld,
 	unpackTriangleNormal, triangleRow, SHADOW_END
 } from './Common.js';
-import { TRI_MATERIAL_MASK } from '../EngineDefaults.js';
+import { TRI_MATERIAL_MASK } from '../Processor/BufferLayout.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
 import { calculateMaterialPDFFromDots } from './LightsSampling.js';
-import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
+import { evaluateMaterialResponseFromDots, evaluateDiffuseTransmission } from './MaterialEvaluation.js';
+import { diffuseTransmissionWeight, diffuseTransmissionPdf } from './MaterialProperties.js';
 import { DotProducts } from './Struct.js';
+import { triangleSide, sideAccepts } from './BVHTraversal.js';
 
 // ================================================================================
 // STRUCTS
@@ -54,6 +56,21 @@ export const EmissiveSample = struct( {
 	valid: 'bool', // Whether sample is valid
 } );
 
+// EmissiveSample plus the triangle it landed on, for the bidirectional MIS weight.
+export const EmissiveSampleIndexed = struct( {
+	position: 'vec3',
+	normal: 'vec3',
+	emission: 'vec3',
+	direction: 'vec3',
+	distance: 'float',
+	pdf: 'float',
+	area: 'float',
+	cosThetaLight: 'float',
+	valid: 'bool',
+	triangleIndex: 'int',
+	faceNormal: 'vec3', // winding normal
+} );
+
 export const EmissiveContributionResult = struct( {
 	contribution: 'vec3',
 	hasEmissive: 'bool',
@@ -285,6 +302,7 @@ export const TriangleData = struct( {
 	v0: 'vec3', v1: 'vec3', v2: 'vec3',
 	n0: 'vec3', n1: 'vec3', n2: 'vec3',
 	materialIndex: 'int',
+	side: 'int', // 0 front, 1 back, 2 double (BVHTraversal.js triangleSide)
 } );
 
 // Fetch triangle vertices from storage buffer
@@ -323,6 +341,7 @@ export const fetchTriangleData = Fn( ( [ triangleIndex, triangleBuffer, bvhBuffe
 	return TriangleData( {
 		v0, v1, v2, n0, n1, n2,
 		materialIndex: int( uvMat.z.bitAnd( uint( TRI_MATERIAL_MASK ) ) ),
+		side: triangleSide( uvMat.z ),
 	} );
 
 } );
@@ -359,14 +378,16 @@ export const calculateEmissiveLightPdf = Fn( ( [
 
 		// Area: PDF = (power/totalPower) / area, converted to solid angle
 		const geoNormal = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
-		const cosLight = max( dot( rayDir.negate(), geoNormal ), 0.001 );
+		const cosLight = max( abs( dot( rayDir, geoNormal ) ), 0.001 );
 		const distSq = hitDistance.mul( hitDistance );
 		const pdfArea = selectionPdf.div( area );
 		result.assign( pdfArea.mul( distSq ).div( cosLight ) );
 
 	} );
 
-	return max( result, MIN_PDF );
+	// The sampler draws only the sides the triangle emits from (a unit normal: sideAccepts has a threshold).
+	const winding = normalize( cross( triData.v1.sub( triData.v0 ), triData.v2.sub( triData.v0 ) ) );
+	return select( sideAccepts( triData.side, dot( rayDir, winding ) ), max( result, MIN_PDF ), float( 0.0 ) );
 
 } );
 
@@ -378,7 +399,7 @@ export const calculateEmissiveLightPdf = Fn( ( [
 // CDF values are stored in the .b channel of the emissive buffer.
 // `emissiveOffset` is the vec4-element offset into the packed light buffer
 // where emissive entries start (0 if using a non-packed buffer).
-const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissiveTriangleCount, rand ] ) => {
+export const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissiveTriangleCount, rand ] ) => {
 
 	const lo = int( 0 ).toVar();
 	const hi = emissiveTriangleCount.sub( 1 ).toVar();
@@ -407,15 +428,17 @@ const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissive
 // Sample from emissive triangle index using CDF importance sampling.
 // `emissiveTriangleBuffer` may be the shared packed light buffer; `emissiveVec4Offset`
 // gives the vec4 offset where emissive entries begin.
-export const sampleEmissiveTriangle = Fn( ( [
+const makeSampleEmissiveTriangle = ( indexed ) => Fn( ( [
 	hitPoint, surfaceNormal,
 	rngState,
 	pixelCoord, resolution, frame, dimBase,
 	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer, bvhBuffer,
+	// The surface passes light through diffusely: a point behind it is as good as one in front.
+	throughSurface,
 ] ) => {
 
-	const result = EmissiveSample( {
+	const fields = {
 		position: vec3( 0.0 ),
 		normal: vec3( 0.0 ),
 		emission: vec3( 0.0 ),
@@ -425,7 +448,10 @@ export const sampleEmissiveTriangle = Fn( ( [
 		area: float( 0.0 ),
 		cosThetaLight: float( 0.0 ),
 		valid: false,
-	} ).toVar();
+	};
+	const result = ( indexed
+		? EmissiveSampleIndexed( { ...fields, triangleIndex: int( - 1 ), faceNormal: vec3( 0.0 ) } )
+		: EmissiveSample( fields ) ).toVar();
 
 	// Check if we have emissive triangles
 	If( emissiveTriangleCount.greaterThan( int( 0 ) ), () => {
@@ -469,9 +495,9 @@ export const sampleEmissiveTriangle = Fn( ( [
 				const samplePos = sphResult.position;
 
 				const surfaceFacing = dot( dir, surfaceNormal );
-				const emissiveFacing = dot( dir, geoNormal.negate() );
+				const emissiveFacing = abs( dot( dir, geoNormal ) );
 
-				If( surfaceFacing.greaterThan( 0.0 ).and( emissiveFacing.greaterThan( 0.0 ) ), () => {
+				If( surfaceFacing.greaterThan( 0.0 ).or( throughSurface ).and( sideAccepts( triData.side, dot( dir, geoNormal ) ) ), () => {
 
 					// Interpolate normal at sampled point via barycentric coords
 					const bary = barycentricFromPoint( samplePos, triData.v0, triData.v1, triData.v2 );
@@ -495,6 +521,12 @@ export const sampleEmissiveTriangle = Fn( ( [
 					result.area.assign( area );
 					result.cosThetaLight.assign( emissiveFacing );
 					result.valid.assign( true );
+					if ( indexed ) {
+
+						result.triangleIndex.assign( triangleIndex );
+						result.faceNormal.assign( geoNormal );
+
+					}
 
 				} );
 
@@ -512,9 +544,11 @@ export const sampleEmissiveTriangle = Fn( ( [
 			const dir = toEmissive.div( dist );
 
 			const surfaceFacing = dot( dir, surfaceNormal );
-			const emissiveFacing = dot( dir, sampleNormal.negate() );
+			// The facet's cosine, not the shading normal's: it is what turns an area density into a solid-angle one.
+			const emissiveFacing = abs( dot( dir, geoNormal ) );
 
-			If( surfaceFacing.greaterThan( 0.0 ).and( emissiveFacing.greaterThan( 0.0 ) ), () => {
+			// Edge-on (a two-sided emitter passes its side test there) the density is infinite and the light zero.
+			If( surfaceFacing.greaterThan( 0.0 ).or( throughSurface ).and( sideAccepts( triData.side, dot( dir, geoNormal ) ) ).and( emissiveFacing.greaterThan( 0.0 ) ), () => {
 
 				// PDF: CDF selection (power/totalPower) * uniform area (1/area)
 				// Converted to solid angle: pdfArea * distSq / cosLight
@@ -530,6 +564,12 @@ export const sampleEmissiveTriangle = Fn( ( [
 				result.area.assign( area );
 				result.cosThetaLight.assign( emissiveFacing );
 				result.valid.assign( true );
+				if ( indexed ) {
+
+					result.triangleIndex.assign( triangleIndex );
+					result.faceNormal.assign( geoNormal );
+
+				}
 
 			} );
 
@@ -541,6 +581,9 @@ export const sampleEmissiveTriangle = Fn( ( [
 
 } );
 
+export const sampleEmissiveTriangle = /*@__PURE__*/ makeSampleEmissiveTriangle( false );
+export const sampleEmissiveTriangleIndexed = /*@__PURE__*/ makeSampleEmissiveTriangle( true );
+
 // ================================================================================
 // EMISSIVE TRIANGLE DIRECT LIGHTING CONTRIBUTION
 // ================================================================================
@@ -573,11 +616,12 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 	// down-weights BSDF hits deletes emitter energy from deep GI.
 
 	// Sample emissive triangle (CDF importance-weighted)
+	const transmits = material.diffuseTransmission.greaterThan( 0.0 );
 	const emissiveSample = EmissiveSample.wrap( sampleEmissiveTriangle(
 		hitPoint, normal, rngState,
 		pixelCoord, resolution, frame, dimBase,
 		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
-		triangleBuffer, bvhBuffer,
+		triangleBuffer, bvhBuffer, transmits,
 	) );
 
 	If( emissiveSample.valid.and( emissiveSample.pdf.greaterThan( 0.0 ) ), () => {
@@ -586,10 +630,12 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 		result.emissionOnly.assign( emissiveSample.emission );
 		result.distance.assign( emissiveSample.distance );
 
-		// Check geometric validity
-		const NoL = max( float( 0.0 ), dot( normal, emissiveSample.direction ) );
+		// Check geometric validity: in front, or behind a surface that passes light through diffusely
+		const back = transmits.and( dot( normal, emissiveSample.direction ).lessThan( 0.0 ) )
+			.and( dot( emissiveSample.direction, geomNormal ).lessThan( 0.0 ) ).toVar();
+		const NoL = abs( dot( normal, emissiveSample.direction ) );
 
-		If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, geomNormal ).greaterThan( 0.0 ) ), () => {
+		If( back.or( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, geomNormal ).greaterThan( 0.0 ) ) ), () => {
 
 			// Aimed at the sampled point and stopped a relative hair short, as for area lights.
 			const rayOrigin = hitPoint.add( calculateRayOffsetFn( hitPoint, geomNormal, emissiveSample.direction ) );
@@ -602,8 +648,9 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 				// Share H + dot products between BRDF eval and PDF (computeDotProducts
 				// would otherwise run twice with identical inputs).
 				const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, emissiveSample.direction, material ) );
-				const brdfValue = evaluateMaterialResponseFromDots( material, dots );
-				const brdfPdf = calculateMaterialPDFFromDots( material, dots );
+				const brdfValue = select( back, evaluateDiffuseTransmission( material, max( dot( normal, viewDir ), 0.001 ) ), evaluateMaterialResponseFromDots( material, dots ) );
+				const brdfPdf = select( back,
+					diffuseTransmissionPdf( diffuseTransmissionWeight( material ), NoL ), calculateMaterialPDFFromDots( material, dots ) );
 
 				// MIS weight: balance light sampling vs BRDF sampling
 				const misWeight = select(

package/src/TSL/Environment.js

@@ -1,6 +1,6 @@
-import { Fn, wgslFn, vec2, vec3, vec4, ivec2, float, int, If, texture, dot, sin, sqrt, floor, fract, min, max, mix, clamp } from 'three/tsl';
+import { Fn, wgslFn, vec2, vec3, ivec2, float, int, If, Loop, sin, sqrt, min, max, clamp, select } from 'three/tsl';
 
-import { REC709_LUMINANCE_COEFFICIENTS } from './Common.js';
+import { EXACT_TABLE_MAX_WIDTH, GUIDES_PER_ENTRY } from '../Processor/EnvironmentExactTable.js';
 
 // Convert direction to UV coordinates for equirectangular map
 // Exact implementation from three-gpu-pathtracer
@@ -28,125 +28,96 @@ export const equirectUvToDirection = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
-// Evaluate PDF for a given direction (for MIS)
-// Returns vec4(color.rgb, pdf) since TSL cannot use inout params
-// Uses MIS-compensated PDF (Karlík et al. 2019): max(0, lum - delta) / compensatedTotalSum
-export const sampleEquirect = Fn( ( [ environment, direction, environmentMatrix, envTotalSum, envCompensationDelta, envResolution ] ) => {
+// The table (EnvironmentExactTable.js packExactTable): texel ( x, y ) is row y's entry x — its running sum, the one
+// below it, and the guides of steps 2x and 2x + 1 — and texel ( w, y ) the rows' entry y likewise. Sizes as exactTableSize.
+const exactTable = ( cdfTexture, envResolution ) => {
 
-	const result = vec4( 0.0 ).toVar();
+	const W = int( envResolution.x );
+	const H = int( envResolution.y );
+	const k = max( W.add( int( EXACT_TABLE_MAX_WIDTH - 1 ) ).div( int( EXACT_TABLE_MAX_WIDTH ) ), int( 1 ) );
+	const w = W.add( k ).sub( int( 1 ) ).div( k ).toVar();
+	const h = H.add( k ).sub( int( 1 ) ).div( k ).toVar();
+	return { w, h, entry: ( x, y ) => cdfTexture.load( ivec2( x, y ) ) };
 
-	If( envTotalSum.equal( 0.0 ), () => {
+};
 
-		// Exclude black environments from MIS
-		result.assign( vec4( 0.0 ) );
+// The first of `count` entries whose running sum is above target: the guide of target's step names it at once unless
+// the step holds more than one entry boundary, or f32 rounding of target × steps picked the step beside it; then a
+// search from one entry below the guide to the guide two steps on. Returns the entry with its sum and the one below.
+const invert = ( count, entryAt, target ) => {
 
-	} ).Else( () => {
+	const steps = count.mul( int( GUIDES_PER_ENTRY ) ).toVar();
+	const step = clamp( int( target.mul( float( steps ) ) ), int( 0 ), steps.sub( int( 1 ) ) ).toVar();
+	const odd = step.bitAnd( int( 1 ) ).equal( int( 1 ) ).toVar();
+	const guides = entryAt( step.shiftRight( int( 1 ) ) ).toVar();
+	const index = int( select( odd, guides.w, guides.z ) ).toVar();
+	const e = entryAt( index ).toVar();
+	If( target.lessThan( e.y ).or( target.greaterThanEqual( e.x ).and( index.lessThan( count.sub( int( 1 ) ) ) ) ), () => {
 
-		const uv = equirectDirectionToUv( { direction, environmentMatrix } ).toVar();
-		const color = texture( environment, uv, 0 ).rgb.toVar();
+		const lo = max( index.sub( int( 1 ) ), int( 0 ) ).toVar();
+		const ahead = entryAt( step.shiftRight( int( 1 ) ).add( int( 1 ) ) );
+		const hi = select( step.add( int( 2 ) ).lessThan( steps ), int( select( odd, ahead.w, ahead.z ) ), count.sub( int( 1 ) ) ).toVar();
+		Loop( lo.lessThan( hi ), () => {
 
-		// sin(theta) matches the CDF's solid-angle weighting (lum * sinTheta)
-		const sinTheta = sin( uv.y.mul( Math.PI ) ).toVar();
-		const lum = dot( color, REC709_LUMINANCE_COEFFICIENTS );
-		const weightedLum = lum.mul( sinTheta );
-		// MIS Compensation: subtract delta to match the sharpened CDF
-		const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) );
-		const pdf = compensatedWeight.div( envTotalSum );
+			const mid = lo.add( hi ).div( 2 ).toVar();
+			If( entryAt( mid ).x.lessThanEqual( target ), () => {
 
-		// Inline equirectDirectionPdf using the uv + sinTheta already in scope —
-		// the helper would otherwise re-derive uv via atan2+acos and recompute sin.
-		const dirPdf = sinTheta.greaterThan( 0.0 ).select(
-			float( 1.0 ).div( float( 2.0 * Math.PI * Math.PI ).mul( sinTheta ) ),
-			float( 0.0 )
-		);
-		const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf );
+				lo.assign( mid.add( 1 ) );
 
-		result.assign( vec4( color, finalPdf ) );
+			} ).Else( () => {
+
+				hi.assign( mid );
+
+			} );
+
+		} );
+		index.assign( lo );
+		e.assign( entryAt( lo ) );
 
 	} );
+	return { index, top: e.x, bottom: e.y };
 
-	return result;
+};
 
-} );
+// Cell density over uv, per steradian at v.
+const cellPdf = ( share, w, h, v ) => {
 
-// Sample environment map using importance sampling
-// Returns vec4(direction.xyz, pdf). Optionally writes sampled color to colorOutput.
-// Exact implementation from three-gpu-pathtracer
-export const sampleEquirectProbability = Fn( ( [
-	environment,
-	envCDFTexture,
-	environmentMatrix,
-	environmentIntensity,
-	envTotalSum,
-	envCompensationDelta,
-	envResolution,
-	r,
-	colorOutput
-] ) => {
-
-	// CDF texture layout: (W+1)×H R32F — conditional[cy*W+cx] at texel (cx,cy); marginal[cy] at column W.
-	const cdfMarginalCol = int( envResolution.x ).toVar();
-
-	// Sample marginal CDF for V coordinate (1D, linear interpolation)
-	const marginalSize = envResolution.y;
-	const mIdx = clamp( r.x.mul( marginalSize.sub( 1.0 ) ), 0.0, marginalSize.sub( 1.0 ) );
-	const mI0 = int( floor( mIdx ) );
-	const mI1 = min( mI0.add( 1 ), int( marginalSize ).sub( 1 ) );
-	const mFrac = fract( mIdx );
-	const v = mix(
-		envCDFTexture.load( ivec2( cdfMarginalCol, mI0 ) ).x,
-		envCDFTexture.load( ivec2( cdfMarginalCol, mI1 ) ).x,
-		mFrac,
-	).toVar();
-
-	// Sample conditional CDF for U coordinate (2D grid, bilinear interpolation)
-	const condW = envResolution.x;
-	const condH = envResolution.y;
-	const cxf = clamp( r.y.mul( condW.sub( 1.0 ) ), 0.0, condW.sub( 1.0 ) );
-	const cyf = clamp( v.mul( condH.sub( 1.0 ) ), 0.0, condH.sub( 1.0 ) );
-	const cx0 = int( floor( cxf ) );
-	const cy0 = int( floor( cyf ) );
-	const cx1 = min( cx0.add( 1 ), int( condW ).sub( 1 ) );
-	const cy1 = min( cy0.add( 1 ), int( condH ).sub( 1 ) );
-	const fx = fract( cxf );
-	const fy = fract( cyf );
-	const v00 = envCDFTexture.load( ivec2( cx0, cy0 ) ).x;
-	const v10 = envCDFTexture.load( ivec2( cx1, cy0 ) ).x;
-	const v01 = envCDFTexture.load( ivec2( cx0, cy1 ) ).x;
-	const v11 = envCDFTexture.load( ivec2( cx1, cy1 ) ).x;
-	const u = mix( mix( v00, v10, fx ), mix( v01, v11, fx ), fy ).toVar();
-
-	const uv = vec2( u, v ).toVar();
-
-	// Convert UV to direction
-	const direction = equirectUvToDirection( { uv, environmentMatrix } ).toVar();
-
-	// Sample color
-	const color = texture( environment, uv, 0 ).rgb.mul( environmentIntensity ).toVar();
-
-	// Write color to output parameter (avoids redundant CDF texture lookups)
-	colorOutput.assign( color );
-
-	// Calculate PDF — sin(theta) weighting + MIS Compensation (Karlík et al. 2019)
-	const sinTheta = sin( uv.y.mul( Math.PI ) ).toVar();
-	const lum = dot( color.div( environmentIntensity ), REC709_LUMINANCE_COEFFICIENTS );
-	const weightedLum = lum.mul( sinTheta );
-	const compensatedWeight = max( float( 0.0 ), weightedLum.sub( envCompensationDelta ) );
-	const pdf = compensatedWeight.div( envTotalSum );
-
-	// Inline equirectDirectionPdf — uv + sinTheta are already in scope, so we
-	// skip the helper's redundant uv-from-direction + sin recompute.
-	const dirPdf = sinTheta.greaterThan( 0.0 ).select(
-		float( 1.0 ).div( float( 2.0 * Math.PI * Math.PI ).mul( sinTheta ) ),
-		float( 0.0 )
-	);
-	const finalPdf = float( envResolution.x ).mul( float( envResolution.y ) ).mul( pdf ).mul( dirPdf );
-
-	return vec4( direction, finalPdf );
+	const sinTheta = sin( v.mul( Math.PI ) );
+	return select( sinTheta.greaterThan( 0.0 ).and( share.greaterThan( 0.0 ) ),
+		share.mul( float( w ) ).mul( float( h ) ).div( max( sinTheta.mul( 2 * Math.PI * Math.PI ), 1e-30 ) ), float( 0.0 ) );
 
-} );
+};
+
+/** A direction drawn exactly from the table, and its density per steradian. */
+export function sampleEnvironmentExact( cdfTexture, environmentMatrix, envResolution, xi ) {
+
+	const { w, h, entry } = exactTable( cdfTexture, envResolution );
+	const row = invert( h, ( i ) => entry( w, i ), xi.y );
+	const y = row.index.toVar();
+	const cell = invert( w, ( i ) => entry( i, y ), xi.x );
+	const pRow = row.top.sub( row.bottom ).toVar();
+	const pCell = cell.top.sub( cell.bottom ).toVar();
+
+	const fv = clamp( xi.y.sub( row.bottom ).div( max( pRow, 1e-30 ) ), 0.0, 0.99999994 );
+	const fu = clamp( xi.x.sub( cell.bottom ).div( max( pCell, 1e-30 ) ), 0.0, 0.99999994 );
+	const uv = vec2( float( cell.index ).add( fu ).div( float( w ) ), float( y ).add( fv ).div( float( h ) ) ).toVar();
+
+	return { direction: equirectUvToDirection( { uv, environmentMatrix } ), pdf: cellPdf( pRow.mul( pCell ), w, h, uv.y ) };
+
+}
+
+/** sampleEnvironmentExact's density per steradian for `direction`. */
+export function environmentPdfExact( cdfTexture, environmentMatrix, envResolution, direction ) {
+
+	const { w, h, entry } = exactTable( cdfTexture, envResolution );
+	const uv = equirectDirectionToUv( { direction, environmentMatrix } ).toVar();
+	const x = clamp( int( uv.x.mul( float( w ) ) ), int( 0 ), w.sub( int( 1 ) ) ).toVar();
+	const y = clamp( int( uv.y.mul( float( h ) ) ), int( 0 ), h.sub( int( 1 ) ) ).toVar();
+	const rowEntry = entry( w, y ).toVar();
+	const cellEntry = entry( x, y ).toVar();
+	return cellPdf( rowEntry.x.sub( rowEntry.y ).mul( cellEntry.x.sub( cellEntry.y ) ), w, h, uv.y );
 
-// Note: powerHeuristic() is defined in Common.js
+}
 
 // Simple environment lookup (no importance sampling) — native WGSL
 export const sampleEnvironment = /*@__PURE__*/ wgslFn( `