three-gpu-pathtracer 0.0.26 → 0.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-gpu-pathtracer",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "Path tracing renderer and utilities for three.js built on top of three-mesh-bvh.",
   "module": "src/index.js",
   "main": "build/index.umd.cjs",
@@ -43,7 +43,7 @@
   "devDependencies": {
     "@lookingglass/webxr": "^0.6.0",
     "@monogrid/gainmap-js": "^3.0.5",
-    "@pmndrs/upscaler": "^0.2.0",
+    "@pmndrs/upscaler": "^0.3.0",
     "@types/node": "^24.3.1",
     "@types/three": "^0.185.1",
     "@typescript-eslint/eslint-plugin": "^8.40.0",

package/src/core/utils/sceneUpdateUtils.js

@@ -78,7 +78,8 @@ export function getLights( scene ) {
 			c.isRectAreaLight ||
 			c.isSpotLight ||
 			c.isPointLight ||
-			c.isDirectionalLight
+			c.isDirectionalLight ||
+			c.isSunLight
 		) {
 
 			lights.push( c );

package/src/uniforms/LightsInfoUniformStruct.js

@@ -2,6 +2,7 @@ import { DataTexture, RGBAFormat, ClampToEdgeWrapping, FloatType, Vector3, Quate
 import { bufferToHash } from '../utils/bufferToHash.js';
 
 const LIGHT_PIXELS = 6;
+const VISIBLE_TO_CAMERA_OFFSET = 11;
 const RECT_AREA_LIGHT = 0;
 const CIRC_AREA_LIGHT = 1;
 const SPOT_LIGHT = 2;
@@ -82,7 +83,7 @@ export class LightsInfoUniformStruct {
 
 				type = SPOT_LIGHT;
 
-			} else if ( l.isDirectionalLight ) {
+			} else if ( l.isDirectionalLight || l.isSunLight ) {
 
 				type = DIR_LIGHT;
 
@@ -207,8 +208,22 @@ export class LightsInfoUniformStruct {
 				floatArray[ baseIndex + ( index ++ ) ] = target.y;
 				floatArray[ baseIndex + ( index ++ ) ] = target.z;
 
+			} else if ( l.isSunLight ) {
+
+				// the sun has no target and shines from its position toward the origin
+				target.setFromMatrixPosition( l.matrixWorld ).normalize();
+
+				// sample 3
+				// u vector
+				floatArray[ baseIndex + ( index ++ ) ] = target.x;
+				floatArray[ baseIndex + ( index ++ ) ] = target.y;
+				floatArray[ baseIndex + ( index ++ ) ] = target.z;
+
 			}
 
+			// whether camera rays see the light
+			floatArray[ baseIndex + VISIBLE_TO_CAMERA_OFFSET ] = l.visibleToCameraRays ? 1 : 0;
+
 		}
 
 		this.count = lights.length;

package/src/webgpu/AtlasTexture.js

@@ -6,10 +6,12 @@ import {
 	NoBlending,
 	Color,
 	Vector4,
+	Matrix3,
 } from 'three/webgpu';
 
 const MAX_TEXTURE_SIZE = 4096;
 const _prevClearColor = new Color();
+const _prevMatrix = new Matrix3();
 
 function getTextureHash( texture ) {
 
@@ -438,21 +440,40 @@ export class AtlasTexture {
 		for ( let i = 0, l = textures.length; i < l; i ++ ) {
 
 			const { x, y, w, h, page } = placements[ i ];
-
-			// Clone the source so we get an independent texture handle
-			const texture = textures[ i ].clone();
-			texture.matrixAutoUpdate = false;
-			texture.matrix.identity();
-
-			quadMesh.material.map = texture;
+			const texture = textures[ i ];
 
 			// three.js uses the render target viewport / scissor
 			renderTarget.viewport.set( x, y, w, h );
 			renderTarget.scissor.set( x, y, w, h );
 			renderer.setRenderTarget( renderTarget, page );
-			quadMesh.render( renderer );
 
-			texture.dispose();
+			if ( texture.isRenderTargetTexture ) {
+
+				// a render target's content only lives on the GPU, so draw it directly
+				const prevAutoUpdate = texture.matrixAutoUpdate;
+				_prevMatrix.copy( texture.matrix );
+				texture.matrix.identity();
+				texture.matrixAutoUpdate = false;
+
+				quadMesh.material.map = texture;
+				quadMesh.render( renderer );
+
+				texture.matrixAutoUpdate = prevAutoUpdate;
+				texture.matrix.copy( _prevMatrix );
+
+			} else {
+
+				// Clone the source so we get an independent texture handle
+				const clone = texture.clone();
+				clone.matrixAutoUpdate = false;
+				clone.matrix.identity();
+
+				quadMesh.material.map = clone;
+				quadMesh.render( renderer );
+
+				clone.dispose();
+
+			}
 
 		}
 

package/src/webgpu/EquirectHdrInfoNode.js

@@ -1,5 +1,5 @@
 import { Matrix3 } from 'three/webgpu';
-import { texture, sampler, uniform, wgslFn } from 'three/tsl';
+import { texture, sampler, uniform, wgslFn, PI } from 'three/tsl';
 import { EquirectHdrInfoUniform } from '../uniforms/EquirectHdrInfoUniform.js';
 import { wgslTagFn } from 'three-mesh-bvh/webgpu';
 import { constants, environmentSampleStruct } from './nodes/structs.wgsl.js';
@@ -126,6 +126,16 @@ export class EquirectHdrInfoNode extends EquirectHdrInfoUniform {
 			}
 		`;
 
+		// the environment's average irradiance, for weighing it against the lights
+		this.getWeight = wgslTagFn/* wgsl */`
+			fn getEnvWeight() -> f32 {
+
+				let resolution = textureDimensions( ${ mapNode } );
+				return ${ intensityNode } * ${ PI } * ${ PI } * ${ totalSumNode } / ( 2.0 * f32( resolution.x * resolution.y ) );
+
+			}
+		`;
+
 		this.getDirPdf = wgslTagFn/* wgsl */`
 			fn getEnvDirPdf( direction: vec3f ) -> f32 {
 

package/src/webgpu/LightsInfoNode.js

@@ -5,6 +5,7 @@ import { AtlasTexture } from './AtlasTexture.js';
 import { LightsInfoUniformStruct } from '../uniforms/LightsInfoUniformStruct.js';
 import { lightStruct, lightRecordStruct } from './nodes/structs.wgsl.js';
 import { sampleTexelFunc } from './nodes/utils.wgsl.js';
+import { luminanceFn } from './nodes/sampling.wgsl.js';
 import {
 	RECT_AREA_LIGHT_TYPE,
 	CIRC_AREA_LIGHT_TYPE,
@@ -17,6 +18,8 @@ import {
 	randomAreaLightSampleFn,
 	randomSpotLightSampleFn,
 	getSpotAttenuationFn,
+	getDistanceAttenuationFn,
+	getSpotLightNearestFn,
 } from './nodes/lights.wgsl.js';
 
 export class LightsInfoNode extends LightsInfoUniformStruct {
@@ -65,12 +68,13 @@ export class LightsInfoNode extends LightsInfoUniformStruct {
 		const src = this.tex.image.data;
 		this.buffer.array.set( src.subarray( 0, count * stride ) );
 
-		// rewrite the int fields ( lightType, iesProfile ) as i32 bits
+		// rewrite the int fields ( lightType, visibleToCameraRays, iesProfile ) as i32 bits
 		const intView = new Int32Array( this.buffer.array.buffer );
 		for ( let i = 0; i < count; i ++ ) {
 
 			const base = i * stride;
 			intView[ base + 3 ] = Math.round( src[ base + 3 ] );
+			intView[ base + 11 ] = Math.round( src[ base + 11 ] );
 			intView[ base + 21 ] = Math.round( src[ base + 21 ] );
 
 		}
@@ -84,12 +88,146 @@ export class LightsInfoNode extends LightsInfoUniformStruct {
 
 	_initFns() {
 
-		const { bufferNode, iesProfilesNode, iesInfoNode } = this;
+		const { bufferNode, countNode, iesProfilesNode, iesInfoNode } = this;
 
 		// profiles are sampled out of an atlas so filtering must resolve tile-relative wrapping
 		const sampleIesTexelFn = sampleTexelFunc( iesInfoNode, iesProfilesNode, 'sampleIesTexel' );
 
-		// uniformly pick a light and sample it
+		this.isLightVisibleToCamera = wgslTagFn/* wgsl */`
+			fn isLightVisibleToCamera( index: u32 ) -> bool {
+
+				return ${ bufferNode }[ index ].visibleToCameraRays != 0;
+
+			}
+		`;
+
+		// A cheap estimate of how much light reaches a position from a light, ignoring occlusion and
+		// the surface orientation, used to choose which light to sample.
+		// TODO: weigh lights below the surface's horizon to zero using its normal, skipped for
+		// transmissive surfaces. Forward hit MIS would then need the previous vertex's normal too.
+		this.getLightWeight = wgslTagFn/* wgsl */`
+			fn getLightWeight( index: u32, position: vec3f ) -> f32 {
+
+				let light = ${ bufferNode }[ index ];
+				let power = ${ luminanceFn }( light.color * light.intensity );
+				if ( light.lightType == ${ SPOT_LIGHT_TYPE } ) {
+
+					// the most any point on the spot's disc lights the position. Ies profiles are not
+					// evaluated here
+					let nearest = ${ getSpotLightNearestFn }( light, position );
+					var attenuation = 1.0;
+					if ( light.iesProfile < 0 ) {
+
+						attenuation = ${ getSpotAttenuationFn }( light.coneCos, light.penumbraCos, nearest.x );
+
+					}
+
+					return power * attenuation * ${ getDistanceAttenuationFn }( nearest.y, light.distance, light.decay );
+
+				} else if ( light.lightType == ${ POINT_LIGHT_TYPE } ) {
+
+					// the point light's world position is packed into the u slot
+					let dist = length( light.u - position );
+					return power * ${ getDistanceAttenuationFn }( dist, light.distance, light.decay );
+
+				} else if ( light.lightType == ${ DIR_LIGHT_TYPE } ) {
+
+					return power;
+
+				} else {
+
+					let toLight = light.position - position;
+					let distSq = dot( toLight, toLight );
+					if ( distSq == 0.0 ) {
+
+						return 0.0;
+
+					}
+
+					// area lights only emit from their front face, and the distance is held above the size
+					// of the light so positions on or near it do not dominate
+					let normal = normalize( cross( light.u, light.v ) );
+					let cosTheta = dot( toLight, normal ) * inverseSqrt( distSq );
+					return power * light.area * max( cosTheta, 0.0 ) / max( distSq, light.area );
+
+				}
+
+			}
+		`;
+
+		this.getLightsWeight = wgslTagFn/* wgsl */`
+			fn getLightsWeight( position: vec3f ) -> f32 {
+
+				var total = 0.0;
+				for ( var i = 0u; i < ${ countNode }; i ++ ) {
+
+					total += ${ this.getLightWeight }( i, position );
+
+				}
+
+				return total;
+
+			}
+		`;
+
+		// Chooses a light, or the environment when the returned index equals the light count, in
+		// proportion to the estimated weights. The pdf is zero when nothing can light the position.
+		this.selectLight = wgslTagFn/* wgsl */`
+			fn selectLight( position: vec3f, envWeight: f32, r: f32, selectionPdf: ptr<function, f32> ) -> u32 {
+
+				let count = ${ countNode };
+				let totalWeight = ${ this.getLightsWeight }( position ) + envWeight;
+				if ( totalWeight <= 0.0 ) {
+
+					*selectionPdf = 0.0;
+					return 0u;
+
+				}
+
+				let targetWeight = r * totalWeight;
+				var accumulated = 0.0;
+				var lastWeighted = 0u;
+				var index = count;
+				for ( var i = 0u; i < count; i ++ ) {
+
+					let lightWeight = ${ this.getLightWeight }( i, position );
+					accumulated += lightWeight;
+					if ( lightWeight > 0.0 ) {
+
+						lastWeighted = i;
+
+					}
+
+					if ( targetWeight < accumulated ) {
+
+						index = i;
+						break;
+
+					}
+
+				}
+
+				// rounding can carry the target past the last light when there is no environment
+				if ( index == count && envWeight <= 0.0 ) {
+
+					index = lastWeighted;
+
+				}
+
+				var weight = envWeight;
+				if ( index < count ) {
+
+					weight = ${ this.getLightWeight }( index, position );
+
+				}
+
+				*selectionPdf = weight / totalWeight;
+				return index;
+
+			}
+		`;
+
+		// sample the light at the given index
 		this.randomLightSample = wgslTagFn/* wgsl */`
 			fn randomLightSample( lightIndex: u32, rayOrigin: vec3f, ruv: vec2f ) -> ${ lightRecordStruct } {
 

package/src/webgpu/MegaKernelPathTracer.js

@@ -271,6 +271,7 @@ export class MegaKernelPathTracer extends PathTracerBackend {
 		// TODO: dispose of all buffers
 		this.envInfo.dispose();
 		this.lightsInfo.dispose();
+		this.kernel.dispose();
 
 	}
 

package/src/webgpu/PathTracerBackend.js

@@ -208,6 +208,8 @@ export class PathTracerBackend {
 		this.outputTarget.dispose();
 		this.prevOutputTarget.dispose();
 		this.sampleCountTarget.dispose();
+		this.sampleCountClearKernel.dispose();
+		this.outputTargetClearKernel.dispose();
 
 		this._renderTask = null;
 

package/src/webgpu/TurquinTexture.js

@@ -96,6 +96,8 @@ export class TurquinTexture extends Storage3DTexture {
 
 		}
 
+		kernel.dispose();
+
 		// fns
 		// function that maps the given value from range [a0, a1] to [b0, b1]
 		const mapLinearClampedFn = wgslTagFn/* wgsl */`

package/src/webgpu/WaveFrontPathTracer.js

@@ -257,6 +257,19 @@ export class WaveFrontPathTracer extends PathTracerBackend {
 		this.rayDispatchConverter.outputDispatch.dispose();
 		this.shadowDispatchConverter.outputDispatch.dispose();
 
+		this.populatePixelIndicesKernel.dispose();
+		this.logicKernel.dispose();
+		this.materialKernel.dispose();
+		this.traceRayKernel.dispose();
+		this.traceShadowRayKernel.dispose();
+		this.rayDispatchConverter.dispose();
+		this.shadowDispatchConverter.dispose();
+		this.primeSampleCountersKernel.dispose();
+		this.tallySampleCountsKernel.dispose();
+		this.resetSlotsKernel.dispose();
+		this.copyRayDataKernel.dispose();
+		this.zeroDispatchKernel.dispose();
+
 	}
 
 	// The queue holds every pixel not owned by a slot. It is sized to the full pixel count so slots

package/src/webgpu/WebGPUPathTracer.js

@@ -151,7 +151,7 @@ export class WebGPUPathTracer {
 	set maxBounces( v ) {
 
 		this._pathTracer.maxBounces = v;
-		this._pathTracer.reset();
+		this.reset();
 
 	}
 
@@ -188,7 +188,7 @@ export class WebGPUPathTracer {
 	set maxTransparentBounces( v ) {
 
 		this._pathTracer.maxTransparentBounces = v;
-		this._pathTracer.reset();
+		this.reset();
 
 	}
 
@@ -1275,14 +1275,20 @@ export class WebGPUPathTracer {
 		this._bvhData.textureAtlas.dispose();
 		this._environmentCache.dispose();
 		this._backgroundCache.dispose();
-		this._blitQuad.dispose();
 		this._lowResTarget.dispose();
+
+		// FullScreenQuad.dispose only disposes the shared geometry, not the material
+		this._blitQuad.dispose();
+		this._blitQuad.material.dispose();
 		this._atlasDebugQuad?.dispose();
+		this._atlasDebugQuad?.material.dispose();
 		this._sampleDensityQuad?.dispose();
+		this._sampleDensityQuad?.material.dispose();
 
 		if ( this._debugBoundsQuad !== undefined ) {
 
 			this._debugBoundsQuad.dispose();
+			this._debugBoundsQuad.material.dispose();
 
 		}
 

package/src/webgpu/compute/ComputeKernel.js

@@ -73,11 +73,21 @@ export class ComputeKernel {
 
 		// forward the call parameters so they remain accessible via "computeNode.parameters"
 		node.parameters = this._fn.parameters;
+
+		// release the renderer's pipeline and bindings for the kernel being replaced
+		this.kernel?.dispose();
 		this.kernel = node.computeKernel( [ x, y, z ] );
 		return this;
 
 	}
 
+	dispose() {
+
+		this.kernel?.dispose();
+		this.kernel = null;
+
+	}
+
 	getDispatchSize( tx = 1, ty = 1, tz = 1, target = [] ) {
 
 		const [ wgx, wgy, wgz ] = this.workgroupSize;

package/src/webgpu/compute/PathTracerMegaKernel.js

@@ -52,6 +52,7 @@ export class PathTracerMegaKernel extends ComputeKernel {
 
 		const raycastOutput = proxy( 'bvhData.value.fns.raycastFirstHit.outputType', params );
 		const raycastFirstHitFn = proxyFn( 'bvhData.value.fns.raycastFirstHit', params );
+		const raycastShadowFn = proxyFn( 'bvhData.value.fns.raycastShadow', params );
 		const sampleTrianglePointFn = proxyFn( 'bvhData.value.fns.sampleTrianglePoint', params );
 		const getSurfaceRecordFn = proxyFn( 'bvhData.value.fns.getSurfaceRecord', params );
 		const getCameraRayFn = proxyFn( 'bvhData.value.fns.getCameraRay', params );
@@ -64,12 +65,17 @@ export class PathTracerMegaKernel extends ComputeKernel {
 		const sampleEnvColor = proxy( 'envInfo.value.sampleColor', params );
 		const sampleEnvDir = proxy( 'envInfo.value.sampleDir', params );
 		const getEnvDirPdf = proxy( 'envInfo.value.getDirPdf', params );
+		const getEnvWeight = proxy( 'envInfo.value.getWeight', params );
 		const sampleBackground = proxy( 'backgroundInfo.value.sampleColor', params );
 
 		// analytic scene lights pulled off the lightsInfo provider ( LightsInfoNode )
 		const lightsCountNode = proxy( 'lightsInfo.value.countNode', params );
 		const randomLightSampleFn = proxyFn( 'lightsInfo.value.randomLightSample', params );
 		const intersectLightAtIndexFn = proxyFn( 'lightsInfo.value.intersectLightAtIndex', params );
+		const getLightWeightFn = proxyFn( 'lightsInfo.value.getLightWeight', params );
+		const getLightsWeightFn = proxyFn( 'lightsInfo.value.getLightsWeight', params );
+		const selectLightFn = proxyFn( 'lightsInfo.value.selectLight', params );
+		const isLightVisibleToCameraFn = proxyFn( 'lightsInfo.value.isLightVisibleToCamera', params );
 
 		const shader = wgslTagFn/* wgsl */`
 
@@ -146,45 +152,58 @@ export class PathTracerMegaKernel extends ComputeKernel {
 				// A negative value marks a sampled wavelength whose RGB reconstruction weight has not been applied yet.
 				var dispersionWavelength = - mix( ${ DISPERSION_MIN_WAVELENGTH }.0, ${ DISPERSION_MAX_WAVELENGTH }.0, ${ rand1 }( ${ RNG_INDEX_DISPERSION_WAVELENGTH } ) );
 
-				// one-sample NEE selects between the analytic lights and the environment -
-				// lightsDenom is the number of options
+				// one-sample NEE chooses between the analytic lights and the environment
 				let envActive = ${ envTotalSumNode } > 0.0 && ${ envIntensityNode } > 0.0;
 				let lightsCount = ${ lightsCountNode };
-				var lightsDenom = f32( lightsCount );
+				var envWeight = 0.0;
 				if ( envActive ) {
 
-					lightsDenom += 1.0;
+					envWeight = ${ getEnvWeight }();
 
 				}
 
+				// added last, since a camera ray miss overwrites the pixel with the background
+				var lightHits = vec3f( 0.0 );
+				var cameraHitLight = false;
+
 				for ( var bounce = 0u; bounce < maxBounces; bounce ++ ) {
 
 					var hitResult: ${ raycastOutput };
 					let didHit = ${ raycastFirstHitFn }( ray, &hitResult );
 					let surfaceDist = select( ${ LIGHT_FAR_DISTANCE }, hitResult.dist, didHit );
 
-					// forward hits: a bsdf-sampled ray that lands on a area light. MIS-weighted
-					// only when NEE is also sampling the lights
-					if ( bounce > 0u ) {
+					// NEE's total weight at the vertex this ray left, for MIS. Camera rays have none
+					let isMISWeighted = misEnabled != 0u && bounce > 0u;
+					var lightTotalWeight = 0.0;
+					if ( isMISWeighted ) {
 
-						for ( var li = 0u; li < lightsCount; li ++ ) {
+						lightTotalWeight = ${ getLightsWeightFn }( ray.origin ) + envWeight;
 
-							var lightRec: ${ lightRecordStruct };
-							if ( ${ intersectLightAtIndexFn }( ray.origin, ray.direction, li, &lightRec ) && lightRec.dist < surfaceDist ) {
+					}
 
-								var misWeight = 1.0;
-								if ( misEnabled != 0u ) {
+					// forward hits on area lights. Camera rays only see visibleToCameraRays lights, at full weight
+					for ( var li = 0u; li < lightsCount; li ++ ) {
 
-									let lightPdf = lightRec.pdf / lightsDenom;
-									misWeight = ${ misHeuristicFn }( bsdfPdf, lightPdf );
+						if ( bounce == 0u && ! ${ isLightVisibleToCameraFn }( li ) ) {
 
-								}
+							continue;
+
+						}
 
-								let lightHit = ${ clampPathContributionFunc }( lightRec.emission * throughputColor * misWeight, bounce, clampDirect, clampIndirect );
-								resultColor += vec4f( lightHit, 0.0 );
+						var lightRec: ${ lightRecordStruct };
+						if ( ${ intersectLightAtIndexFn }( ray.origin, ray.direction, li, &lightRec ) && lightRec.dist < surfaceDist ) {
+
+							var misWeight = 1.0;
+							if ( isMISWeighted ) {
+
+								let selectionPdf = ${ getLightWeightFn }( li, ray.origin ) / lightTotalWeight;
+								misWeight = ${ misHeuristicFn }( bsdfPdf, lightRec.pdf * selectionPdf );
 
 							}
 
+							lightHits += ${ clampPathContributionFunc }( lightRec.emission * throughputColor * misWeight, bounce, clampDirect, clampIndirect );
+							cameraHitLight = cameraHitLight || bounce == 0u;
+
 						}
 
 					}
@@ -263,30 +282,31 @@ export class PathTracerMegaKernel extends ComputeKernel {
 						let emission = ${ clampPathContributionFunc }( throughputColor * surface.emission, bounce, clampDirect, clampIndirect );
 						resultColor += vec4f( emission, 0.0 );
 
-						// next event estimation: draw one light or the environment, each with
-						// probability 1 / lightsDenom
-						if ( misEnabled != 0u && lightsDenom > 0.0 ) {
+						// next event estimation: choose one light or the environment by its estimated
+						// contribution
+						if ( misEnabled != 0u ) {
 
-							// pick one light or the environment with a single sample
-							// TODO: importance-sample the selection by light intensity and solid angle
 							let ruv = ${ rand3 }( ${ RNG_INDEX_DIRECT_LIGHT_SAMPLE } );
-							let lightIndex = min( u32( ruv.x * lightsDenom ), u32( lightsDenom ) - 1u );
-							var lightRec: ${ lightRecordStruct };
-							if ( envActive && lightIndex == lightsCount ) {
-
-								// the environment, sampled from its CDF, as a light of kind ENVIRONMENT
-								let envSample = ${ sampleEnvDir }( ruv.yz );
-								lightRec.direction = envSample.direction;
-								lightRec.emission = envSample.color;
-								lightRec.pdf = envSample.pdf;
-								lightRec.dist = ${ LIGHT_FAR_DISTANCE };
-								lightRec.lightType = ${ ENVIRONMENT_LIGHT_TYPE };
+							var selectionPdf = 0.0;
+							let lightIndex = ${ selectLightFn }( vertexData.position.xyz, envWeight, ruv.x, &selectionPdf );
+							if ( selectionPdf > 0.0 ) {
 
-							} else {
+								var lightRec: ${ lightRecordStruct };
+								if ( envActive && lightIndex == lightsCount ) {
 
-								lightRec = ${ randomLightSampleFn }( lightIndex, vertexData.position.xyz, ruv.yz );
+									// the environment, sampled from its CDF, as a light of kind ENVIRONMENT
+									let envSample = ${ sampleEnvDir }( ruv.yz );
+									lightRec.direction = envSample.direction;
+									lightRec.emission = envSample.color;
+									lightRec.pdf = envSample.pdf;
+									lightRec.dist = ${ LIGHT_FAR_DISTANCE };
+									lightRec.lightType = ${ ENVIRONMENT_LIGHT_TYPE };
 
-							}
+								} else {
+
+									lightRec = ${ randomLightSampleFn }( lightIndex, vertexData.position.xyz, ruv.yz );
+
+								}
 
 								if ( lightRec.pdf > 0.0 ) {
 
@@ -296,20 +316,21 @@ export class PathTracerMegaKernel extends ComputeKernel {
 										var shadowRay: ${ rayStruct };
 										shadowRay.origin = ${ offsetRayOriginFunc }( vertexData.position.xyz, lightRec.direction, hitResult.normal );
 										shadowRay.direction = lightRec.direction;
-										shadowRay.maxDist = lightRec.dist - ${ LIGHT_EPSILON };
+										shadowRay.maxDist = lightRec.dist * ( 1.0 - ${ LIGHT_EPSILON } );
 
 										// opaque occlusion up to the light distance. A shadow-specific any hit
 										// traversal could support tinted shadows from transmissive and partially
 										// opaque objects
 										var shadowHit: ${ raycastOutput };
-										let occluded = ${ raycastFirstHitFn }( shadowRay, &shadowHit );
+										let occluded = ${ raycastShadowFn }( shadowRay, &shadowHit );
 										if ( ! occluded ) {
 
-											var lightPdf = lightRec.pdf;
-											lightPdf /= lightsDenom;
+											let lightPdf = lightRec.pdf * selectionPdf;
 
-											// env + area lights are also bsdf-sampled, so MIS-weight them - punctual lights take full weight
-											let misWeight = select( 1.0, ${ misHeuristicFn }( lightPdf, evalRec.pdf ), ${ isMISWeightLightFn }( lightRec.lightType ) );
+											// env + area lights are also bsdf-sampled, so MIS-weight them - punctual lights take full weight,
+											// or when a bsdf ray could never reach the light
+											let isMISWeighted = ${ isMISWeightLightFn }( lightRec.lightType ) && ! shadowHit.forwardBlocked;
+											let misWeight = select( 1.0, ${ misHeuristicFn }( lightPdf, evalRec.pdf ), isMISWeighted );
 											let directLight = throughputColor * lightRec.emission * evalRec.color * misWeight / lightPdf;
 											let contribution = ${ clampPathContributionFunc }( directLight, bounce + 1u, clampDirect, clampIndirect );
 											resultColor += vec4f( contribution, 0.0 );
@@ -320,6 +341,8 @@ export class PathTracerMegaKernel extends ComputeKernel {
 
 								}
 
+							}
+
 						}
 
 						let scatterRec = ${ bsdfSampleFn }( view, surface );
@@ -370,10 +393,10 @@ export class PathTracerMegaKernel extends ComputeKernel {
 						if ( bounce > 0u && ! isFullyTransmissive ) {
 
 							var misWeight = 1.0;
-							if ( misEnabled != 0u && envActive ) {
+							if ( isMISWeighted && envActive ) {
 
 								// match the env pdf scaling used by the NEE selection so the two estimators balance
-								let envPdf = ${ getEnvDirPdf }( ray.direction ) / lightsDenom;
+								let envPdf = ${ getEnvDirPdf }( ray.direction ) * envWeight / lightTotalWeight;
 								misWeight = ${ misHeuristicFn }( bsdfPdf, envPdf );
 
 							}
@@ -450,6 +473,14 @@ export class PathTracerMegaKernel extends ComputeKernel {
 
 				}
 
+				// visible lights are opaque against a transparent background
+				resultColor += vec4f( lightHits, 0.0 );
+				if ( cameraHitLight ) {
+
+					resultColor.a = 1.0;
+
+				}
+
 				let nextSampleCount = sampleCount + 1;
 				// store the color rows top down to match a rasterized render target
 				let colorIndex = vec2u( indexUV.x, targetDimensions.y - 1u - indexUV.y );