three-gpu-pathtracer 0.0.26 → 0.0.28

package/src/webgpu/index.d.ts

@@ -1,5 +1,53 @@
-import { Camera, Scene, Texture, ExternalTexture } from 'three';
-import { WebGPURenderer } from 'three/webgpu';
+import { Camera, Color, EventDispatcher, Scene, Texture, ExternalTexture } from 'three';
+import { StorageArrayTexture, WebGPURenderer } from 'three/webgpu';
+import { BVHWorker } from '../index.js';
+
+// three.js type augmentation
+
+declare module 'three' {
+
+	export interface Material {
+
+		matte?: boolean;
+		castShadow?: boolean;
+
+	}
+
+	// volume scattering from "KHR_materials_scatter"
+	export interface MeshPhysicalMaterial {
+
+		scatterStrength?: number;
+		multiscatterColor?: Color;
+		scatterAnisotropy?: number;
+
+	}
+
+	export interface Object3D {
+
+		visibleToShadowRays?: boolean;
+
+	}
+
+	export interface Light {
+
+		visibleToCameraRays?: boolean;
+
+	}
+
+	export interface SpotLight {
+
+		radius?: number;
+		iesMap?: Texture | null;
+
+	}
+
+	export interface RectAreaLight {
+
+		isCircular?: boolean;
+
+	}
+
+}
 
 // constants
 
@@ -64,7 +112,14 @@ export interface OIDNDenoiserOptions {
 
 }
 
-export class OIDNDenoiser {
+export interface OIDNDenoiserEventMap {
+
+	'error': { error: Error };
+	'progress': { progress: number };
+
+}
+
+export class OIDNDenoiser extends EventDispatcher<OIDNDenoiserEventMap> {
 
 	constructor( options: OIDNDenoiserOptions );
 
@@ -80,8 +135,7 @@ export class OIDNDenoiser {
 	readonly running: boolean;
 
 	init( renderer: WebGPURenderer ): void;
-	setScene( scene: Scene, camera: Camera ): void;
-	update( target: Texture ): Texture | null;
+	update( target: Texture, aux?: StorageArrayTexture | null ): Texture | null;
 	denoise( color: Texture, albedo?: Texture | null, normal?: Texture | null ): Promise<void>;
 	reset(): void;
 	dispose(): void;
@@ -117,13 +171,23 @@ export interface DebugBoundsOptions {
 
 }
 
-export class WebGPUPathTracer {
+export interface WebGPUPathTracerEventMap {
+
+	'complete': {};
+	'progress': { stage: 'building' | 'compiling' | 'rendering' | 'denoising', progress: number | null, samples?: SampleCounts };
+
+}
+
+export class WebGPUPathTracer extends EventDispatcher<WebGPUPathTracerEventMap> {
 
 	constructor( renderer: WebGPURenderer );
 
 	maxBounces: number;
 	frameBudget: number;
+	adaptiveFrameBudget: boolean;
+	targetFrameTime: number;
 	maxTransparentBounces: number;
+	maxSubsurfaceBounces: number;
 	maxSamples: number;
 	transmissiveBackground: TransmissiveBackgroundMode;
 	filterGlossyFactor: number;
@@ -136,17 +200,23 @@ export class WebGPUPathTracer {
 	fadeDuration: number;
 	dynamicLowRes: boolean;
 	lowResScale: number;
+	adaptiveDynamicRes: boolean;
 	renderScale: number;
 	synchronizeRenderSize: boolean;
+	renderToCanvas: boolean;
+	asyncCompile: boolean;
 	generateMissingAttributes: boolean;
 	commonAttributes: Array<string>;
 	stableNoise: boolean;
 	pause: boolean;
 
 	readonly target: Texture | null;
+	readonly frameTime: number;
+	readonly complete: boolean;
 	readonly fadeState: number;
 	readonly lowResTarget: Texture;
 	readonly lowResMode: boolean;
+	readonly compiling: boolean;
 	readonly textureAtlas: AtlasTexture;
 
 	getSampleCountsAsync(): Promise<SampleCounts>;
@@ -155,6 +225,8 @@ export class WebGPUPathTracer {
 	setUpscaler( upscaler: FSRUpscaler | null ): void;
 
 	setScene( scene: Scene, camera: Camera ): void;
+	setBVHWorker( WorkerConstructor: new () => BVHWorker & { dispose(): void } ): void;
+	setSceneAsync( scene: Scene, camera: Camera ): Promise<void>;
 	setRandom( random: RandomStrategy ): void;
 	setCamera( camera: Camera ): void;
 	setSize( x: number, y: number ): void;
@@ -170,6 +242,7 @@ export class WebGPUPathTracer {
 	renderDebugBounds( options?: DebugBoundsOptions ): void;
 	renderTextureAtlas( layer?: number ): void;
 	renderSampleDensity(): void;
+	renderAuxBuffer( buffer?: 'albedo' | 'normal' ): void;
 	getRenderTime(): number;
 	dispose(): void;
 

package/src/webgpu/materials/GltfCompliantMaterial.js

@@ -160,8 +160,10 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 
 						}
 
-						// the refracted half is not attenuated by the layers above
-						result += ( 1.0 - surf.metalness ) * surf.transmission * refraction * surf.color;
+						// the refracted half is not attenuated by the layers above. A volume is entered and exited,
+						// so each crossing takes the square root of the color, as in Cycles
+						let transmissionTint = select( sqrt( surf.color ), surf.color, surf.thinWall );
+						result += ( 1.0 - surf.metalness ) * surf.transmission * refraction * transmissionTint;
 
 					} else {
 
@@ -228,11 +230,15 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 					let metallic = metallicSpecular * metallicReflectance;
 					let dielectric = dielectricSpecular * dielectricReflectance;
 
-					// the energy the specular interface takes from the layers below
-					let fresnelEnergySS = ${ this.turquinTexture.sampleDielectricFn }( NdotV, surf.roughness, surf.ior ) * dielectricBoost;
+					// The energy the specular interface takes from the layers below, at the lobe's specular color
+					// and intensity. The table holds the albedo at the ior's f0, and the Schlick albedo is linear
+					// in f0, so the tinted albedo slides from it toward the conductor albedo at f0 = 1
+					let iorEnergySS = ${ this.turquinTexture.sampleDielectricFn }( NdotV, surf.roughness, surf.ior );
+					let tintedEnergySS = iorEnergySS + ( dielectricF0 - surf.f0 ) * ( energySS - iorEnergySS ) / ( 1.0 - surf.f0 );
+					let fresnelEnergySS = surf.specularIntensity * tintedEnergySS * dielectricBoost;
 
 					result += attenuation * mix( ( 1.0 - surf.transmission ) * dielectric, metallic, surf.metalness );
-					attenuation *= ( 1.0 - surf.metalness ) * mix( 1.0 - fresnelEnergySS, 1.0 - filmFresnelMax, surf.iridescence );
+					attenuation *= ( 1.0 - surf.metalness ) * mix( 1.0 - fresnelEnergySS, vec3f( 1.0 - filmFresnelMax ), surf.iridescence );
 
 				}
 
@@ -385,6 +391,13 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 
 						wi = refract( - wo, wh, surf.eta );
 
+						// "refract" returns zero on total internal reflection, so reflect instead and let "isDead" drop it
+						if ( dot( wi, wi ) == 0.0 ) {
+
+							wi = - normalize( reflect( wo, wh ) );
+
+						}
+
 					}
 
 					// the facet choice must agree with the resulting hemisphere - reflection above,
@@ -417,7 +430,8 @@ export class GltfCompliantMaterial extends PathtracingMaterial {
 
 					// Cycles represents a singular event with a large matching BSDF and PDF. Their
 					// ratio preserves throughput while forward MIS correctly gives the event full weight.
-					result.color = ( 1.0 - surf.metalness ) * surf.transmission * surf.color *
+					let transmissionTint = select( sqrt( surf.color ), surf.color, surf.thinWall );
+					result.color = ( 1.0 - surf.metalness ) * surf.transmission * transmissionTint *
 						deltaTransmittance * ${ SINGULAR_EVENT_SCALE };
 					result.direction = worldWi;
 					result.pdf = weights.transmission * deltaProbability * ${ SINGULAR_EVENT_SCALE };

package/src/webgpu/materials/debug/AuxDebugMaterial.js

@@ -0,0 +1,54 @@
+import { MeshBasicNodeMaterial, NoBlending } from 'three/webgpu';
+import { uv, varying, texture, uniform } from 'three/tsl';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { createAuxTarget } from '../../compute/targets.js';
+import { unpackAuxAlbedoFn, unpackAuxNormalFn, AUX_LAYERS } from '../../nodes/aux.wgsl.js';
+
+// Shows the albedo or normal the path tracer accumulates for the denoiser
+export class AuxDebugMaterial extends MeshBasicNodeMaterial {
+
+	set texture( v ) {
+
+		this._texNode.value = v;
+
+	}
+
+	set showNormal( v ) {
+
+		this._showNormalUniform.value = v ? 1 : 0;
+
+	}
+
+	constructor() {
+
+		super();
+
+		this.blending = NoBlending;
+
+		this._texNode = texture( createAuxTarget() );
+		this._showNormalUniform = uniform( 0, 'uint' );
+
+		const auxDebug = wgslTagFn/* wgsl */`
+			fn auxDebug( tex: texture_2d_array<u32>, coord: vec2f, showNormal: u32 ) -> vec4f {
+
+				// the rows are stored top down, so the quad's bottom up uv is flipped
+				let texel = vec2u( vec2f( coord.x, 1.0 - coord.y ) * vec2f( textureDimensions( tex, 0 ) ) );
+				var packed: vec3u;
+				for ( var layer = 0u; layer < ${ AUX_LAYERS }u; layer ++ ) {
+
+					packed[ layer ] = textureLoad( tex, texel, layer, 0 ).r;
+
+				}
+
+				let albedo = ${ unpackAuxAlbedoFn }( packed );
+				let normal = ${ unpackAuxNormalFn }( packed );
+				return vec4f( select( albedo, normal, showNormal == 1u ), 1.0 );
+
+			}
+		`;
+
+		this.colorNode = auxDebug( this._texNode, varying( uv() ), this._showNormalUniform );
+
+	}
+
+}

package/src/webgpu/nodes/PathtracerBVHComputeData.js

@@ -1,6 +1,6 @@
 import { BackSide, FrontSide, DoubleSide, BufferAttribute, BufferGeometry, StorageBufferAttribute, StructTypeNode, Vector4, SkinnedMesh, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, NearestFilter } from 'three/webgpu';
-import { BVHComputeData, intersectRayTriangle, bvhNodeBoundsStruct, bvhNodeStruct, rayStruct, rayIntersectionResultStruct as intersectionResultStruct, wgslTagFn } from 'three-mesh-bvh/webgpu';
-import { storage, float, texture, uniformArray, uint } from 'three/tsl';
+import { BVHComputeData, intersectRayTriangle, bvhNodeBoundsStruct, bvhNodeStruct, rayStruct, wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { storage, float, bool, texture, uniformArray, uint } from 'three/tsl';
 import { SkinnedMeshBVH, MeshBVH, SAH } from 'three-mesh-bvh';
 import { materialStruct } from './structs.wgsl.js';
 import { getTextureHash } from '../../core/utils/sceneUpdateUtils.js';
@@ -14,11 +14,25 @@ const transformStruct = new StructTypeNode( {
 	inverseMatrixWorld: 'mat4x4f',
 	visible: 'uint',
 	materialIndex: 'uint',
+	visibleToShadowRays: 'uint',
 	_alignment0: 'uint',
-	_alignment1: 'uint',
 	color: 'vec4f',
 }, 'TransformStruct' );
 
+// three-mesh-bvh's ray hit result. Shadow rays also record the share of bsdf rays the faces they skipped
+// would stop, and the share of light the partially transparent surfaces they passed block
+const intersectionResultStruct = new StructTypeNode( {
+	indices: 'vec4u',
+	normal: 'vec3f',
+	didHit: 'bool',
+	barycoord: 'vec3f',
+	objectIndex: 'uint',
+	side: 'float',
+	dist: 'float',
+	skippedOcclusion: 'float',
+	occlusion: 'float',
+}, 'PathTracerIntersectionResult' );
+
 // Pathtracer-specific version of the BVHComputeData tht includes material mapping, property structs
 export class PathtracerBVHComputeData extends BVHComputeData {
 
@@ -167,7 +181,7 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 		const { textureAtlas, storage, fns } = this;
 		const textures = textureAtlas.texture;
-		const textureInfo = uniformArray( textureAtlas.textureInfo, 'uvec4' );
+		const textureInfo = uniformArray( textureAtlas.textureInfo, 'uvec4' ).setName( 'bvh_textureInfo' );
 
 		// build the single sampleTexel bound to this instance's textureInfo node
 		const sampleTexel = sampleTexelFunc( textureInfo, texture( textures ) );
@@ -181,8 +195,12 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 		const scratchRayScalar = float( 1.0 ).toVar( 'bvh_rayScalar' );
 		const baseOpacityScalar = float( 1.0 ).toVar( 'bvh_baseOpacity' );
 
-		fns.raycastFirstHit = this.getShapecastFn( {
-			name: 'raycastFirstHit',
+		// shadow rays hit both sides, pass through the objects not visible to them and partially transparent
+		// surfaces, and stop at the first opaque hit
+		const isShadowRay = bool( false ).toVar( 'bvh_isShadowRay' );
+		const skipShadowObject = bool( false ).toVar( 'bvh_skipShadowObject' );
+
+		const raycastOptions = {
 			shapeStruct: rayStruct,
 			resultStruct: intersectionResultStruct,
 
@@ -196,8 +214,8 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 			intersectsBoundsFn: wgslTagFn/* wgsl */`
 				fn rayIntersectsBounds( ray: ${ rayStruct }, bounds: ${ bvhNodeBoundsStruct }, result: ptr<function, ${ intersectionResultStruct }> ) -> u32 {
 
-					// early-out if our object is completely transparent
-					if ( ${ baseOpacityScalar } == 0.0 ) {
+					// early-out if our object is completely transparent, or a shadow ray is already occluded
+					if ( ${ baseOpacityScalar } == 0.0 || ( ${ isShadowRay } && result.didHit ) ) {
 
 						return 0u;
 
@@ -259,16 +277,16 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 							let material = ${ storage.materials }[ ${ currentMaterialIndex } ];
 
 							// TODO: if material is a transmissive volume we may need to assume double-sidedness
-							if ( material.side != 0 && triResult.side != material.side ) {
+							// shadow rays hit both sides
+							if ( ! ${ isShadowRay } && material.side != 0 && triResult.side != material.side ) {
 
 								continue;
 
 							}
 
+							var opacity = ${ baseOpacityScalar };
 							if ( material.transparent != 0 || material.alphaTest > 0.0 ) {
 
-								var opacity = ${ baseOpacityScalar };
-
 								// add support for vertex color opacity
 								if ( material.vertexColors == 1 ) {
 
@@ -325,6 +343,29 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 							}
 
+							// shadow rays skip the objects not visible to them. Record the share of bsdf rays this face
+							// would stop: all of them if it's opaque, its opacity if it's partially transparent
+							if ( ${ skipShadowObject } ) {
+
+								if ( material.side == 0 || triResult.side == material.side ) {
+
+									result.skippedOcclusion += ( 1.0 - result.skippedOcclusion ) * select( 1.0, opacity, material.transparent != 0 );
+
+								}
+
+								continue;
+
+							}
+
+							// shadow rays pass partially transparent surfaces, each blocking its opacity's share of the
+							// light still getting through, just as bsdf rays pass them by chance
+							if ( ${ isShadowRay } && material.transparent != 0 && opacity < 1.0 ) {
+
+								result.occlusion += ( 1.0 - result.occlusion ) * opacity;
+								continue;
+
+							}
+
 							result.didHit = true;
 							result.dist = triResult.dist;
 							result.normal = triResult.normal;
@@ -367,6 +408,8 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 					}
 
+					${ skipShadowObject } = ${ isShadowRay } && object.visibleToShadowRays == 0u;
+
 				}
 			`,
 			transformResultFn: wgslTagFn/* wgsl */`
@@ -384,6 +427,30 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 					${ scratchRayScalar } = 1.0;
 					${ baseOpacityScalar } = 1.0;
 
+				}
+			`,
+		};
+
+		fns.raycastFirstHit = this.getShapecastFn( {
+			...raycastOptions,
+			name: 'raycastFirstHit',
+			prefixFn: wgslTagFn/* wgsl */`
+				fn initFirstHitCull() -> void {
+
+					${ isShadowRay } = false;
+
+				}
+			`,
+		} );
+
+		fns.raycastShadow = this.getShapecastFn( {
+			...raycastOptions,
+			name: 'raycastShadow',
+			prefixFn: wgslTagFn/* wgsl */`
+				fn initShadowCull() -> void {
+
+					${ isShadowRay } = true;
+
 				}
 			`,
 		} );
@@ -398,6 +465,9 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 		this.updateUvAttributesFromScene();
 
+		// the material indices are written with the transforms
+		this.updateMaterialsMap();
+
 		super.update();
 
 		// build the channel -> uv lookup now that the geometry struct (and its uv members) exist
@@ -423,7 +493,7 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 				if ( Array.isArray( o.material ) ) {
 
-					o.material.forEach( m => add( m ) );
+					o.material.forEach( m => m && add( m ) );
 
 				} else {
 
@@ -716,9 +786,8 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 			floatArray[ index ++ ] = getField( m, 'iridescenceIOR', 1.3 );
 
 			// offset 32
-			const iridescenceThicknessRange = getField( m, 'iridescenceThicknessRange', [ 100, 400 ] );
-			floatArray[ index ++ ] = iridescenceThicknessRange[ 0 ];
-			floatArray[ index ++ ] = iridescenceThicknessRange[ 1 ];
+			floatArray[ index ++ ] = getField( m, 'iridescenceThicknessMinimum', 100 );
+			floatArray[ index ++ ] = getField( m, 'iridescenceThicknessMaximum', 400 );
 			floatArray[ index ++ ] = getField( m, 'diffuseRoughness', 0.0 );
 			floatArray[ index ++ ] = getField( m, 'dispersion', 0.0 );
 
@@ -885,6 +954,17 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 			// anisotropyMap transform - offset 264
 			index += writeTextureMatrixToArray( m, 'anisotropyMap', floatArray, index );
 
+			// scattering volume - offset 276
+			const multiscatterColor = getField( m, 'multiscatterColor', null );
+			floatArray[ index ++ ] = multiscatterColor ? multiscatterColor.r : 1.0;
+			floatArray[ index ++ ] = multiscatterColor ? multiscatterColor.g : 1.0;
+			floatArray[ index ++ ] = multiscatterColor ? multiscatterColor.b : 1.0;
+			floatArray[ index ++ ] = getField( m, 'scatterStrength', 0.0 );
+			floatArray[ index ++ ] = getField( m, 'scatterAnisotropy', 0.0 );
+
+			// padding to the struct's 16 byte alignment
+			index += 3;
+
 		}
 
 		return { materialData: intArray, textures };
@@ -906,9 +986,17 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 		}
 
-		// save the index
-		const index = materialsMap.get( material ) || 0;
 		const transformBufferU32 = new Uint32Array( targetBuffer );
+
+		const index = materialsMap.has( material ) ? materialsMap.get( material ) : - 1;
+		if ( index === - 1 ) {
+
+			// hide the object when there is no material
+			transformBufferU32[ writeOffset * transformStruct.getLength() + 32 ] = 0;
+
+		}
+
+		// save the material index
 		transformBufferU32[ writeOffset * transformStruct.getLength() + 33 ] = index;
 
 		// write color
@@ -939,6 +1027,10 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 		super.writeTransformData( info, premultiplyMatrix, writeOffset, targetBuffer );
 		this.writeMaterialData( info, writeOffset, targetBuffer );
 
+		// whether shadow rays see the object, in the slot after the material index
+		const transformBufferU32 = new Uint32Array( targetBuffer );
+		transformBufferU32[ writeOffset * this.structs.transform.getLength() + 34 ] = info.object.visibleToShadowRays === false ? 0 : 1;
+
 	}
 
 	getBVH( object, instanceId, rangeTarget ) {

package/src/webgpu/nodes/aux.wgsl.js

@@ -0,0 +1,61 @@
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { scatterRecordStruct, surfaceRecordStruct } from './structs.wgsl.js';
+
+// The denoiser's auxiliary images, the first hit albedo and normal, accumulate in an "r32uint" array
+// texture, the one kind of storage texture core WebGPU can both read and write. Each layer packs two
+// halves: albedo.rg, then albedo.b and normal.z, then normal.xy. Normals are mapped to [0,1].
+export const AUX_LAYERS = 3;
+
+// the smooth metals the auxiliary images look past to what they reflect, as in mutracer
+const AUX_MIRROR_MAX_ROUGHNESS = 0.02;
+const AUX_MIRROR_MIN_METALNESS = 0.98;
+
+// whether a scatter shows its surface in the auxiliary images, rather than looking past it through a
+// transmission or a mirror
+export const isAuxSurfaceFn = wgslTagFn/* wgsl */`
+
+	fn isAuxSurface( surface: ${ surfaceRecordStruct }, scatterRec: ${ scatterRecordStruct } ) -> bool {
+
+		let isMirror = surface.roughness <= ${ AUX_MIRROR_MAX_ROUGHNESS } && surface.metalness >= ${ AUX_MIRROR_MIN_METALNESS };
+		return ! scatterRec.isTransmissive && ! isMirror;
+
+	}
+
+`;
+
+export const unpackAuxAlbedoFn = wgslTagFn/* wgsl */`
+
+	fn unpackAuxAlbedo( packed: vec3u ) -> vec3f {
+
+		return vec3f( unpack2x16float( packed.x ), unpack2x16float( packed.y ).x );
+
+	}
+
+`;
+
+export const unpackAuxNormalFn = wgslTagFn/* wgsl */`
+
+	fn unpackAuxNormal( packed: vec3u ) -> vec3f {
+
+		return vec3f( unpack2x16float( packed.z ), unpack2x16float( packed.y ).y );
+
+	}
+
+`;
+
+// blends a sample's albedo and normal into the packed running means
+export const blendAuxFn = wgslTagFn/* wgsl */`
+
+	fn blendAux( packed: vec3u, albedo: vec3f, normal: vec3f, weight: f32 ) -> vec3u {
+
+		let meanAlbedo = mix( ${ unpackAuxAlbedoFn }( packed ), albedo, weight );
+		let meanNormal = mix( ${ unpackAuxNormalFn }( packed ), normal * 0.5 + 0.5, weight );
+		return vec3u(
+			pack2x16float( meanAlbedo.rg ),
+			pack2x16float( vec2f( meanAlbedo.b, meanNormal.z ) ),
+			pack2x16float( meanNormal.xy ),
+		);
+
+	}
+
+`;

package/src/webgpu/nodes/eon.wgsl.js

@@ -119,7 +119,7 @@ const eonLtcBasisFunc = wgslFn( /* wgsl */ `
 	fn eonLtcBasis( wo: vec3f ) -> mat3x3f {
 
 		let lenSqr = dot( wo.xy, wo.xy );
-		let invLen = inverseSqrt( max( lenSqr, 1e-7 ) );
+		let invLen = inverseSqrt( lenSqr );
 		let x = select(
 			vec3f( 1.0, 0.0, 0.0 ),
 			vec3f( wo.x, wo.y, 0.0 ) * invLen,

package/src/webgpu/nodes/lights.wgsl.js

@@ -11,7 +11,7 @@ export const POINT_LIGHT_TYPE = 4;
 export const ENVIRONMENT_LIGHT_TYPE = 5;
 export const LIGHT_FAR_DISTANCE = 1e30;
 
-// tolerance for comparing a shadow hit distance to the sampled light distance
+// fraction of the light distance a shadow ray stops short of the light
 export const LIGHT_EPSILON = 1e-5;
 
 // light kinds that are also bsdf-sampled and so take MIS-weighted NEE - punctual lights take full weight
@@ -201,3 +201,23 @@ export const randomSpotLightSampleFn = wgslFn( /* wgsl */ `
 	}
 
 `, [ lightStruct, lightRecordStruct, constants, getDistanceAttenuationFn ] );
+
+// The cosine to the spot axis and the distance from a position to the nearest point on the spot
+// light's disc, where the disc lights the position the most
+export const getSpotLightNearestFn = wgslFn( /* wgsl */ `
+
+	fn getSpotLightNearest( light: Light, position: vec3f ) -> vec2f {
+
+		let normal = normalize( cross( light.u, light.v ) );
+		let startDistance = light.radius / max( tan( acos( light.coneCos ) ), EPSILON );
+		let discCenter = light.position - normal * startDistance;
+
+		let toPosition = position - discCenter;
+		let along = dot( toPosition, - normal );
+		let across = max( length( toPosition + normal * along ) - light.radius, 0.0 );
+		let dist = length( vec2f( along, across ) );
+		return vec2f( along / max( dist, EPSILON ), dist );
+
+	}
+
+`, [ lightStruct, constants ] );

package/src/webgpu/nodes/material.wgsl.js

@@ -848,7 +848,8 @@ export const transmissionFresnelFunc = ( iridescentFresnel = iridescentFresnelFu
 		// Include the base-color tint in the transmission energy, as Cycles does when it
 		// computes the glass reflection probability from its two tinted coefficients.
 		let reflectEnergy = dot( reflectance, vec3f( 1.0 / 3.0 ) );
-		let transmitEnergy = dot( transmittance * surf.color, vec3f( 1.0 / 3.0 ) );
+		let transmissionTint = select( sqrt( surf.color ), surf.color, surf.thinWall );
+		let transmitEnergy = dot( transmittance * transmissionTint, vec3f( 1.0 / 3.0 ) );
 		let totalEnergy = reflectEnergy + transmitEnergy;
 		result.reflectProbability = select( 0.0, reflectEnergy / max( totalEnergy, EPSILON ), totalEnergy > EPSILON );