three-gpu-pathtracer 0.0.25 → 0.0.27

package/src/webgpu/compute/wavefront/LogicKernel.js

@@ -53,12 +53,17 @@ export class LogicKernel 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 fn = wgslTagFn/* wgsl */`
 
@@ -97,19 +102,24 @@ export class LogicKernel extends ComputeKernel {
 				let indexUV = vec2u( input.pixelIndex >> 16, input.pixelIndex & 0xFFFF );
 				${ rngInit }( indexUV, input.seed, input.currentBounce + input.alphaDepth );
 
-				// one-sample NEE selection normalization (lights + env), matched with the megakernel
+				// one-sample NEE chooses between the analytic lights and the environment, matched with
+				// the megakernel
 				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 }();
 
 				}
 
 				var resultColor = input.resultColor;
 				var throughputColor = input.throughputColor;
 
+				// added last, since a camera ray miss overwrites the pixel with the background
+				var lightHits = vec3f( 0.0 );
+				var cameraHitLight = false;
+
 				// resolve the previous surface's NEE shadow ray (pre-scatter throughput). The index
 				// is negative when no shadow ray was enqueued last frame
 				if ( input.shadowRayIntersectionIndex >= 0 && input.lightPdf > 0.0 ) {
@@ -118,8 +128,10 @@ export class LogicKernel extends ComputeKernel {
 					let occluded = shadowHit.objectIndex >= 0;
 					if ( ! occluded ) {
 
-						// env + area lights are also bsdf-sampled, so MIS-weight them; punctual take full weight
-						let misWeight = select( 1.0, ${ misHeuristicFn }( input.lightPdf, input.lightBsdfPdf ), ${ isMISWeightLightFn }( input.lightType ) );
+						// env + area lights are also bsdf-sampled, so MIS-weight them; punctual take full weight,
+						// or when a bsdf ray could never reach the light
+						let isMISWeighted = ${ isMISWeightLightFn }( input.lightType ) && shadowHit.forwardBlocked == 0u;
+						let misWeight = select( 1.0, ${ misHeuristicFn }( input.lightPdf, input.lightBsdfPdf ), isMISWeighted );
 						let directLight = throughputColor * input.lightEmission * input.lightBsdf * misWeight / input.lightPdf;
 						let contribution = ${ clampPathContributionFunc }( directLight, input.currentBounce, clampDirect, clampIndirect );
 						resultColor += vec4f( contribution, 0.0 );
@@ -151,28 +163,38 @@ export class LogicKernel extends ComputeKernel {
 					let didHit = hitResult.objectIndex >= 0;
 					let surfaceDist = select( ${ LIGHT_FAR_DISTANCE }, hitResult.dist, didHit );
 
-					// forward hits: a bsdf-sampled segment that lands on a area light. MIS-weighted
-					// only when NEE is also sampling the lights. The camera segment is skipped.
-					if ( input.currentBounce > 0u ) {
+					// NEE's total weight at the vertex this segment left, for MIS. Camera segments have none
+					let isMISWeighted = misEnabled != 0u && input.currentBounce > 0u;
+					var lightTotalWeight = 0.0;
+					if ( isMISWeighted ) {
 
-						for ( var li = 0u; li < lightsCount; li ++ ) {
+						lightTotalWeight = ${ getLightsWeightFn }( input.origin ) + envWeight;
 
-							var lightRec: ${ lightRecordStruct };
-							if ( ${ intersectLightAtIndexFn }( input.origin, input.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 }( input.scatterPdf, lightPdf );
+						if ( input.currentBounce == 0u && ! ${ isLightVisibleToCameraFn }( li ) ) {
 
-								}
+							continue;
+
+						}
 
-								let lightHit = ${ clampPathContributionFunc }( lightRec.emission * throughputColor * misWeight, input.currentBounce, clampDirect, clampIndirect );
-								resultColor += vec4f( lightHit, 0.0 );
+						var lightRec: ${ lightRecordStruct };
+						if ( ${ intersectLightAtIndexFn }( input.origin, input.direction, li, &lightRec ) && lightRec.dist < surfaceDist ) {
+
+							var misWeight = 1.0;
+							if ( isMISWeighted ) {
+
+								let selectionPdf = ${ getLightWeightFn }( li, input.origin ) / lightTotalWeight;
+								misWeight = ${ misHeuristicFn }( input.scatterPdf, lightRec.pdf * selectionPdf );
 
 							}
 
+							lightHits += ${ clampPathContributionFunc }( lightRec.emission * throughputColor * misWeight, input.currentBounce, clampDirect, clampIndirect );
+							cameraHitLight = cameraHitLight || input.currentBounce == 0u;
+
 						}
 
 					}
@@ -187,36 +209,40 @@ export class LogicKernel extends ComputeKernel {
 						rayDataStorage[ index ].objectIndex = hitResult.objectIndex;
 						rayDataStorage[ index ].dist = hitResult.dist;
 
-						// next event estimation: pick one light or the environment with a single sample.
-						// MaterialKernel evaluates the bsdf and enqueues the shadow ray.
-						// TODO: importance-sample the selection by light intensity and solid angle
+						// next event estimation: choose one light or the environment by its estimated
+						// contribution. MaterialKernel evaluates the bsdf and enqueues the shadow ray.
 						var lightPdf = 0.0;
-						if ( misEnabled != 0u && lightsDenom > 0.0 ) {
+						if ( misEnabled != 0u ) {
 
 							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 }( hitResult.position, envWeight, ruv.x, &selectionPdf );
+							if ( selectionPdf > 0.0 ) {
 
-							} else {
+								var lightRec: ${ lightRecordStruct };
+								if ( envActive && lightIndex == lightsCount ) {
 
-								lightRec = ${ randomLightSampleFn }( lightIndex, hitResult.position, 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, hitResult.position, ruv.yz );
 
-							lightPdf = lightRec.pdf / lightsDenom;
-							rayDataStorage[ index ].lightDirection = lightRec.direction;
-							rayDataStorage[ index ].lightEmission = lightRec.emission;
-							rayDataStorage[ index ].lightDist = lightRec.dist;
-							rayDataStorage[ index ].lightType = lightRec.lightType;
+								}
+
+								lightPdf = lightRec.pdf * selectionPdf;
+								rayDataStorage[ index ].lightDirection = lightRec.direction;
+								rayDataStorage[ index ].lightEmission = lightRec.emission;
+								rayDataStorage[ index ].lightDist = lightRec.dist;
+								rayDataStorage[ index ].lightType = lightRec.lightType;
+
+							}
 
 						}
 
@@ -229,10 +255,10 @@ export class LogicKernel extends ComputeKernel {
 						if ( input.currentBounce > 0u && input.isFullyTransmissive == 0u ) {
 
 							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 }( input.direction ) / lightsDenom;
+								let envPdf = ${ getEnvDirPdf }( input.direction ) * envWeight / lightTotalWeight;
 								misWeight = ${ misHeuristicFn }( input.scatterPdf, envPdf );
 
 							}
@@ -308,6 +334,14 @@ export class LogicKernel extends ComputeKernel {
 
 				}
 
+				// visible lights are opaque against a transparent background
+				resultColor += vec4f( lightHits, 0.0 );
+				if ( cameraHitLight ) {
+
+					resultColor.a = 1.0;
+
+				}
+
 				// the color rows are stored top down to match a rasterized render target
 				let colorIndex = vec2u( indexUV.x, textureDimensions( ${ params.outputTarget } ).y - 1u - indexUV.y );
 				let storedSamples = textureLoad( ${ params.sampleCountTarget }, indexUV ).r & ${ SAMPLE_COUNT_MASK }u;

package/src/webgpu/compute/wavefront/MaterialKernel.js

@@ -339,7 +339,7 @@ export class MaterialKernel extends ComputeKernel {
 							shadowRayQueue.elements[ shadowIndex ].currentBounce = input.currentBounce;
 							shadowRayQueue.elements[ shadowIndex ].seed = input.seed;
 							shadowRayQueue.elements[ shadowIndex ].alphaDepth = input.alphaDepth;
-							shadowRayQueue.elements[ shadowIndex ].maxDist = input.lightDist - ${ LIGHT_EPSILON };
+							shadowRayQueue.elements[ shadowIndex ].maxDist = input.lightDist * ( 1.0 - ${ LIGHT_EPSILON } );
 							rayDataStorage[ index ].shadowRayIntersectionIndex = i32( shadowIndex );
 
 						} else {

package/src/webgpu/compute/wavefront/TraceShadowRayKernel.js

@@ -5,8 +5,8 @@ import { proxy, wgslTagFn } from 'three-mesh-bvh/webgpu';
 import { rngInit } from '../../nodes/random.wgsl.js';
 import { rayQueueStruct, intersectionResultStruct } from './structs.js';
 
-// Pure BVH traversal over the queued shadow rays. Uses the same first-hit traversal as the bounce
-// rays ( no dedicated any-hit traversal exists yet ); LogicKernel decides occlusion by comparing the
+// Pure BVH traversal over the queued shadow rays. Uses a first-hit traversal without face culling
+// ( no dedicated any-hit traversal exists yet ); LogicKernel decides occlusion by comparing the
 // hit distance against the light distance.
 export class TraceShadowRayKernel extends ComputeKernel {
 
@@ -22,7 +22,7 @@ export class TraceShadowRayKernel extends ComputeKernel {
 		};
 
 		const raycastOutput = proxy( 'bvhData.value.fns.raycastFirstHit.outputType', params );
-		const raycastFirstHitFn = proxy( 'bvhData.value.fns.raycastFirstHit', params );
+		const raycastShadowFn = proxy( 'bvhData.value.fns.raycastShadow', params );
 
 		const fn = wgslTagFn /* wgsl */`
 
@@ -44,7 +44,7 @@ export class TraceShadowRayKernel extends ComputeKernel {
 
 				let ray = Ray( queuedRay.origin, queuedRay.direction, queuedRay.maxDist );
 				var hitResult: ${ raycastOutput };
-				if ( ${ raycastFirstHitFn }( ray, &hitResult ) ) {
+				if ( ${ raycastShadowFn }( ray, &hitResult ) ) {
 
 					shadowRayIntersectionsStorage[ index ].objectIndex = i32( hitResult.objectIndex );
 					shadowRayIntersectionsStorage[ index ].dist = hitResult.dist;
@@ -55,6 +55,8 @@ export class TraceShadowRayKernel extends ComputeKernel {
 
 				}
 
+				shadowRayIntersectionsStorage[ index ].forwardBlocked = u32( hitResult.forwardBlocked );
+
 			}
 		`;
 

package/src/webgpu/compute/wavefront/structs.js

@@ -118,7 +118,9 @@ export const intersectionResultStruct = new StructTypeNode( {
 	side: 'float',
 
 	indices: 'vec3u',
-	_alignment0: 'uint',
+
+	// shadow rays only: a face a bsdf ray would hit was passed
+	forwardBlocked: 'uint',
 
 }, 'TraceResult' );
 

package/src/webgpu/index.d.ts

@@ -1,6 +1,44 @@
 import { Camera, Scene, Texture, ExternalTexture } from 'three';
 import { WebGPURenderer } from 'three/webgpu';
 
+// three.js type augmentation
+
+declare module 'three' {
+
+	export interface Material {
+
+		matte?: boolean;
+		castShadow?: boolean;
+
+	}
+
+	export interface Object3D {
+
+		visibleToShadowRays?: boolean;
+
+	}
+
+	export interface Light {
+
+		visibleToCameraRays?: boolean;
+
+	}
+
+	export interface SpotLight {
+
+		radius?: number;
+		iesMap?: Texture | null;
+
+	}
+
+	export interface RectAreaLight {
+
+		isCircular?: boolean;
+
+	}
+
+}
+
 // constants
 
 export type RandomStrategy = object;

package/src/webgpu/materials/GltfCompliantMaterial.js

@@ -1,6 +1,6 @@
 import { float } from 'three/tsl';
 import { wgslTagFn } from 'three-mesh-bvh/webgpu';
-import { PathtracingMaterial } from './PathtracingMaterial';
+import { PathtracingMaterial } from './PathtracingMaterial.js';
 import { specularBrdfFunc, specularBtdfFunc, fresnelMixFunc, conductorFresnelFunc, fresnelCoatFunc, iridescentFresnelFunc, isMatchedIorFunc, thinWallTransmissionRoughnessFunc, transmissionFresnelFunc } from '../nodes/material.wgsl.js';
 import { eonBrdfFunc, eonDirectionFunc, eonPDFFunc } from '../nodes/eon.wgsl.js';
 import { sheenColorFunc, sheenAlbedoScalingFunc } from '../nodes/sheen.wgsl.js';

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,23 @@ 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, plus whether a shadow ray passed a face a bsdf ray would hit
+const intersectionResultStruct = new StructTypeNode( {
+	indices: 'vec4u',
+	normal: 'vec3f',
+	didHit: 'bool',
+	barycoord: 'vec3f',
+	objectIndex: 'uint',
+	side: 'float',
+	dist: 'float',
+	forwardBlocked: 'bool',
+}, 'PathTracerIntersectionResult' );
+
 // Pathtracer-specific version of the BVHComputeData tht includes material mapping, property structs
 export class PathtracerBVHComputeData extends BVHComputeData {
 
@@ -181,8 +193,11 @@ 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, and pass through the objects not visible to them
+		const isShadowRay = bool( false ).toVar( 'bvh_isShadowRay' );
+		const skipShadowObject = bool( false ).toVar( 'bvh_skipShadowObject' );
+
+		const raycastOptions = {
 			shapeStruct: rayStruct,
 			resultStruct: intersectionResultStruct,
 
@@ -259,7 +274,8 @@ 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;
 
@@ -325,6 +341,19 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 							}
 
+							// shadow rays pass the objects not visible to them, but a bsdf ray would hit this face
+							if ( ${ skipShadowObject } ) {
+
+								if ( material.side == 0 || triResult.side == material.side ) {
+
+									result.forwardBlocked = true;
+
+								}
+
+								continue;
+
+							}
+
 							result.didHit = true;
 							result.dist = triResult.dist;
 							result.normal = triResult.normal;
@@ -367,6 +396,8 @@ export class PathtracerBVHComputeData extends BVHComputeData {
 
 					}
 
+					${ skipShadowObject } = ${ isShadowRay } && object.visibleToShadowRays == 0u;
+
 				}
 			`,
 			transformResultFn: wgslTagFn/* wgsl */`
@@ -384,6 +415,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 +453,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 +481,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 {
 
@@ -906,9 +964,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 +1005,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/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/structs.wgsl.js

@@ -234,6 +234,7 @@ export const lightStruct = new StructTypeNode( {
 	color: 'vec3f',
 	intensity: 'float',
 	u: 'vec3f',
+	visibleToCameraRays: 'int',
 	v: 'vec3f',
 	area: 'float',
 	radius: 'float',

package/src/webgpu/upscale/FSRUpscaler.js

@@ -50,6 +50,7 @@ export class FSRUpscaler {
 	init( renderer ) {
 
 		this.renderer = renderer;
+		this._upscaler?.dispose();
 		this._upscaler = new this.Upscaler( { renderer } );
 		this._upscaler.init();
 
@@ -100,7 +101,7 @@ export class FSRUpscaler {
 
 	dispose() {
 
-		this._upscaler.dispose();
+		this._upscaler?.dispose();
 		this._upscaler = null;
 
 	}