@gnsx/three 0.184.8 → 0.184.10

package/examples/jsm/helpers/LightProbeGridCubeMapHelper.js

@@ -0,0 +1,222 @@
+import {
+	BoxGeometry,
+	Mesh,
+	Object3D,
+	ShaderMaterial,
+	Vector3
+} from 'three';
+import { NodeMaterial } from 'three/webgpu';
+import {
+	cubeTexture,
+	Fn,
+	normalWorld,
+	vec4
+} from 'three/tsl';
+
+function createNodeMaterial( texture ) {
+
+	const fragmentNode = Fn( () => {
+
+		return vec4( cubeTexture( texture, normalWorld ).rgb, 1.0 );
+
+	} )();
+
+	const material = new NodeMaterial();
+	material.fragmentNode = fragmentNode;
+
+	return material;
+
+}
+
+function createShaderMaterial( texture ) {
+
+	return new ShaderMaterial( {
+
+		uniforms: {
+
+			cubeTexture: { value: texture }
+
+		},
+
+		vertexShader: /* glsl */`
+
+			varying vec3 vWorldNormal;
+
+			void main() {
+
+				vWorldNormal = normalize( mat3( modelMatrix ) * normal );
+				gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+			}
+
+		`,
+
+		fragmentShader: /* glsl */`
+
+			precision highp float;
+
+			uniform samplerCube cubeTexture;
+
+			varying vec3 vWorldNormal;
+
+			void main() {
+
+				vec3 direction = normalize( vWorldNormal );
+				vec3 color = textureCube( cubeTexture, direction ).rgb;
+
+				gl_FragColor = vec4( color, 1.0 );
+
+				#include <tonemapping_fragment>
+				#include <colorspace_fragment>
+
+			}
+
+		`
+
+	} );
+
+}
+
+/**
+ * Visualizes an {@link LightProbeGrid} by rendering a cube at each
+ * probe position, displaying the captured cube map on each face.
+ *
+ * Requires the probe grid to be baked with `retainCubemaps: true` option.
+ *
+ * ```js
+ * // First bake with retainCubemaps option
+ * await probeGrid.bake( renderer, scene, { retainCubemaps: true } );
+ *
+ * // Then create the helper
+ * const helper = new LightProbeGridCubeMapHelper( probeGrid );
+ * scene.add( helper );
+ * ```
+ *
+ * @augments Object3D
+ * @three_import import { LightProbeGridCubeMapHelper } from 'three/addons/helpers/LightProbeGridCubeMapHelper.js';
+ */
+class LightProbeGridCubeMapHelper extends Object3D {
+
+	/**
+	 * Constructs a new light probe grid cube map helper.
+	 *
+	 * @param {LightProbeGrid} probes - The probe grid to visualize.
+	 * @param {number} [cubeSize=0.15] - The size of each probe cube.
+	 * @param {Object} [options] - The helper options.
+	 * @param {boolean} [options.webgpu=false] - Whether to use a WebGPU-compatible node material.
+	 */
+	constructor( probes, cubeSize = 0.15, options = {} ) {
+
+		super();
+
+		/**
+		 * The probe grid to visualize.
+		 *
+		 * @type {LightProbeGrid}
+		 */
+		this.probes = probes;
+
+		this.type = 'LightProbeGridCubeMapHelper';
+
+		/**
+		 * The size of each probe cube.
+		 *
+		 * @type {number}
+		 */
+		this.cubeSize = cubeSize;
+
+		/**
+		 * Whether to use WebGPU node materials.
+		 *
+		 * @private
+		 * @type {boolean}
+		 */
+		this._webgpu = options.webgpu === true;
+
+		/**
+		 * Shared cube geometry.
+		 *
+		 * @private
+		 * @type {BoxGeometry}
+		 */
+		this._geometry = new BoxGeometry( cubeSize, cubeSize, cubeSize );
+
+		this.update();
+
+	}
+
+	/**
+	 * Rebuilds cube meshes from the current probe grid.
+	 * Call this after changing `probes` or after re-baking with `retainCubemaps: true`.
+	 */
+	update() {
+
+		this._clearCubes();
+
+		const probes = this.probes;
+		const res = probes.resolution;
+		const cubeTextures = probes.cubeTextures || [];
+		const probePos = new Vector3();
+
+		let i = 0;
+
+		for ( let iz = 0; iz < res.z; iz ++ ) {
+
+			for ( let iy = 0; iy < res.y; iy ++ ) {
+
+				for ( let ix = 0; ix < res.x; ix ++ ) {
+
+					const texture = cubeTextures[ i ];
+
+					if ( texture !== undefined ) {
+
+						const material = this._webgpu === true ? createNodeMaterial( texture ) : createShaderMaterial( texture );
+						const cube = new Mesh( this._geometry, material );
+
+						probes.getProbePosition( ix, iy, iz, probePos );
+						cube.position.copy( probePos );
+						this.add( cube );
+
+					}
+
+					i ++;
+
+				}
+
+			}
+
+		}
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this._clearCubes();
+		this._geometry.dispose();
+
+	}
+
+	/**
+	 * Removes all cube children and disposes their materials.
+	 *
+	 * @private
+	 */
+	_clearCubes() {
+
+		for ( const child of this.children ) {
+
+			child.material.dispose();
+
+		}
+
+		this.clear();
+
+	}
+
+}
+
+export { LightProbeGridCubeMapHelper };

package/examples/jsm/helpers/LightProbeGridHelper.js

@@ -1,136 +1,195 @@
 import {
+	Data3DTexture,
+	FloatType,
 	InstancedBufferAttribute,
 	InstancedMesh,
+	LinearFilter,
 	Matrix4,
+	RGBAFormat,
 	ShaderMaterial,
 	SphereGeometry,
 	Vector3
 } from 'three';
+// WITH_GENESYS
+import { NodeMaterial } from 'three/webgpu';
+import {
+	attribute,
+	Fn,
+	getLightProbeGridIrradianceAtUV,
+	normalWorld,
+	texture3D,
+	uniform,
+	vec4
+} from 'three/tsl';
+// !WITH_GENESYS
+
+// WITH_GENESYS
+const _emptyTexture = /*@__PURE__*/ new Data3DTexture( new Float32Array( 1 * 1 * 28 * 4 ), 1, 1, 28 );
+
+_emptyTexture.format = RGBAFormat;
+_emptyTexture.type = FloatType;
+_emptyTexture.minFilter = LinearFilter;
+_emptyTexture.magFilter = LinearFilter;
+_emptyTexture.needsUpdate = true;
+
+function createNodeMaterial( probes ) {
+
+	const probesSH = texture3D( probes.texture || _emptyTexture );
+	const probesResolution = uniform( new Vector3( 1, 1, 1 ) );
+	const instanceUVW = attribute( 'instanceUVW', 'vec3' );
+
+	const fragmentNode = Fn( () => {
+
+		const irradiance = getLightProbeGridIrradianceAtUV( {
+			probesSH,
+			probesResolution,
+			gridUVW: instanceUVW,
+			worldNormal: normalWorld
+		} );
 
-/**
- * Visualizes an {@link LightProbeGrid} by rendering a sphere at each
- * probe position, shaded with the probe's L1 spherical harmonics.
- *
- * Uses a single `InstancedMesh` draw call for all probes.
- *
- * ```js
- * const helper = new LightProbeGridHelper( probes );
- * scene.add( helper );
- * ```
- *
- * @augments InstancedMesh
- * @three_import import { LightProbeGridHelper } from 'three/addons/helpers/LightProbeGridHelper.js';
- */
-class LightProbeGridHelper extends InstancedMesh {
+		return vec4( irradiance, 1.0 );
 
-	/**
-	 * Constructs a new irradiance probe grid helper.
-	 *
-	 * @param {LightProbeGrid} probes - The probe grid to visualize.
-	 * @param {number} [sphereSize=0.12] - The radius of each probe sphere.
-	 */
-	constructor( probes, sphereSize = 0.12 ) {
+	} )();
 
-		const geometry = new SphereGeometry( sphereSize, 16, 16 );
+	const material = new NodeMaterial();
+	material.fragmentNode = fragmentNode;
 
-		const material = new ShaderMaterial( {
+	return { material, probesSH, probesResolution };
 
-			uniforms: {
+}
+// !WITH_GENESYS
 
-				probesSH: { value: null },
-				probesResolution: { value: new Vector3() },
+function createShaderMaterial() {
 
-			},
+	return new ShaderMaterial( {
 
-			vertexShader: /* glsl */`
+		uniforms: {
 
-				attribute vec3 instanceUVW;
+			probesSH: { value: null },
+			probesResolution: { value: new Vector3() },
 
-				varying vec3 vWorldNormal;
-				varying vec3 vUVW;
+		},
 
-				void main() {
+		vertexShader: /* glsl */`
 
-					vUVW = instanceUVW;
-					vWorldNormal = normalize( mat3( modelMatrix ) * normal );
-					gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4( position, 1.0 );
+			attribute vec3 instanceUVW;
 
-				}
+			varying vec3 vWorldNormal;
+			varying vec3 vUVW;
+
+			void main() {
 
-			`,
+				vUVW = instanceUVW;
+				vWorldNormal = normalize( mat3( modelMatrix ) * normal );
+				gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4( position, 1.0 );
 
-			fragmentShader: /* glsl */`
+			}
 
-				precision highp sampler3D;
+		`,
 
-				uniform sampler3D probesSH;
-				uniform vec3 probesResolution;
+		fragmentShader: /* glsl */`
 
-				varying vec3 vWorldNormal;
-				varying vec3 vUVW;
+			precision highp sampler3D;
 
-				void main() {
+			uniform sampler3D probesSH;
+			uniform vec3 probesResolution;
 
-					// Atlas UV mapping — must match lightprobes_pars_fragment.glsl.js
-					float nz          = probesResolution.z;
-					float paddedSlices = nz + 2.0;
-					float atlasDepth  = 7.0 * paddedSlices;
-					float uvZBase     = vUVW.z * nz + 1.0;
+			varying vec3 vWorldNormal;
+			varying vec3 vUVW;
 
-					vec4 s0 = texture( probesSH, vec3( vUVW.xy, ( uvZBase                       ) / atlasDepth ) );
-					vec4 s1 = texture( probesSH, vec3( vUVW.xy, ( uvZBase +       paddedSlices   ) / atlasDepth ) );
-					vec4 s2 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 2.0 * paddedSlices   ) / atlasDepth ) );
-					vec4 s3 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 3.0 * paddedSlices   ) / atlasDepth ) );
-					vec4 s4 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 4.0 * paddedSlices   ) / atlasDepth ) );
-					vec4 s5 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 5.0 * paddedSlices   ) / atlasDepth ) );
-					vec4 s6 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 6.0 * paddedSlices   ) / atlasDepth ) );
+			void main() {
 
-					// Unpack 9 vec3 SH L2 coefficients
+				// Atlas UV mapping — must match lightprobes_pars_fragment.glsl.js
+				float nz          = probesResolution.z;
+				float paddedSlices = nz + 2.0;
+				float atlasDepth  = 7.0 * paddedSlices;
+				float uvZBase     = vUVW.z * nz + 1.0;
 
-					vec3 c0 = s0.xyz;
-					vec3 c1 = vec3( s0.w, s1.xy );
-					vec3 c2 = vec3( s1.zw, s2.x );
-					vec3 c3 = s2.yzw;
-					vec3 c4 = s3.xyz;
-					vec3 c5 = vec3( s3.w, s4.xy );
-					vec3 c6 = vec3( s4.zw, s5.x );
-					vec3 c7 = s5.yzw;
-					vec3 c8 = s6.xyz;
+				vec4 s0 = texture( probesSH, vec3( vUVW.xy, ( uvZBase                       ) / atlasDepth ) );
+				vec4 s1 = texture( probesSH, vec3( vUVW.xy, ( uvZBase +       paddedSlices   ) / atlasDepth ) );
+				vec4 s2 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 2.0 * paddedSlices   ) / atlasDepth ) );
+				vec4 s3 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 3.0 * paddedSlices   ) / atlasDepth ) );
+				vec4 s4 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 4.0 * paddedSlices   ) / atlasDepth ) );
+				vec4 s5 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 5.0 * paddedSlices   ) / atlasDepth ) );
+				vec4 s6 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 6.0 * paddedSlices   ) / atlasDepth ) );
 
-					vec3 n = normalize( vWorldNormal );
+				// Unpack 9 vec3 SH L2 coefficients
 
-					float x = n.x, y = n.y, z = n.z;
+				vec3 c0 = s0.xyz;
+				vec3 c1 = vec3( s0.w, s1.xy );
+				vec3 c2 = vec3( s1.zw, s2.x );
+				vec3 c3 = s2.yzw;
+				vec3 c4 = s3.xyz;
+				vec3 c5 = vec3( s3.w, s4.xy );
+				vec3 c6 = vec3( s4.zw, s5.x );
+				vec3 c7 = s5.yzw;
+				vec3 c8 = s6.xyz;
 
-					// band 0
-					vec3 result = c0 * 0.886227;
+				vec3 n = normalize( vWorldNormal );
 
-					// band 1,
-					result += c1 * 2.0 * 0.511664 * y;
-					result += c2 * 2.0 * 0.511664 * z;
-					result += c3 * 2.0 * 0.511664 * x;
+				float x = n.x, y = n.y, z = n.z;
 
-					// band 2,
-					result += c4 * 2.0 * 0.429043 * x * y;
-					result += c5 * 2.0 * 0.429043 * y * z;
-					result += c6 * ( 0.743125 * z * z - 0.247708 );
-					result += c7 * 2.0 * 0.429043 * x * z;
-					result += c8 * 0.429043 * ( x * x - y * y );
+				// band 0
+				vec3 result = c0 * 0.886227;
 
-					gl_FragColor = vec4( max( result, vec3( 0.0 ) ), 1.0 );
+				// band 1,
+				result += c1 * 2.0 * 0.511664 * y;
+				result += c2 * 2.0 * 0.511664 * z;
+				result += c3 * 2.0 * 0.511664 * x;
 
-					#include <tonemapping_fragment>
-					#include <colorspace_fragment>
+				// band 2,
+				result += c4 * 2.0 * 0.429043 * x * y;
+				result += c5 * 2.0 * 0.429043 * y * z;
+				result += c6 * ( 0.743125 * z * z - 0.247708 );
+				result += c7 * 2.0 * 0.429043 * x * z;
+				result += c8 * 0.429043 * ( x * x - y * y );
 
-				}
+				gl_FragColor = vec4( max( result, vec3( 0.0 ) ), 1.0 );
 
-			`
+				#include <tonemapping_fragment>
+				#include <colorspace_fragment>
 
-		} );
+			}
+
+		`
+
+	} );
+
+}
+
+/**
+ * Visualizes an {@link LightProbeGrid} by rendering a sphere at each
+ * probe position, shaded with the probe's L1 spherical harmonics.
+ *
+ * Uses a single `InstancedMesh` draw call for all probes.
+ *
+ * ```js
+ * const helper = new LightProbeGridHelper( probes );
+ * scene.add( helper );
+ * ```
+ *
+ * @augments InstancedMesh
+ * @three_import import { LightProbeGridHelper } from 'three/addons/helpers/LightProbeGridHelper.js';
+ */
+class LightProbeGridHelper extends InstancedMesh {
+
+	/**
+	 * Constructs a new irradiance probe grid helper.
+	 *
+	 * @param {LightProbeGrid} probes - The probe grid to visualize.
+	 * @param {number} [sphereSize=0.12] - The radius of each probe sphere.
+	 * @param {Object} [options] - The helper options.
+	 * @param {boolean} [options.webgpu=false] - Whether to use a WebGPU-compatible node material.
+	 */
+	constructor( probes, sphereSize = 0.12, options = {} ) {
+
+		const geometry = new SphereGeometry( sphereSize, 16, 16 );
+		const materialState = options.webgpu === true ? createNodeMaterial( probes ) : { material: createShaderMaterial() };
 
 		const res = probes.resolution;
 		const count = res.x * res.y * res.z;
 
-		super( geometry, material, count );
+		super( geometry, materialState.material, count );
 
 		/**
 		 * The probe grid to visualize.
@@ -141,6 +200,11 @@ class LightProbeGridHelper extends InstancedMesh {
 
 		this.type = 'LightProbeGridHelper';
 
+		// WITH_GENESYS
+		this._probesSH = materialState.probesSH || null;
+		this._probesResolution = materialState.probesResolution || null;
+		// !WITH_GENESYS
+
 		this.update();
 
 	}
@@ -155,17 +219,17 @@ class LightProbeGridHelper extends InstancedMesh {
 		const res = probes.resolution;
 		const count = res.x * res.y * res.z;
 
-		// Resize instance matrix buffer if needed
-
 		if ( this.instanceMatrix.count !== count ) {
 
+			// WITH_GENESYS
+			this.instanceMatrix.dispose();
+			// !WITH_GENESYS
 			this.instanceMatrix = new InstancedBufferAttribute( new Float32Array( count * 16 ), 16 );
 
 		}
 
 		this.count = count;
 
-		const uvwArray = new Float32Array( count * 3 );
 		const matrix = new Matrix4();
 		const probePos = new Vector3();
 
@@ -177,11 +241,6 @@ class LightProbeGridHelper extends InstancedMesh {
 
 				for ( let ix = 0; ix < res.x; ix ++ ) {
 
-					// Remap to texel centers (must match lightprobes_pars_fragment.glsl.js)
-					uvwArray[ i * 3 ] = ( ix + 0.5 ) / res.x;
-					uvwArray[ i * 3 + 1 ] = ( iy + 0.5 ) / res.y;
-					uvwArray[ i * 3 + 2 ] = ( iz + 0.5 ) / res.z;
-
 					probes.getProbePosition( ix, iy, iz, probePos );
 					matrix.makeTranslation( probePos.x, probePos.y, probePos.z );
 					this.setMatrixAt( i, matrix );
@@ -196,12 +255,65 @@ class LightProbeGridHelper extends InstancedMesh {
 
 		this.instanceMatrix.needsUpdate = true;
 
-		this.geometry.setAttribute( 'instanceUVW', new InstancedBufferAttribute( uvwArray, 3 ) );
+		let instanceUVW = this.geometry.getAttribute( 'instanceUVW' );
+
+		if ( instanceUVW === undefined || instanceUVW.count !== count ) {
+
+			// WITH_GENESYS
+			if ( instanceUVW !== undefined ) {
+
+				instanceUVW.dispose();
+
+			}
+			// !WITH_GENESYS
+
+			const uvwArray = new Float32Array( count * 3 );
+
+			i = 0;
+
+			for ( let iz = 0; iz < res.z; iz ++ ) {
+
+				for ( let iy = 0; iy < res.y; iy ++ ) {
+
+					for ( let ix = 0; ix < res.x; ix ++ ) {
+
+						// Remap to texel centers (must match lightprobes_pars_fragment.glsl.js)
+						uvwArray[ i * 3 ] = ( ix + 0.5 ) / res.x;
+						uvwArray[ i * 3 + 1 ] = ( iy + 0.5 ) / res.y;
+						uvwArray[ i * 3 + 2 ] = ( iz + 0.5 ) / res.z;
+
+						i ++;
+
+					}
+
+				}
+
+			}
+
+			instanceUVW = new InstancedBufferAttribute( uvwArray, 3 );
+			this.geometry.setAttribute( 'instanceUVW', instanceUVW );
+
+		}
 
 		// Update texture uniforms
 
-		this.material.uniforms.probesSH.value = probes.texture;
-		this.material.uniforms.probesResolution.value.copy( probes.resolution );
+		// WITH_GENESYS
+		if ( this._probesSH !== null && this._probesResolution !== null ) {
+
+			this._probesSH.value = probes.texture || _emptyTexture;
+			this._probesResolution.value.copy( probes.resolution );
+
+		} else {
+
+			// !WITH_GENESYS
+
+			this.material.uniforms.probesSH.value = probes.texture;
+			this.material.uniforms.probesResolution.value.copy( probes.resolution );
+
+			// WITH_GENESYS
+
+		}
+		// !WITH_GENESYS
 
 	}
 
@@ -211,6 +323,18 @@ class LightProbeGridHelper extends InstancedMesh {
 	 */
 	dispose() {
 
+		// WITH_GENESYS
+		this.instanceMatrix.dispose();
+
+		const instanceUVW = this.geometry.getAttribute( 'instanceUVW' );
+
+		if ( instanceUVW !== undefined ) {
+
+			instanceUVW.dispose();
+
+		}
+		// !WITH_GENESYS
+
 		this.geometry.dispose();
 		this.material.dispose();
 

package/examples/jsm/inspector/tabs/Settings.js

@@ -233,7 +233,7 @@ class Settings extends Parameters {
 		const extUrl = new URL( extension.url, new URL( _EXTENSIONS_PATH, import.meta.url ) ).href;
 
 		// WITH_GENESYS
-		const module = await import( /* webpackIgnore: true */ extUrl );
+		const module = await import( /* @vite-ignore */ /* webpackIgnore: true */ extUrl );
 		// !WITH_GENESYS
 
 		const keys = Object.keys( module );