@gnsx/three 0.184.20 → 0.185.3

package/examples/jsm/libs/mikktspace.module.js

@@ -117,12 +117,37 @@ export let wasm;
 
 export let isReady = false;
 
-export const ready = fetch(wasmDataURI)
-    .then((res) => res.arrayBuffer())
-    .then((buffer) => WebAssembly.instantiate(buffer, {
-        './mikktspace_module_bg.js': {__wbindgen_string_new, __wbindgen_rethrow}
-    }))
-    .then((result) => {
-        wasm = result.instance.exports;
-        isReady = true;
-    });
+let readyPromise = null;
+
+function initialize() {
+
+	return fetch( wasmDataURI )
+		.then( ( res ) => res.arrayBuffer() )
+		.then( ( buffer ) => WebAssembly.instantiate( buffer, {
+			'./mikktspace_module_bg.js': { __wbindgen_string_new, __wbindgen_rethrow }
+		} ) )
+		.then( ( result ) => {
+
+			wasm = result.instance.exports;
+			isReady = true;
+
+		} );
+
+}
+
+export const ready = {
+	then: function ( onFulfilled, onRejected ) {
+
+		if ( readyPromise === null ) readyPromise = initialize();
+		return readyPromise.then( onFulfilled, onRejected );
+
+	}
+};
+
+export function dispose() {
+
+	wasm = null;
+	isReady = false;
+	readyPromise = null;
+
+}

package/examples/jsm/lighting/ClusteredLighting.js

@@ -0,0 +1,55 @@
+import { Lighting } from 'three/webgpu';
+import ClusteredLightsNode from '../tsl/lighting/ClusteredLightsNode.js';
+
+/**
+ * A custom lighting implementation based on Forward+ Clustered Shading that
+ * overwrites the default lighting system in {@link WebGPURenderer}. Suitable
+ * for 3D scenes with many point lights and real depth complexity — the view
+ * frustum is partitioned into a 3D cluster grid so only the lights actually
+ * reaching each fragment are evaluated.
+ *
+ * ```js
+ * const lighting = new ClusteredLighting();
+ * renderer.lighting = lighting; // set lighting system
+ * ```
+ *
+ * @augments Lighting
+ * @three_import import { ClusteredLighting } from 'three/addons/lighting/ClusteredLighting.js';
+ */
+export class ClusteredLighting extends Lighting {
+
+	/**
+	 * Constructs a new clustered lighting system.
+	 *
+	 * @param {number} [maxLights=1024] - Maximum number of point lights.
+	 * @param {number} [tileSize=32] - Screen tile size in pixels (cluster XY size).
+	 * @param {number} [zSlices=24] - Number of exponential depth slices.
+	 * @param {number} [maxLightsPerCluster=64] - Per-cluster light-list capacity.
+	 */
+	constructor( maxLights = 1024, tileSize = 32, zSlices = 24, maxLightsPerCluster = 64 ) {
+
+		super();
+
+		this.maxLights = maxLights;
+		this.tileSize = tileSize;
+		this.zSlices = zSlices;
+		this.maxLightsPerCluster = maxLightsPerCluster;
+
+	}
+
+	/**
+	 * Creates a new clustered lights node for the given array of lights.
+	 *
+	 * This method is called internally by the renderer and must be overwritten by
+	 * all custom lighting implementations.
+	 *
+	 * @param {Array<Light>} lights - The lights.
+	 * @return {ClusteredLightsNode} The clustered lights node.
+	 */
+	createNode( lights = [] ) {
+
+		return new ClusteredLightsNode( this.maxLights, this.tileSize, this.zSlices, this.maxLightsPerCluster ).setLights( lights );
+
+	}
+
+}

package/examples/jsm/lighting/LightProbeGrid.js

@@ -80,8 +80,8 @@ let _batchTargetProbes = 0;
 // Reusable temp objects
 const _position = /*@__PURE__*/ new Vector3();
 const _size = /*@__PURE__*/ new Vector3();
-const _savedViewport = /*@__PURE__*/ new Vector4();
-const _savedScissor = /*@__PURE__*/ new Vector4();
+const _currentViewport = /*@__PURE__*/ new Vector4();
+const _currentScissor = /*@__PURE__*/ new Vector4();
 
 // Number of padding texels added at each boundary of every sub-volume in the atlas.
 const ATLAS_PADDING = 1;
@@ -90,6 +90,9 @@ const ATLAS_PADDING = 1;
  * A 3D grid of L2 Spherical Harmonic irradiance probes that provides
  * position-dependent diffuse global illumination.
  *
+ * Note that this class can only be used with {@link WebGLRenderer}.
+ * A version for {@link WebGPURenderer} will be added at a later point.
+ *
  * All seven packed SH sub-volumes are stored in a **single** RGBA
  * `WebGL3DRenderTarget` using a texture-atlas layout along the Z axis.
  * Each sub-volume occupies `( nz + 2 )` atlas slices: one padding slice at
@@ -99,11 +102,11 @@ const ATLAS_PADDING = 1;
  * Atlas layout (nz = resolution.z, PADDING = 1):
  * ```
  *   slice   0              : padding  (copy of sub-volume 0, data slice 0)
- *   slices  1 … nz         : sub-volume 0 data
+ *   slices  1 �? nz         : sub-volume 0 data
  *   slice   nz + 1         : padding  (copy of sub-volume 0, data slice nz-1)
  *   slice   nz + 2         : padding  (copy of sub-volume 1, data slice 0)
- *   slices  nz+3 … 2*nz+2  : sub-volume 1 data
- *   …
+ *   slices  nz+3 �? 2*nz+2  : sub-volume 1 data
+ *   �?
  * ```
  * Total atlas depth = `7 * ( nz + 2 )`.
  *
@@ -275,7 +278,10 @@ class LightProbeGrid extends Object3D {
 
 	/**
 	 * Bakes all probes by rendering cubemaps at each probe position
-	 * and projecting to L2 SH. Fully GPU-resident with zero CPU readback.
+	 * and projecting to L2 SH. Optionally iterates additional passes to
+	 * capture indirect bounces �? each extra pass samples the previous pass's
+	 * atlas as indirect light, so a grid added to the scene before baking
+	 * accumulates one bounce per extra pass.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {Scene} scene - The scene to render.
@@ -283,6 +289,7 @@ class LightProbeGrid extends Object3D {
 	 * @param {number} [options.cubemapSize=8] - Resolution of each cubemap face.
 	 * @param {number} [options.near=0.1] - Near plane for the cube camera.
 	 * @param {number} [options.far=100] - Far plane for the cube camera.
+	 * @param {number} [options.bounces=0] - Additional bounce passes after the initial direct pass.
 	 * @param {boolean} [options.retainCubemaps=false] - Whether to retain the captured cube maps for visualization.
 	 * @return {Promise<void>} Resolves when baking has completed.
 	 */
@@ -303,40 +310,66 @@ class LightProbeGrid extends Object3D {
 
 		} else { // !WITH_GENESYS
 
-			const { cubeRenderTarget, cubeCamera } = _ensureBakeResources( options );
+		const { bounces = 0 } = options;
+		const { cubeRenderTarget, cubeCamera } = _ensureBakeResources( options );
+
+		this._ensureTextures();
+		this.updateBoundingBox();
+
+		const res = this.resolution;
+		const totalProbes = res.x * res.y * res.z;
+
+		// Batch render target for SH coefficients: 9 pixels wide, one row per probe
+		const batchTarget = _ensureBatchTarget( totalProbes );
+
+		// Save renderer state
+		const currentRenderTarget = renderer.getRenderTarget();
+		renderer.getViewport( _currentViewport );
+		renderer.getScissor( _currentScissor );
+		const currentScissorTest = renderer.getScissorTest();
 
-			this._ensureTextures();
-			this.updateBoundingBox();
+		// Scene is static across the bake �? update once and disable per-render auto updates.
+		const currentMatrixWorldAutoUpdate = scene.matrixWorldAutoUpdate;
+		if ( currentMatrixWorldAutoUpdate === true ) {
 
-			const res = this.resolution;
-			const totalProbes = res.x * res.y * res.z;
+			scene.updateMatrixWorld( true );
+			scene.matrixWorldAutoUpdate = false;
 
-			// Batch render target for SH coefficients: 9 pixels wide, one row per probe
-			const batchTarget = _ensureBatchTarget( totalProbes );
+		}
 
-			// Save renderer state
-			const savedRenderTarget = renderer.getRenderTarget();
-			renderer.getViewport( _savedViewport );
-			renderer.getScissor( _savedScissor );
-			const savedScissorTest = renderer.getScissorTest();
+		// Disable shadow map auto-update across all passes �? lights don't move.
+		// Force a single shadow update on the first render so maps are initialized.
+		const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+		renderer.shadowMap.autoUpdate = false;
+		renderer.shadowMap.needsUpdate = true;
 
-			// Clear pooled batch target so skipped probes read as zero
-			batchTarget.scissorTest = false;
-			batchTarget.viewport.set( 0, 0, 9, totalProbes );
-			renderer.setRenderTarget( batchTarget );
-			renderer.clear();
+		_ensureRepackResources();
 
-			// const t0 = performance.now();
+		const paddedSlices = res.z + 2 * ATLAS_PADDING;
+		const rt = this._renderTarget;
 
-			// Phase 1: Render cubemaps and project to SH into batch target
-			// Note: set viewport/scissor on the render target directly to avoid pixel ratio scaling
-			batchTarget.scissorTest = true;
+		// const t0 = performance.now();
 
-			// Disable shadow map auto-update during bake — lights don't move between probes.
-			// Force one shadow update on the first render so maps are initialized.
-			const savedShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-			renderer.shadowMap.autoUpdate = false;
-			renderer.shadowMap.needsUpdate = true;
+		// Pass 0 captures direct light only (grid hidden, so probesSH is not sampled
+		// �? the atlas at this point may be uninitialized or hold a prior bake).
+		// Each subsequent pass keeps the grid visible so the cube cameras read the
+		// previous pass's atlas as indirect light, accumulating one bounce per pass.
+		// Phase 1 writes to the batch target and Phase 2 only swaps it into the atlas
+		// at the very end of each pass, which gives an implicit ping-pong for free.
+
+		for ( let pass = 0; pass <= bounces; pass ++ ) {
+
+			this.visible = pass > 0;
+
+		// Clear pooled batch target so skipped probes read as zero
+		batchTarget.scissorTest = false;
+		batchTarget.viewport.set( 0, 0, 9, totalProbes );
+		renderer.setRenderTarget( batchTarget );
+		renderer.clear();
+
+		// Phase 1: Render cubemaps and project to SH into batch target
+		// Note: set viewport/scissor on the render target directly to avoid pixel ratio scaling
+		batchTarget.scissorTest = true;
 
 			// Initialize cube texture/render target arrays if retaining
 			if ( retainCubemaps ) {
@@ -358,15 +391,15 @@ class LightProbeGrid extends Object3D {
 
 			}
 
-			for ( let iz = 0; iz < res.z; iz ++ ) {
+		for ( let iz = 0; iz < res.z; iz ++ ) {
 
-				for ( let iy = 0; iy < res.y; iy ++ ) {
+			for ( let iy = 0; iy < res.y; iy ++ ) {
 
-					for ( let ix = 0; ix < res.x; ix ++ ) {
+				for ( let ix = 0; ix < res.x; ix ++ ) {
 
-						const probeIndex = ix + iy * res.x + iz * res.x * res.y;
+					const probeIndex = ix + iy * res.x + iz * res.x * res.y;
 
-						this.getProbePosition( ix, iy, iz, _position );
+					this.getProbePosition( ix, iy, iz, _position );
 
 						let envMapTexture = cubeRenderTarget.texture;
 
@@ -387,81 +420,81 @@ class LightProbeGrid extends Object3D {
 
 						} else {
 
-							cubeCamera.position.copy( _position );
-							cubeCamera.update( renderer, scene );
+					cubeCamera.position.copy( _position );
+					cubeCamera.update( renderer, scene );
 
 						}
 
-						// SH projection
+					// SH projection
 						_shMaterial.uniforms.envMap.value = envMapTexture;
-						_mesh.material = _shMaterial;
-						batchTarget.viewport.set( 0, probeIndex, 9, 1 );
-						batchTarget.scissor.set( 0, probeIndex, 9, 1 );
-						renderer.setRenderTarget( batchTarget );
-						renderer.render( _scene, _camera );
-
-					}
+					_mesh.material = _shMaterial;
+					batchTarget.viewport.set( 0, probeIndex, 9, 1 );
+					batchTarget.scissor.set( 0, probeIndex, 9, 1 );
+					renderer.setRenderTarget( batchTarget );
+					renderer.render( _scene, _camera );
 
 				}
 
 			}
 
-			renderer.shadowMap.autoUpdate = savedShadowAutoUpdate;
+		}
 
-			// Phase 2: Repack SH data from batch target into the atlas 3D texture (GPU-to-GPU).
-			//
-			// For each of the 7 packed sub-volumes (texture index t) we write:
-			//   - A leading padding slice  (copy of data slice iz = 0)
-			//   - All nz data slices       (iz = 0 … nz-1)
-			//   - A trailing padding slice (copy of data slice iz = nz-1)
-			//
-			// In the atlas the slices for sub-volume t occupy the range:
-			//   [ t * paddedSlices, t * paddedSlices + paddedSlices - 1 ]
-			// where paddedSlices = nz + 2 * ATLAS_PADDING.
+		// Phase 2: Repack SH data from batch target into the atlas 3D texture (GPU-to-GPU).
+		//
+		// For each of the 7 packed sub-volumes (texture index t) we write:
+		//   - A leading padding slice  (copy of data slice iz = 0)
+		//   - All nz data slices       (iz = 0 �? nz-1)
+		//   - A trailing padding slice (copy of data slice iz = nz-1)
+		//
+		// In the atlas the slices for sub-volume t occupy the range:
+		//   [ t * paddedSlices, t * paddedSlices + paddedSlices - 1 ]
+		// where paddedSlices = nz + 2 * ATLAS_PADDING.
 
-			_ensureRepackResources();
+		rt.scissorTest = false;
+		rt.viewport.set( 0, 0, res.x, res.y );
 
-			const paddedSlices = res.z + 2 * ATLAS_PADDING;
-			const rt = this._renderTarget;
-			rt.scissorTest = false;
-			rt.viewport.set( 0, 0, res.x, res.y );
+		for ( let t = 0; t < 7; t ++ ) {
 
-			for ( let t = 0; t < 7; t ++ ) {
+			_repackMaterials[ t ].uniforms.batchTexture.value = batchTarget.texture;
+			_repackMaterials[ t ].uniforms.resolution.value.copy( res );
 
-				_repackMaterials[ t ].uniforms.batchTexture.value = batchTarget.texture;
-				_repackMaterials[ t ].uniforms.resolution.value.copy( res );
+			// Write data slices
+			for ( let iz = 0; iz < res.z; iz ++ ) {
 
-				// Write data slices
-				for ( let iz = 0; iz < res.z; iz ++ ) {
+				_repackMaterials[ t ].uniforms.sliceZ.value = iz;
+				_mesh.material = _repackMaterials[ t ];
+				renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + iz );
+				renderer.render( _scene, _camera );
 
-					_repackMaterials[ t ].uniforms.sliceZ.value = iz;
-					_mesh.material = _repackMaterials[ t ];
-					renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + iz );
-					renderer.render( _scene, _camera );
+			}
 
-				}
+			// Leading padding: copy of data slice iz = 0
+			_repackMaterials[ t ].uniforms.sliceZ.value = 0;
+			_mesh.material = _repackMaterials[ t ];
+			renderer.setRenderTarget( rt, t * paddedSlices );
+			renderer.render( _scene, _camera );
 
-				// Leading padding: copy of data slice iz = 0
-				_repackMaterials[ t ].uniforms.sliceZ.value = 0;
-				_mesh.material = _repackMaterials[ t ];
-				renderer.setRenderTarget( rt, t * paddedSlices );
-				renderer.render( _scene, _camera );
+			// Trailing padding: copy of data slice iz = nz - 1
+			_repackMaterials[ t ].uniforms.sliceZ.value = res.z - 1;
+			_mesh.material = _repackMaterials[ t ];
+			renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + res.z );
+			renderer.render( _scene, _camera );
 
-				// Trailing padding: copy of data slice iz = nz - 1
-				_repackMaterials[ t ].uniforms.sliceZ.value = res.z - 1;
-				_mesh.material = _repackMaterials[ t ];
-				renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + res.z );
-				renderer.render( _scene, _camera );
+		}
 
-			}
+		}
+
+		renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+
+		// Restore renderer state
+		renderer.setRenderTarget( currentRenderTarget );
+		renderer.setViewport( _currentViewport );
+		renderer.setScissor( _currentScissor );
+		renderer.setScissorTest( currentScissorTest );
 
-			// Restore renderer state
-			renderer.setRenderTarget( savedRenderTarget );
-			renderer.setViewport( _savedViewport );
-			renderer.setScissor( _savedScissor );
-			renderer.setScissorTest( savedScissorTest );
+		scene.matrixWorldAutoUpdate = currentMatrixWorldAutoUpdate;
 
-			// console.log( `LightProbeGrid: bake complete ${ ( performance.now() - t0 ).toFixed( 1 ) }ms` );
+		// console.log( `LightProbeGrid: bake complete ${ ( performance.now() - t0 ).toFixed( 1 ) }ms` );
 
 		}
 
@@ -1109,7 +1142,7 @@ function _ensureWebGPUComputeResources( cubemapSize, envMapTexture, atlasTexture
 				totalWeight.addAssign( weight );
 
 				const dir = coord.normalize();
-				// Pass explicit direction — omitting UV would default to reflectVector (needs camera).
+				// Pass explicit direction �? omitting UV would default to reflectVector (needs camera).
 				const cw = cubeTexture( envMapTexture, coord ).rgb.mul( weight );
 
 				accum0.addAssign( cw.mul( 0.282095 ) );

package/examples/jsm/lines/LineMaterial.js

@@ -10,7 +10,7 @@ UniformsLib.line = {
 
 	worldUnits: { value: 1 },
 	linewidth: { value: 1 },
-	resolution: { value: new Vector2( 1, 1 ) },
+	resolution: { value: new Vector2() },
 	dashOffset: { value: 0 },
 	dashScale: { value: 1 },
 	dashSize: { value: 1 },
@@ -70,18 +70,20 @@ ShaderLib[ 'line' ] = {
 
 		#endif
 
-		void trimSegment( const in vec4 start, inout vec4 end ) {
+		float trimSegmentAlpha( const in vec4 start, const in vec4 end ) {
 
-			// trim end segment so it terminates between the camera plane and the near plane
+			// compute the interpolation factor needed to trim the segment so it terminates
+			// between the camera plane and the near plane
 
 			// conservative estimate of the near plane
 			float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
 			float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
-			float nearEstimate = - 0.5 * b / a;
 
-			float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );
+			// we need different nearEstimate formula for reversed and default depth buffer
+			// a is positive with a reversed depth buffer so it can be used for controlling the code flow
+			float nearEstimate = ( a > 0.0 ) ? ( - b / ( a + 1.0 ) ) : ( - 0.5 * b / a );
 
-			end.xyz = mix( start.xyz, end.xyz, alpha );
+			return ( nearEstimate - start.z ) / ( end.z - start.z );
 
 		}
 
@@ -93,19 +95,19 @@ ShaderLib[ 'line' ] = {
 
 			#endif
 
-			#ifdef USE_DASH
-
-				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
-				vUv = uv;
-
-			#endif
-
 			float aspect = resolution.x / resolution.y;
 
 			// camera space
 			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
 			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
 
+			#ifdef USE_DASH
+
+				float lineDistanceStart = dashScale * instanceDistanceStart;
+				float lineDistanceEnd = dashScale * instanceDistanceEnd;
+
+			#endif
+
 			#ifdef WORLD_UNITS
 
 				worldStart = start.xyz;
@@ -128,16 +130,37 @@ ShaderLib[ 'line' ] = {
 
 				if ( start.z < 0.0 && end.z >= 0.0 ) {
 
-					trimSegment( start, end );
+					float alpha = trimSegmentAlpha( start, end );
+					end.xyz = mix( start.xyz, end.xyz, alpha );
+
+					#ifdef USE_DASH
+
+						lineDistanceEnd = mix( lineDistanceStart, lineDistanceEnd, alpha );
+
+					#endif
 
 				} else if ( end.z < 0.0 && start.z >= 0.0 ) {
 
-					trimSegment( end, start );
+					float alpha = trimSegmentAlpha( end, start );
+					start.xyz = mix( end.xyz, start.xyz, alpha );
+
+					#ifdef USE_DASH
+
+						lineDistanceStart = mix( lineDistanceEnd, lineDistanceStart, alpha );
+
+					#endif
 
 				}
 
 			}
 
+			#ifdef USE_DASH
+
+				vLineDistance = ( position.y < 0.5 ) ? lineDistanceStart : lineDistanceEnd;
+				vUv = uv;
+
+			#endif
+
 			// clip space
 			vec4 clipStart = projectionMatrix * start;
 			vec4 clipEnd = projectionMatrix * end;

package/examples/jsm/lines/LineSegments2.js

@@ -326,6 +326,14 @@ class LineSegments2 extends Mesh {
 
 		}
 
+		// early out if no resolution has been set (line was not rendered yet)
+
+		if ( worldUnits === false && ( this.material.resolution.x === 0 || this.material.resolution.y === 0 ) ) {
+
+			return;
+
+		}
+
 		const threshold = ( raycaster.params.Line2 !== undefined ) ? raycaster.params.Line2.threshold || 0 : 0;
 
 		_ray = raycaster.ray;

package/examples/jsm/lines/webgpu/LineSegments2.js

@@ -324,6 +324,14 @@ class LineSegments2 extends Mesh {
 
 		}
 
+		// early out if no resolution has been set (line was not rendered yet)
+
+		if ( worldUnits === false && ( this._resolution.x === 0 || this._resolution.y === 0 ) ) {
+
+			return;
+
+		}
+
 		const threshold = ( raycaster.params.Line2 !== undefined ) ? raycaster.params.Line2.threshold || 0 : 0;
 
 		_ray = raycaster.ray;

package/examples/jsm/loaders/3DMLoader.js

@@ -42,7 +42,7 @@ const _taskCache = new WeakMap();
  *
  * ```js
  * const loader = new Rhino3dmLoader();
- * loader.setLibraryPath( 'https://cdn.jsdelivr.net/npm/rhino3dm@8.0.1' );
+ * loader.setLibraryPath( 'https://cdn.jsdelivr.net/npm/rhino3dm@8.17.0/' );
  *
  * const object = await loader.loadAsync( 'models/3dm/Rhino_Logo.3dm' );
  * scene.add( object );