@gnsx/three 0.184.8 → 0.184.10

package/examples/jsm/tsl/lighting/DynamicLightsNode.js

@@ -1,4 +1,8 @@
-import { LightsNode, NodeUtils, warn } from 'three/webgpu';
+import {
+	LightsNode,
+	NodeUtils,
+	warn
+} from 'three/webgpu';
 import { nodeObject } from 'three/tsl';
 
 import AmbientLightDataNode from './data/AmbientLightDataNode.js';
@@ -145,6 +149,16 @@ class DynamicLightsNode extends LightsNode {
 
 		}
 
+		// WITH_GENESYS
+		for ( let i = 0; i < this._lightProbeGrids.length; i ++ ) {
+
+			const lightProbeGrid = this._lightProbeGrids[ i ];
+
+			_hashData.push( lightProbeGrid.id );
+
+		}
+		// !WITH_GENESYS
+
 		const cacheKey = NodeUtils.hashArray( _hashData );
 
 		_hashData.length = 0;
@@ -230,6 +244,10 @@ class DynamicLightsNode extends LightsNode {
 
 		}
 
+		// WITH_GENESYS
+		this._appendLightProbeGridNode( lightNodes );
+		// !WITH_GENESYS
+
 		this._lightNodes = lightNodes;
 
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gnsx/three",
-  "version": "0.184.8",
+  "version": "0.184.10",
   "description": "JavaScript 3D library",
   "type": "module",
   "main": "./build/three.cjs",

package/src/Three.TSL.js

@@ -202,6 +202,10 @@ export const getCurrentStack = TSL.getCurrentStack;
 export const getDirection = TSL.getDirection;
 export const getDistanceAttenuation = TSL.getDistanceAttenuation;
 export const getGeometryRoughness = TSL.getGeometryRoughness;
+// WITH_GENESYS
+export const getLightProbeGridIrradiance = TSL.getLightProbeGridIrradiance;
+export const getLightProbeGridIrradianceAtUV = TSL.getLightProbeGridIrradianceAtUV;
+// !WITH_GENESYS
 export const getNormalFromDepth = TSL.getNormalFromDepth;
 export const interleavedGradientNoise = TSL.interleavedGradientNoise;
 export const vogelDiskSample = TSL.vogelDiskSample;

package/src/nodes/Nodes.js

@@ -116,6 +116,9 @@ export { default as IESSpotLightNode } from './lighting/IESSpotLightNode.js';
 export { default as IrradianceNode } from './lighting/IrradianceNode.js';
 export { default as LightingContextNode } from './lighting/LightingContextNode.js';
 export { default as LightingNode } from './lighting/LightingNode.js';
+// WITH_GENESYS
+export { default as LightProbeGridNode } from './lighting/LightProbeGridNode.js';
+// !WITH_GENESYS
 export { default as LightProbeNode } from './lighting/LightProbeNode.js';
 export { default as LightsNode } from './lighting/LightsNode.js';
 // WITH_GENESYS

package/src/nodes/TSL.js

@@ -168,6 +168,10 @@ export { default as V_GGX_SmithCorrelated } from './functions/BSDF/V_GGX_SmithCo
 export * from './lighting/LightUtils.js';
 
 export { default as getGeometryRoughness } from './functions/material/getGeometryRoughness.js';
+// WITH_GENESYS
+export { default as getLightProbeGridIrradiance } from './functions/material/getLightProbeGridIrradiance.js';
+export { getLightProbeGridIrradianceAtUV } from './functions/material/getLightProbeGridIrradiance.js';
+// !WITH_GENESYS
 export { default as getParallaxCorrectNormal } from './functions/material/getParallaxCorrectNormal.js';
 export { default as getRoughness } from './functions/material/getRoughness.js';
 export { default as getShIrradianceAt } from './functions/material/getShIrradianceAt.js';

package/src/nodes/accessors/CubeTextureNode.js

@@ -126,7 +126,13 @@ class CubeTextureNode extends TextureNode {
 
 		// rotate first
 
-		uvNode = materialEnvRotation.mul( uvNode );
+		// WITH_GENESYS: Skip material/scene env rotation in compute — no material or scene context.
+		if ( builder.shaderStage !== 'compute' ) {
+
+			uvNode = materialEnvRotation.mul( uvNode );
+
+		}
+		// !WITH_GENESYS
 
 		// flip
 

package/src/nodes/accessors/TextureNode.js

@@ -366,7 +366,27 @@ class TextureNode extends UniformNode {
 
 			if ( this.updateMatrix === true ) {
 
-				uvNode = this.getTransformedUV( uvNode );
+				// eslint-disable-next-line no-constant-condition
+				if ( true ) {
+
+					// WITH_GENESYS: Do not apply UV matrix to integer texel coords or storage textures.
+					const explicitUV = this.uvNode;
+					const explicitUVType = explicitUV ? explicitUV.getNodeType( builder ) : null;
+					const isIntegerTexelCoord = explicitUVType === 'uvec2' || explicitUVType === 'uvec3' || explicitUVType === 'ivec2' || explicitUVType === 'ivec3';
+					const isStorageTexture = texture.isStorageTexture === true;
+
+					if ( isIntegerTexelCoord === false && isStorageTexture === false ) {
+
+						uvNode = this.getTransformedUV( uvNode );
+
+					}
+					// !WITH_GENESYS
+
+				} else {
+
+					uvNode = this.getTransformedUV( uvNode );
+
+				}
 
 			}
 

package/src/nodes/functions/material/getLightProbeGridIrradiance.js

@@ -0,0 +1,68 @@
+import { Fn, max, vec3 } from '../../tsl/TSLBase.js';
+
+export const getLightProbeGridIrradianceAtUV = /*@__PURE__*/ Fn( ( { probesSH, probesResolution, gridUVW, worldNormal } ) => {
+
+	const res = probesResolution;
+	const uvw = gridUVW.toVar();
+
+	const nz = res.z;
+	const paddedSlices = nz.add( 2.0 );
+	const atlasDepth = paddedSlices.mul( 7.0 );
+	const uvZBase = uvw.z.mul( nz ).add( 1.0 );
+
+	const atlasUv = ( sliceOffset ) => vec3( uvw.x, uvw.y, uvZBase.add( paddedSlices.mul( sliceOffset ) ).div( atlasDepth ) );
+
+	const s0 = probesSH.sample( atlasUv( 0.0 ) );
+	const s1 = probesSH.sample( atlasUv( 1.0 ) );
+	const s2 = probesSH.sample( atlasUv( 2.0 ) );
+	const s3 = probesSH.sample( atlasUv( 3.0 ) );
+	const s4 = probesSH.sample( atlasUv( 4.0 ) );
+	const s5 = probesSH.sample( atlasUv( 5.0 ) );
+	const s6 = probesSH.sample( atlasUv( 6.0 ) );
+
+	const c0 = s0.xyz;
+	const c1 = vec3( s0.w, s1.x, s1.y );
+	const c2 = vec3( s1.z, s1.w, s2.x );
+	const c3 = s2.yzw;
+	const c4 = s3.xyz;
+	const c5 = vec3( s3.w, s4.x, s4.y );
+	const c6 = vec3( s4.z, s4.w, s5.x );
+	const c7 = s5.yzw;
+	const c8 = s6.xyz;
+
+	const x = worldNormal.x, y = worldNormal.y, z = worldNormal.z;
+
+	let result = c0.mul( 0.886227 );
+	result = result.add( c1.mul( 2.0 * 0.511664 ).mul( y ) );
+	result = result.add( c2.mul( 2.0 * 0.511664 ).mul( z ) );
+	result = result.add( c3.mul( 2.0 * 0.511664 ).mul( x ) );
+	result = result.add( c4.mul( 2.0 * 0.429043 ).mul( x ).mul( y ) );
+	result = result.add( c5.mul( 2.0 * 0.429043 ).mul( y ).mul( z ) );
+	result = result.add( c6.mul( z.mul( z ).mul( 0.743125 ).sub( 0.247708 ) ) );
+	result = result.add( c7.mul( 2.0 * 0.429043 ).mul( x ).mul( z ) );
+	result = result.add( c8.mul( 0.429043 ).mul( x.mul( x ).sub( y.mul( y ) ) ) );
+
+	return max( result, vec3( 0.0 ) );
+
+} );
+
+const getLightProbeGridIrradiance = /*@__PURE__*/ Fn( ( { probesSH, probesMin, probesMax, probesResolution, worldPosition, worldNormal } ) => {
+
+	const res = probesResolution;
+	const gridRange = probesMax.sub( probesMin ).toVar();
+	const resMinusOne = res.sub( 1.0 );
+	const probeSpacing = gridRange.div( resMinusOne ).toVar();
+
+	const samplePos = worldPosition.add( worldNormal.mul( probeSpacing ).mul( 0.5 ) );
+	const gridUVW = samplePos.sub( probesMin ).div( gridRange ).clamp( 0.0, 1.0 ).mul( resMinusOne.div( res ) ).add( vec3( 0.5 ).div( res ) );
+
+	return getLightProbeGridIrradianceAtUV( {
+		probesSH,
+		probesResolution,
+		gridUVW,
+		worldNormal
+	} );
+
+} );
+
+export default getLightProbeGridIrradiance;

package/src/nodes/lighting/LightProbeGridNode.js

@@ -0,0 +1,137 @@
+import LightingNode from './LightingNode.js';
+import { normalWorld } from '../accessors/Normal.js';
+import { positionWorld } from '../accessors/Position.js';
+import { texture3D } from '../accessors/Texture3DNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { uniform } from '../core/UniformNode.js';
+import getLightProbeGridIrradiance from '../functions/material/getLightProbeGridIrradiance.js';
+import { FloatType, LinearFilter, RGBAFormat } from '../../constants.js';
+import { Data3DTexture } from '../../textures/Data3DTexture.js';
+import { Vector3 } from '../../math/Vector3.js';
+
+const _objectPosition = /*@__PURE__*/ new Vector3();
+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 findLightProbeGrid( volumes, object ) {
+
+	if ( volumes.length === 0 ) return null;
+
+	if ( volumes.length === 1 ) {
+
+		return volumes[ 0 ].texture !== null ? volumes[ 0 ] : null;
+
+	}
+
+	_objectPosition.setFromMatrixPosition( object.matrixWorld );
+
+	for ( let i = 0, l = volumes.length; i < l; i ++ ) {
+
+		const volume = volumes[ i ];
+
+		if ( volume.texture !== null && volume.boundingBox.containsPoint( _objectPosition ) ) return volume;
+
+	}
+
+	return null;
+
+}
+
+/**
+ * Adds diffuse irradiance from the active LightProbeGrid to WebGPU node materials.
+ *
+ * @augments LightingNode
+ */
+class LightProbeGridNode extends LightingNode {
+
+	static get type() {
+
+		return 'LightProbeGridNode';
+
+	}
+
+	/**
+	 * Constructs a new light probe grid node.
+	 *
+	 * @param {Array<Object3D>} [lightProbeGrids=[]] - Light probe grids collected from the scene.
+	 */
+	constructor( lightProbeGrids = [] ) {
+
+		super();
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isLightProbeGridNode = true;
+
+		this.lightProbeGrids = lightProbeGrids;
+		this.activeLightProbeGrid = null;
+
+		this.probesSH = texture3D( _emptyTexture );
+		this.probesMin = uniform( new Vector3() );
+		this.probesMax = uniform( new Vector3( 1, 1, 1 ) );
+		this.probesResolution = uniform( new Vector3( 2, 2, 2 ) );
+
+		this.updateType = NodeUpdateType.OBJECT;
+
+	}
+
+	update( frame ) {
+
+		const activeLightProbeGrid = findLightProbeGrid( this.lightProbeGrids, frame.object );
+
+		this.activeLightProbeGrid = activeLightProbeGrid;
+
+		if ( activeLightProbeGrid !== null ) {
+
+			activeLightProbeGrid.updateBoundingBox();
+
+			this.probesSH.value = activeLightProbeGrid.texture;
+			this.probesMin.value.copy( activeLightProbeGrid.boundingBox.min );
+			this.probesMax.value.copy( activeLightProbeGrid.boundingBox.max );
+			this.probesResolution.value.copy( activeLightProbeGrid.resolution );
+
+		} else {
+
+			this.probesSH.value = _emptyTexture;
+			this.probesMin.value.set( 0, 0, 0 );
+			this.probesMax.value.set( 1, 1, 1 );
+			this.probesResolution.value.set( 2, 2, 2 );
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		const irradiance = getLightProbeGridIrradiance( {
+			probesSH: this.probesSH,
+			probesMin: this.probesMin,
+			probesMax: this.probesMax,
+			probesResolution: this.probesResolution,
+			worldPosition: positionWorld,
+			worldNormal: normalWorld
+		} );
+
+		builder.context.irradiance.addAssign( irradiance );
+
+	}
+
+	getHash() {
+
+		return `lightProbeGrid-${ this.lightProbeGrids.map( ( lightProbeGrid ) => lightProbeGrid.id ).join( ',' ) }`;
+
+	}
+
+}
+
+export default LightProbeGridNode;

package/src/nodes/lighting/LightsNode.js

@@ -2,6 +2,9 @@ import Node from '../core/Node.js';
 import { nodeObject, property, vec3 } from '../tsl/TSLBase.js';
 import { hashArray } from '../core/NodeUtils.js';
 import { warn } from '../../utils.js';
+// WITH_GENESYS
+import LightProbeGridNode from './LightProbeGridNode.js';
+// !WITH_GENESYS
 
 const sortLights = ( lights ) => {
 
@@ -79,6 +82,25 @@ class LightsNode extends Node {
 		 */
 		this._lights = [];
 
+		// WITH_GENESYS
+		/**
+		 * A list of light probe grids collected from the scene.
+		 *
+		 * @private
+		 * @type {Array<Object3D>}
+		 */
+		this._lightProbeGrids = [];
+
+		/**
+		 * Cached light probe grid node reused across {@link LightsNode#setupLightsNode} calls.
+		 *
+		 * @private
+		 * @type {?LightProbeGridNode}
+		 * @default null
+		 */
+		this._lightProbeGridNode = null;
+		// !WITH_GENESYS
+
 		/**
 		 * For each light in the scene, this node will create a
 		 * corresponding light node.
@@ -136,6 +158,18 @@ class LightsNode extends Node {
 
 		}
 
+		// WITH_GENESYS
+		const lightProbeGrids = this._lightProbeGrids;
+
+		for ( let i = 0; i < lightProbeGrids.length; i ++ ) {
+
+			const lightProbeGrid = lightProbeGrids[ i ];
+
+			_hashData.push( lightProbeGrid.id );
+
+		}
+		// !WITH_GENESYS
+
 		const cacheKey = hashArray( _hashData );
 
 		_hashData.length = 0;
@@ -244,10 +278,44 @@ class LightsNode extends Node {
 
 		}
 
+		// WITH_GENESYS
+		this._appendLightProbeGridNode( lightNodes );
+		// !WITH_GENESYS
+
 		this._lightNodes = lightNodes;
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Appends the cached {@link LightProbeGridNode} for the current probe grids.
+	 *
+	 * @private
+	 * @param {Array<LightingNode>} lightNodes - The light nodes array being built.
+	 */
+	_appendLightProbeGridNode( lightNodes ) {
+
+		if ( this._lightProbeGrids.length === 0 ) {
+
+			return;
+
+		}
+
+		if ( this._lightProbeGridNode === null ) {
+
+			this._lightProbeGridNode = new LightProbeGridNode( this._lightProbeGrids );
+
+		} else {
+
+			this._lightProbeGridNode.lightProbeGrids = this._lightProbeGrids;
+
+		}
+
+		lightNodes.push( this._lightProbeGridNode );
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Sets up a direct light in the lighting model.
 	 *
@@ -394,6 +462,31 @@ class LightsNode extends Node {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Configures this node with an array of light probe grids.
+	 *
+	 * @param {Array<Object3D>} lightProbeGrids - An array of light probe grids.
+	 * @return {LightsNode} A reference to this node.
+	 */
+	setLightProbeGrids( lightProbeGrids ) {
+
+		this._lightProbeGrids = lightProbeGrids;
+
+		if ( this._lightProbeGridNode !== null ) {
+
+			this._lightProbeGridNode.lightProbeGrids = lightProbeGrids;
+
+		}
+
+		this._lightNodes = null;
+		this._lightNodesHash = null;
+
+		return this;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Returns an array of the scene's lights.
 	 *
@@ -412,7 +505,11 @@ class LightsNode extends Node {
 	 */
 	get hasLights() {
 
-		return this._lights.length > 0;
+		return this._lights.length > 0
+			// WITH_GENESYS
+			|| this._lightProbeGrids.length > 0
+			// !WITH_GENESYS
+		;
 
 	}
 

package/src/renderers/common/Background.js

@@ -44,6 +44,39 @@ class Background extends DataMap {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Disposes the renderer-owned background skybox mesh (material and geometry)
+	 * for `scene` and clears cached mesh state.
+	 *
+	 * Does not dispose {@link Scene#background}.
+	 *
+	 * @param {Scene} scene - The scene.
+	 */
+	disposeScene( scene ) {
+
+		if ( this.has( scene ) === false ) return;
+
+		const sceneData = this.get( scene );
+
+		const backgroundMesh = sceneData.backgroundMesh;
+
+		if ( backgroundMesh !== undefined ) {
+
+			this.renderer._objects.disposeObjectResources( backgroundMesh, scene );
+
+			backgroundMesh.material.dispose();
+			backgroundMesh.geometry.dispose();
+
+			delete sceneData.backgroundMesh;
+			delete sceneData.backgroundMeshNode;
+			delete sceneData.backgroundCacheKey;
+
+		}
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Updates the background for the given scene. Depending on how `Scene.background`
 	 * or `Scene.backgroundNode` are configured, this method might configure a simple clear

package/src/renderers/common/RenderList.js

@@ -161,6 +161,15 @@ class RenderList {
 		 */
 		this.lightsArray = [];
 
+		// WITH_GENESYS
+		/**
+		 * The scene's light probe grids stored in an array.
+		 *
+		 * @type {Array<Object3D>}
+		 */
+		this.lightProbeGridsArray = [];
+		// !WITH_GENESYS
+
 		/**
 		 * The scene.
 		 *
@@ -202,6 +211,9 @@ class RenderList {
 		this.bundles.length = 0;
 
 		this.lightsArray.length = 0;
+		// WITH_GENESYS
+		this.lightProbeGridsArray.length = 0;
+		// !WITH_GENESYS
 
 		this.occlusionQueryCount = 0;
 
@@ -353,6 +365,19 @@ class RenderList {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Pushes a light probe grid into the render list.
+	 *
+	 * @param {Object3D} lightProbeGrid - The light probe grid.
+	 */
+	pushLightProbeGrid( lightProbeGrid ) {
+
+		this.lightProbeGridsArray.push( lightProbeGrid );
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Sorts the internal render lists.
 	 *
@@ -376,6 +401,9 @@ class RenderList {
 		// update lights
 
 		this.lightsNode.setLights( this.lightsArray );
+		// WITH_GENESYS
+		this.lightsNode.setLightProbeGrids( this.lightProbeGridsArray );
+		// !WITH_GENESYS
 
 		// Clear references from inactive renderItems in the list
 

package/src/renderers/common/RenderObjects.js

@@ -207,6 +207,53 @@ class RenderObjects {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Disposes every {@link RenderObject} associated with `scene`.
+	 *
+	 * @param {Scene} scene - The scene being removed.
+	 */
+	disposeSceneResources( scene ) {
+
+		const renderObjects = Array.from( this._renderObjects );
+
+		for ( const renderObject of renderObjects ) {
+
+			if ( renderObject.scene === scene ) {
+
+				renderObject.dispose();
+
+			}
+
+		}
+
+	}
+
+	/**
+	 * Disposes every {@link RenderObject} for `object` drawn with `scene`.
+	 * Call before disposing a renderer-owned mesh (e.g. background skybox) so WebGPU
+	 * bindings are released while the renderer keeps running.
+	 *
+	 * @param {Object3D} object - The 3D object.
+	 * @param {Scene} scene - The scene reference used when the object was rendered.
+	 */
+	disposeObjectResources( object, scene ) {
+
+		const renderObjects = Array.from( this._renderObjects );
+
+		for ( const renderObject of renderObjects ) {
+
+			if ( renderObject.object === object && renderObject.scene === scene ) {
+
+				renderObject.dispose();
+
+			}
+
+		}
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Factory method for creating render objects with the given list of parameters.
 	 *

package/src/renderers/common/Renderer.js

@@ -935,7 +935,11 @@ class Renderer {
 
 					renderList.pushLight( object );
 
-				}
+				} else if ( object.isLightProbeGrid && object.layers.test( camera.layers ) ) { // WITH_GENESYS
+
+					renderList.pushLightProbeGrid( object );
+
+				} // !WITH_GENESYS
 
 			} );
 
@@ -2552,6 +2556,28 @@ class Renderer {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Releases renderer resources scoped to `scene` when the scene is removed but
+	 * this renderer instance continues to run. Disposes matching {@link RenderObject}s,
+	 * the internal background skybox mesh, and cached background/environment nodes.
+	 *
+	 * Does not call `texture.dispose()` on {@link Scene#background} or
+	 * {@link Scene#environment}; the caller remains responsible for those textures.
+	 *
+	 * @param {Scene} scene - The scene being removed.
+	 */
+	disposeSceneResources( scene ) {
+
+		if ( this._initialized !== true ) return;
+
+		this._objects.disposeSceneResources( scene );
+		this._nodes.clearSceneBackgroundAndEnvironmentNodes( scene );
+		this._background.disposeScene( scene );
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Sets the given render target. Calling this method means the renderer does not
 	 * target the default framebuffer (meaning the canvas) anymore but a custom framebuffer.
@@ -3085,7 +3111,11 @@ class Renderer {
 
 				renderList.pushLight( object );
 
-			} else if ( object.isSprite ) {
+			} else if ( object.isLightProbeGrid ) { // WITH_GENESYS
+
+				renderList.pushLightProbeGrid( object );
+
+			} else if ( object.isSprite ) { // !WITH_GENESYS
 
 				const frustum = camera.isArrayCamera ? _frustumArray : _frustum;