rayzee 11.0.0 → 11.1.1

package/src/Processor/PBRT/PBRTTextureBake.js

@@ -3,8 +3,8 @@
  * an image texture's `scale` above 1 or `invert`, and a `mix` material whose amount is a texture.
  *
  * A layer is an image as pbrt evaluates it: linear values, top row first, `channels` 1 (a float texture reads
- * the red channel) or 3, already scaled and inverted, and the uv mapping pbrt applies before the lookup
- * (st = scale · uv + delta, image row from the top = 1 − t).
+ * an image's alpha where it has one, else the mean of its colour) or 3, already scaled and inverted, and the uv
+ * mapping pbrt applies before the lookup (st = scale · uv + delta, image row from the top = 1 − t).
  */
 
 const MAX_BAKE_SIZE = 4096;
@@ -28,6 +28,10 @@ export function makeLayer( pixels, { channels, decode = null, scale = 1, invert
 	const stride = pixels.channels ?? 4;
 	const data = new Float32Array( width * height * channels );
 	const topDown = pixels.topDown !== false;
+	// pbrt's encoding applies to every channel of an 8-bit image, alpha included.
+	const read = ( i ) => ( decode ? decode( pixels.data[ i ] / 255 ) : pixels.data[ i ] );
+	const fromAlpha = channels === 1 && stride === 4 && hasAlpha( pixels );
+	const mean = channels === 1 && stride >= 3 && ! fromAlpha;
 
 	for ( let y = 0; y < height; y ++ ) {
 
@@ -37,8 +41,10 @@ export function makeLayer( pixels, { channels, decode = null, scale = 1, invert
 			const src = ( row * width + x ) * stride, dst = ( y * width + x ) * channels;
 			for ( let c = 0; c < channels; c ++ ) {
 
-				const raw = pixels.data[ src + Math.min( c, stride - 1 ) ];
-				const v = scale * ( decode ? decode( raw / 255 ) : raw );
+				const raw = fromAlpha ? read( src + 3 )
+					: mean ? ( read( src ) + read( src + 1 ) + read( src + 2 ) ) / 3
+						: read( src + Math.min( c, stride - 1 ) );
+				const v = scale * raw;
 				data[ dst + c ] = invert ? Math.max( 0, 1 - v ) : v;
 
 			}
@@ -51,6 +57,16 @@ export function makeLayer( pixels, { channels, decode = null, scale = 1, invert
 
 }
 
+/** Whether an RGBA image's alpha is anything but opaque — pbrt reads it as an RGB image when it is not. */
+export function hasAlpha( pixels ) {
+
+	const { data } = pixels;
+	const one = pixels.float ? 1 : 255;
+	for ( let i = 3; i < data.length; i += 4 ) if ( data[ i ] !== one ) return true;
+	return false;
+
+}
+
 /** The layer's mean value (a float layer's only channel; a spectrum layer's average of three). */
 export function layerMean( layer ) {
 
@@ -91,9 +107,12 @@ function sample( layer, s, t, out ) {
  * (bottom row first), clamped to [0, 1] as pbrt clamps an albedo. Null when every term is a constant.
  * @param {Array<{ rgb?: number[], layer?: object, tint?: number[] }>} terms
  * @param {(values: number[][]) => number[]} combine - linear RGB from each term's linear RGB
+ * @param {object} [options]
+ * @param {(values: number[][]) => number} [options.alphaOf] - the alpha channel, linear; opaque without it
+ * @param {boolean} [options.linear=false] - linear bytes, for a data map
  * @returns {{ data: Uint8Array, width: number, height: number, mapping: { su: number, sv: number, du: number, dv: number } } | null}
  */
-export function bake( terms, combine ) {
+export function bake( terms, combine, { alphaOf = null, linear = false } = {} ) {
 
 	let driver = null;
 	for ( const term of terms ) if ( term.layer && ( ! driver || term.layer.width * term.layer.height > driver.width * driver.height ) ) driver = term.layer;
@@ -134,8 +153,14 @@ export function bake( terms, combine ) {
 
 			const rgb = combine( values );
 			const o = ( j * width + i ) * 4;
-			for ( let c = 0; c < 3; c ++ ) out[ o + c ] = Math.round( 255 * linearToSRGB( Math.min( 1, Math.max( 0, rgb[ c ] ) ) ) );
-			out[ o + 3 ] = 255;
+			for ( let c = 0; c < 3; c ++ ) {
+
+				const v = Math.min( 1, Math.max( 0, rgb[ c ] ) );
+				out[ o + c ] = Math.round( 255 * ( linear ? v : linearToSRGB( v ) ) );
+
+			}
+
+			out[ o + 3 ] = alphaOf ? Math.round( 255 * Math.min( 1, Math.max( 0, alphaOf( values ) ) ) ) : 255;
 
 		}
 

package/src/Processor/SceneMetadata.js

@@ -14,6 +14,9 @@
  *       "sourceFile": "https://.../brown_photostudio_02_1k.hdr",
  *       "rotation": 0,      // degrees around Y, matches the environmentRotation setting
  *       "intensity": 1      // drives both environmentIntensity and backgroundIntensity
+ *     },
+ *     "render": {           // what the file asks the renderer for; reported, not applied
+ *       "maxBounces": 15, "samples": 1024, "width": 1920, "height": 1080
  *     }
  *   }
  *
@@ -56,10 +59,11 @@ function pickPayload( container ) {
 	const obj = asObject( container );
 	if ( ! obj ) return null;
 
+	const has = ( o ) => o && ( o.environment !== undefined || o.render !== undefined );
 	const scoped = asObject( obj.rayzee );
-	if ( scoped && scoped.environment !== undefined ) return scoped;
+	if ( has( scoped ) ) return scoped;
 
-	return obj.environment !== undefined ? obj : null;
+	return has( obj ) ? obj : null;
 
 }
 
@@ -84,10 +88,29 @@ function normalizeEnvironment( raw ) {
 
 }
 
+const RENDER_KEYS = [ 'maxBounces', 'samples', 'width', 'height' ];
+
+function normalizeRender( raw ) {
+
+	const render = asObject( raw );
+	if ( ! render ) return null;
+
+	const normalized = {};
+	for ( const key of RENDER_KEYS ) {
+
+		const n = asNumber( render[ key ] );
+		if ( n !== undefined && n > 0 ) normalized[ key ] = Math.round( n );
+
+	}
+
+	return Object.keys( normalized ).length ? normalized : null;
+
+}
+
 /**
  * Reads scene metadata out of one `extras`-shaped container.
  * @param {Object|string|null} container
- * @returns {{ environment?: { sourceFile: string, rotation?: number, intensity?: number } }|null}
+ * @returns {{ environment?: { sourceFile: string, rotation?: number, intensity?: number }, render?: { maxBounces?: number, samples?: number, width?: number, height?: number } }|null}
  */
 export function parseSceneMetadata( container ) {
 
@@ -95,14 +118,16 @@ export function parseSceneMetadata( container ) {
 	if ( ! payload ) return null;
 
 	const environment = normalizeEnvironment( payload.environment );
-	return environment ? { environment } : null;
+	const render = normalizeRender( payload.render );
+	if ( ! environment && ! render ) return null;
+	return { ...( environment ? { environment } : {} ), ...( render ? { render } : {} ) };
 
 }
 
 /**
  * Reads scene metadata out of a GLTFLoader parse result.
  * @param {Object} gltf - The object GLTFLoader resolves with
- * @returns {{ environment?: { sourceFile: string, rotation?: number, intensity?: number } }|null}
+ * @returns {ReturnType<typeof parseSceneMetadata>}
  */
 export function extractSceneMetadata( gltf ) {
 

package/src/RayzeeRenderer.js

@@ -1216,8 +1216,9 @@ export class RayzeeRenderer extends EventDispatcher {
 	/**
 	 * Scene-level authoring metadata carried by the current model file (glTF `extras`),
 	 * or null when the file has none. See {@link module:Processor/SceneMetadata}. A pbrt scene
-	 * without an infinite light carries `environment: { enabled: false }`.
-	 * @type {{ environment?: { sourceFile?: string, rotation?: number, intensity?: number, enabled?: boolean } }|null}
+	 * without an infinite light carries `environment: { enabled: false }`. `render` is what the file asks
+	 * the renderer for (pbrt's maxdepth, pixelsamples and film resolution); nothing applies it.
+	 * @type {{ environment?: { sourceFile?: string, rotation?: number, intensity?: number, enabled?: boolean }, render?: { maxBounces?: number, samples?: number, width?: number, height?: number } }|null}
 	 */
 	get sceneMetadata() {
 

package/src/Stages/PathTracer.js

@@ -1443,12 +1443,10 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
-	/** The material layers the scene uses; bidirectional leaves diffuse transmission out (its paths do not cross surfaces). */
+	/** The material layers the scene uses. */
 	_layersToCompile() {
 
-		const layers = this.materialData.materialLayers();
-		if ( this._integrator ) layers.diffuseTransmission = false;
-		return layers;
+		return this.materialData.materialLayers();
 
 	}
 
@@ -2083,7 +2081,7 @@ export class PathTracer extends PathTracerStage {
 
 		this._integrator?.registerKernels( {
 			km: this._kernelManager, qm, pb, counters, bounceCountsBuf, wfCurrentBounce, copyReadB, copyWriteA, maxRays, w, own,
-			freshLight, freshTri, freshBvh, freshMat, freshEnvTex, freshEnvCDF,
+			freshLight, freshTri, freshBvh, freshMat, freshEnvTex, freshEnvCDF, materialLayers: this._compiledLayers,
 		} );
 
 		const fwFn = buildFinalWriteKernel( {

package/src/TSL/Bidirectional.js

@@ -156,8 +156,6 @@ export function resolveSurfaceMaterial( materialIndex, uv, N, materialBuffer ) {
 	material.normalMapIndex.assign( int( - 1 ) );
 	material.bumpMapIndex.assign( int( - 1 ) );
 	material.displacementMapIndex.assign( int( - 1 ) );
-	// Shade leaves diffuse transmission out in this integrator (its strategies do not cross surfaces yet).
-	material.diffuseTransmission.assign( 0.0 );
 
 	const samples = MaterialSamples.wrap( sampleAllMaterialTextures( material, uv, N, vec4( 0.0 ) ) ).toVar();
 	const rawRough = samples.roughness.toVar();
@@ -187,6 +185,8 @@ export function resolveSurfaceMaterial( materialIndex, uv, N, materialBuffer ) {
 	material.iridescenceThicknessRange.assign( vec2( material.iridescenceThicknessRange.x, ext.iridescenceThickness ) );
 	material.specularIntensity.assign( ext.specularIntensity );
 	material.specularColor.assign( ext.specularColor );
+	material.diffuseTransmission.assign( ext.diffuseTransmission );
+	material.diffuseTransmissionColor.assign( ext.diffuseTransmissionColor );
 
 	If( rawRough.lessThan( MIN_ROUGHNESS ).and( material.anisotropy.equal( 0.0 ) ).and( material.clearcoat.equal( 0.0 ) )
 		.and( material.transmission.equal( 0.0 ) ).and( material.subsurface.equal( 0.0 ) ), () => {
@@ -199,6 +199,10 @@ export function resolveSurfaceMaterial( materialIndex, uv, N, materialBuffer ) {
 
 }
 
+// The normal of the frame with `toward` on top: a surface that passes light through diffusely is seen from either side.
+export const facingSide = ( N, toward, material ) => select(
+	material.diffuseTransmission.greaterThan( 0.0 ).and( dot( N, toward ).lessThan( 0.0 ) ), N.negate(), N );
+
 // The light end's cosine with the shading-normal correction (Veach 5.3.2): |V·N| |d·Ng| / |V·Ng|.
 export const lightEndCosine = ( V, N, facetN, toOther ) =>
 	abs( dot( V, N ) ).mul( abs( dot( toOther, facetN ) ) ).div( max( abs( dot( V, facetN ) ), 1e-4 ) );

package/src/TSL/ConnectKernel.js

@@ -4,7 +4,7 @@
  */
 
 import {
-	Fn, float, vec2, vec4, int, uint, If, instanceIndex, atomicLoad, Return, dot, sqrt, min, max, length,
+	Fn, float, vec2, vec4, int, uint, If, instanceIndex, atomicLoad, Return, dot, sqrt, min, max, length, select, abs,
 } from 'three/tsl';
 
 import { getRandomSample1D, pcgHash, SAMPLER_DIMS_PER_BOUNCE } from './Random.js';
@@ -15,7 +15,7 @@ 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,
+	resolveSurfaceMaterial, lightEndCosine, misPartial, misWeight, strategyWeight, facingSide, STRATEGY, DIM_CONNECT_PATH, DIM_CONNECT_VERTEX,
 } from './Bidirectional.js';
 import { COUNTER } from '../Processor/QueueManager.js';
 import {
@@ -35,6 +35,8 @@ export function buildConnectKernel( params ) {
 		maxBounceCount, globalIlluminationIntensity, fireflyThreshold,
 		// Vertex merging's η² at a point (Bidirectional.js mergeVmAt), or null without it.
 		mergeVm = null,
+		// Some material passes light through diffusely: a connection may then reach either end from behind.
+		diffuseTransmission = true,
 	} = params;
 
 	return Fn( () => {
@@ -89,7 +91,15 @@ export function buildConnectKernel( params ) {
 		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 ) ), () => {
+		// Through a surface that transmits diffusely, either end may also be reached from behind (checked below).
+		const inFront = cosCamera.greaterThan( 0.0 ).and( cosCameraFacet.greaterThan( 0.0 ) ).and( cosLightFacet.greaterThan( 0.0 ) );
+		const cameraBehind = cosCamera.lessThan( 0.0 ).and( cosCameraFacet.lessThan( 0.0 ) );
+		const lightBehind = cosLightFacet.lessThan( 0.0 );
+		const possible = diffuseTransmission
+			? cameraBehind.or( cosCamera.greaterThan( 0.0 ).and( cosCameraFacet.greaterThan( 0.0 ) ) )
+				.and( lightBehind.or( cosLightFacet.greaterThan( 0.0 ) ) )
+			: inFront;
+		If( possible.not(), () => {
 
 			Return();
 
@@ -98,19 +108,28 @@ export function buildConnectKernel( params ) {
 		const cameraMaterial = resolveSurfaceMaterial( cam.materialIndex, cam.uv, cam.N, materialBuffer );
 		const lightMaterial = resolveSurfaceMaterial( light.materialIndex, light.uv, light.N, materialBuffer );
 		const toCamera = dir.negate();
+		if ( diffuseTransmission ) If( cameraBehind.and( cameraMaterial.diffuseTransmission.lessThanEqual( 0.0 ) )
+			.or( lightBehind.and( lightMaterial.diffuseTransmission.lessThanEqual( 0.0 ) ) ), () => {
 
+			Return();
+
+		} );
+
+		// Each end's BSDF and densities read in the frame with their own first direction on top.
+		const camN = ( toward ) => ( diffuseTransmission ? facingSide( cam.N, toward, cameraMaterial ) : cam.N );
+		const lightN = ( toward ) => ( diffuseTransmission ? facingSide( light.N, toward, lightMaterial ) : light.N );
 		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 fLight = evaluateMaterialResponse( toCamera, light.V, lightN( toCamera ), lightMaterial ).toVar();
+		const geometry = ( diffuseTransmission ? abs( cosCamera ) : 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 cameraReverse = calculateMaterialPDF( dir, cam.V, camN( dir ), cameraMaterial );
 		const lightForward = calculateMaterialPDF( light.V, toCamera, light.N, lightMaterial );
-		const lightReverse = calculateMaterialPDF( toCamera, light.V, light.N, lightMaterial );
+		const lightReverse = calculateMaterialPDF( toCamera, light.V, lightN( toCamera ), 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 wLight = misPartial( cameraForward.mul( diffuseTransmission ? abs( cosLightFacet ) : cosLightFacet ).div( dist2 ), light, lightReverse );
+		const wCamera = misPartial( lightForward.mul( diffuseTransmission ? abs( cosCameraFacet ) : 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.
@@ -123,8 +142,9 @@ export function buildConnectKernel( params ) {
 
 		If( luminance( contribution ).greaterThan( 0.0 ), () => {
 
-			const origin = offsetRayOrigin( cam.position, cam.facetN ).toVar();
-			const segment = offsetRayOrigin( light.position, light.facetN ).sub( origin ).toVar();
+			// Each end of the shadow ray leaves from the side the connection takes.
+			const origin = offsetRayOrigin( cam.position, diffuseTransmission ? select( cameraBehind, cam.facetN.negate(), cam.facetN ) : cam.facetN ).toVar();
+			const segment = offsetRayOrigin( light.position, diffuseTransmission ? select( lightBehind, light.facetN.negate(), light.facetN ) : light.facetN ).sub( origin ).toVar();
 			const segmentLength = length( segment ).toVar();
 			const visibility = traceShadowRayRefractiveOpaque(
 				origin, segment.div( segmentLength ), segmentLength.mul( SHADOW_END ),

package/src/TSL/LightSplatKernel.js

@@ -5,7 +5,7 @@
 
 import {
 	Fn, float, vec3, vec4, int, uint, If, instanceIndex, atomicAdd, atomicLoad, atomicStore, Return,
-	dot, sqrt, max, min, floor, length, localId, workgroupId,
+	dot, sqrt, max, min, floor, length, localId, workgroupId, select, abs,
 } from 'three/tsl';
 
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
@@ -15,7 +15,7 @@ import { traverseBVHShadowCameraCulled } from './BVHTraversal.js';
 import { offsetRayOrigin, SHADOW_END, sanitizeRGB } from './Common.js';
 import { pcgHash } from './Random.js';
 import { regularizePathContribution } from './PathTracerCore.js';
-import { resolveSurfaceMaterial, lightEndCosine, misPartial, misWeight, strategyWeight, STRATEGY, SPLAT_SCALE, SPLAT_MAX } from './Bidirectional.js';
+import { resolveSurfaceMaterial, lightEndCosine, misPartial, misWeight, strategyWeight, facingSide, STRATEGY, SPLAT_SCALE, SPLAT_MAX } from './Bidirectional.js';
 import {
 	cachedVertex, readVertexRecord, readLightPathLength, readRayRadiance, writeRayRadiance,
 } from '../Processor/PackedRayBuffer.js';
@@ -33,6 +33,8 @@ export function buildLightSplatKernel( params ) {
 		renderWidth, renderHeight,
 		globalIlluminationIntensity, fireflyThreshold, accumFrame, frame,
 		mergeVm = null,
+		// Some material passes light through diffusely: the camera may then see a light vertex from behind its surface.
+		diffuseTransmission = true,
 	} = params;
 
 	return Fn( () => {
@@ -60,8 +62,13 @@ export function buildLightSplatKernel( params ) {
 		const dir = toCamera.div( sqrt( dist2 ) ).toVar();
 		const cosFacet = dot( dir, v.facetN ).toVar();
 		const cosCamera = dot( dir, cameraForward ).negate().toVar();
-		// The camera is this vertex's viewer: like a camera path, only the facet decides which side it is on.
-		If( cosFacet.lessThanEqual( 0.0 ).or( cosCamera.lessThanEqual( 1e-6 ) ).or( v.extra.notEqual( uint( 0 ) ) ), () => {
+		// The camera is this vertex's viewer: like a camera path, only the facet decides which side it is on. Behind the
+		// surface (only through diffuse transmission, checked below) the cull flag is the far side's, bit 1.
+		const behind = cosFacet.lessThan( 0.0 );
+		const culled = diffuseTransmission
+			? select( behind, v.extra.bitAnd( uint( 2 ) ), v.extra.bitAnd( uint( 1 ) ) ).notEqual( uint( 0 ) )
+			: v.extra.notEqual( uint( 0 ) );
+		If( ( diffuseTransmission ? cosFacet.equal( 0.0 ) : cosFacet.lessThanEqual( 0.0 ) ).or( cosCamera.lessThanEqual( 1e-6 ) ).or( culled ), () => {
 
 			Return();
 
@@ -83,14 +90,22 @@ export function buildLightSplatKernel( params ) {
 		} );
 
 		const material = resolveSurfaceMaterial( v.materialIndex, v.uv, v.N, materialBuffer );
-		const f = evaluateMaterialResponse( dir, v.V, v.N, material ).toVar();
+		if ( diffuseTransmission ) If( behind.and( material.diffuseTransmission.lessThanEqual( 0.0 ) ), () => {
+
+			Return();
+
+		} );
+
+		// Read in the frame with the camera on top.
+		const viewN = diffuseTransmission ? facingSide( v.N, dir, material ) : v.N;
+		const f = evaluateMaterialResponse( dir, v.V, viewN, material ).toVar();
 
 		// The pinhole's solid-angle density for a uniform point in a pixel: 1 / (A_pixel cos³θ).
 		const cameraPdfW = float( 1.0 ).div( pixelArea.mul( cosCamera ).mul( cosCamera ).mul( cosCamera ) );
 		const toSurface = cameraPdfW.div( dist2 ).toVar();
 
 		// Georgiev (46); the camera side has no sum of its own.
-		const wLight = misPartial( toSurface.mul( cosFacet ).div( float( lightPaths ) ), v, calculateMaterialPDF( dir, v.V, v.N, material ) );
+		const wLight = misPartial( toSurface.mul( diffuseTransmission ? abs( cosFacet ) : cosFacet ).div( float( lightPaths ) ), v, calculateMaterialPDF( dir, v.V, viewN, material ) );
 		const bounces = c.add( uint( 1 ) );
 		const gi = float( 1.0 ).toVar();
 		If( bounces.greaterThan( uint( 1 ) ), () => {
@@ -105,7 +120,7 @@ export function buildLightSplatKernel( params ) {
 			float( c ), fireflyThreshold, int( accumFrame ),
 		).toVar();
 
-		const origin = offsetRayOrigin( v.position, v.facetN ).toVar();
+		const origin = offsetRayOrigin( v.position, diffuseTransmission ? select( behind, v.facetN.negate(), v.facetN ) : v.facetN ).toVar();
 		const segment = cameraPosition.sub( origin ).toVar();
 		const segmentLength = length( segment ).toVar();
 		// This segment stands in for the primary ray, which sees through the faces it culls.

package/src/TSL/MergeKernel.js

@@ -12,14 +12,14 @@
 
 import {
 	Fn, float, vec3, vec4, int, uint, ivec3, If, Loop, instanceIndex, atomicLoad, atomicStore, atomicFunc, Return, dot, floor, max, min, select,
-	length, log2, exp2, Break,
+	length, log2, exp2, Break, abs,
 } from 'three/tsl';
 
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import { calculateMaterialPDF } from './LightsSampling.js';
 import { luminance } from './Common.js';
 import { regularizePathContribution } from './PathTracerCore.js';
-import { resolveSurfaceMaterial, misMergePartial, misWeight, strategyWeight, mergeRadiusAt, mergeEta, STRATEGY } from './Bidirectional.js';
+import { resolveSurfaceMaterial, misMergePartial, misWeight, strategyWeight, mergeRadiusAt, mergeEta, facingSide, STRATEGY } from './Bidirectional.js';
 import { COUNTER } from '../Processor/QueueManager.js';
 import {
 	readRayRadiance, writeRayRadiance, pendingVertex, cachedVertex, readVertexTag, readVertexRecord, readVertexPosition,
@@ -105,6 +105,8 @@ export function buildMergeKernel( params ) {
 	const {
 		rayBufferRW, hitBufferRO, activeIndicesRO, counters, head, materialBuffer, bidirectional: bdpt,
 		maxBounceCount, globalIlluminationIntensity, fireflyThreshold, accumFrame,
+		// Some material passes light through diffusely: light arriving from behind its surface merges too.
+		diffuseTransmission = true,
 	} = params;
 	const { passTag, slotsPerPath, strategyView, hashMask } = bdpt;
 
@@ -173,19 +175,23 @@ export function buildMergeKernel( params ) {
 						const light = readVertexRecord( hitBufferRO, at );
 						const cosShading = dot( light.V, cam.N ).toVar();
 						const cosFacet = dot( light.V, cam.facetN ).toVar();
-						// Light arriving on this side. A corner's other wall stays in: its light vertices stand in for the
-						// part of the sphere past the corner, which the density divides by too.
-						If( cosShading.greaterThan( 0.0 ).and( cosFacet.greaterThan( 0.0 ) ), () => {
+						// Light arriving on this side, or from behind a surface that passes it through diffusely. A corner's
+						// other wall stays in: its light vertices stand in for the part of the sphere past the corner, which
+						// the density divides by too.
+						const onThisSide = cosShading.greaterThan( 0.0 ).and( cosFacet.greaterThan( 0.0 ) );
+						const throughSurface = material.diffuseTransmission.greaterThan( 0.0 ).and( cosShading.lessThan( 0.0 ) ).and( cosFacet.lessThan( 0.0 ) );
+						If( diffuseTransmission ? onThisSide.or( throughSurface ) : onThisSide, () => {
 
 							const f = evaluateMaterialResponse( cam.V, light.V, cam.N, material );
 							const wLight = misMergePartial( light, calculateMaterialPDF( cam.V, light.V, cam.N, material ), vc );
-							const wCamera = misMergePartial( cam, calculateMaterialPDF( light.V, cam.V, cam.N, material ), vc );
+							const reverseN = diffuseTransmission ? facingSide( cam.N, light.V, material ) : cam.N;
+							const wCamera = misMergePartial( cam, calculateMaterialPDF( light.V, cam.V, reverseN, material ), vc );
 							const scattering = cameraDepth.add( l );
 							// Alone, a path of k scattering vertices is reached by k merges.
 							const weight = strategyWeight( strategyView, STRATEGY.MERGE, misWeight( wLight, wCamera ), float( 1.0 ).div( float( scattering ) ) );
 							const gi = select( scattering.greaterThan( int( 1 ) ), globalIlluminationIntensity, float( 1.0 ) );
 							// The photon's flux is per unit area; the BSDF wants it per projected solid angle (Veach 5.3.2).
-							const correction = cosShading.div( max( cosFacet, 1e-4 ) );
+							const correction = diffuseTransmission ? abs( cosShading ).div( max( abs( cosFacet ), 1e-4 ) ) : cosShading.div( max( cosFacet, 1e-4 ) );
 							gathered.addAssign( regularizePathContribution(
 								cam.throughput.mul( f ).mul( light.throughput ).mul( weight.mul( correction ).div( eta ).mul( gi ) ),
 								float( scattering.sub( int( 1 ) ) ), fireflyThreshold, int( accumFrame ),