@gnsx/three 0.184.5 → 0.184.7

package/examples/jsm/inspector/Inspector.js

@@ -514,28 +514,71 @@ class Inspector extends RendererInspector {
 
 }
 
+const STORAGE_KEY_THREE_INSPECTOR = 'threejs-inspector';
+
+function getStorageOrNull() {
+
+	try {
+
+		const storage = globalThis.localStorage;
+		if ( storage === undefined || storage === null ) return null;
+		if ( typeof storage.getItem !== 'function' || typeof storage.setItem !== 'function' ) return null;
+		return storage;
+
+	} catch {
+
+		return null;
+
+	}
+
+}
+
 function getItem( id ) {
 
-	const data = JSON.parse( localStorage.getItem( 'threejs-inspector' ) || '{}' );
-	return data[ id ] || {};
+	const storage = getStorageOrNull();
+	if ( storage === null ) return {};
+
+	try {
+
+		const raw = storage.getItem( STORAGE_KEY_THREE_INSPECTOR );
+		const data = JSON.parse( raw || '{}' );
+		return data[ id ] || {};
+
+	} catch {
+
+		return {};
+
+	}
 
 }
 
 function setItem( id, state ) {
 
-	const data = JSON.parse( localStorage.getItem( 'threejs-inspector' ) || '{}' );
+	const storage = getStorageOrNull();
+	if ( storage === null ) return;
 
-	if ( state === null ) {
+	try {
 
-		delete data[ id ];
+		const raw = storage.getItem( STORAGE_KEY_THREE_INSPECTOR );
+		const data = JSON.parse( raw || '{}' );
 
-	} else {
+		if ( state === null ) {
 
-		data[ id ] = state;
+			delete data[ id ];
 
-	}
+		} else {
+
+			data[ id ] = state;
 
-	localStorage.setItem( 'threejs-inspector', JSON.stringify( data ) );
+		}
+
+		storage.setItem( STORAGE_KEY_THREE_INSPECTOR, JSON.stringify( data ) );
+
+	} catch {
+
+		// Headless / private mode / blocked storage: skip persistence
+
+	}
 
 }
 

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

@@ -232,7 +232,7 @@ class Settings extends Parameters {
 
 		const extUrl = new URL( extension.url, new URL( _EXTENSIONS_PATH, import.meta.url ) ).href;
 
-		const module = await import( extUrl );
+		const module = await import( /* webpackIgnore: true */ extUrl );
 
 		const keys = Object.keys( module );
 		const ExtensionClass = module[ keys[ 0 ] ];

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@gnsx/three",
-  "version": "0.184.5",
-  "types": "index.d.ts",
+  "version": "0.184.7",
   "description": "JavaScript 3D library",
   "type": "module",
   "main": "./build/three.cjs",
   "module": "./build/three.module.js",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
       "import": "./build/three.module.js",
       "require": "./build/three.cjs"
     },
@@ -31,7 +29,6 @@
     "build",
     "examples/jsm",
     "examples/fonts",
-    "index.d.ts",
     "LICENSE",
     "package.json",
     "README.md",
@@ -127,8 +124,5 @@
       "build/three.module.js"
     ],
     "directories": {}
-  },
-  "dependencies": {
-    "@gnsx/three-types": "^0.184.1"
   }
 }

package/src/materials/nodes/NodeMaterial.js

@@ -1047,7 +1047,10 @@ class NodeMaterial extends Material {
 
 		if ( materialLightsNode.length > 0 ) {
 
-			lightsN = builder.renderer.lighting.createNode( [ ...lightsN.getLights(), ...materialLightsNode ] );
+			// WITH_GENESYS
+			lightsN = builder.renderer.lighting.createMaterialNode( lightsN, materialLightsNode );
+			// !WITH_GENESYS
+			// lightsN = builder.renderer.lighting.createNode( [ ...lightsN.getLights(), ...materialLightsNode ] );
 
 		}
 

package/src/nodes/Nodes.js

@@ -118,6 +118,9 @@ export { default as LightingContextNode } from './lighting/LightingContextNode.j
 export { default as LightingNode } from './lighting/LightingNode.js';
 export { default as LightProbeNode } from './lighting/LightProbeNode.js';
 export { default as LightsNode } from './lighting/LightsNode.js';
+// WITH_GENESYS
+export { MaterialLightsNode } from './lighting/LightsNode.js';
+// !WITH_GENESYS
 export { default as PointLightNode } from './lighting/PointLightNode.js';
 export { default as PointShadowNode } from './lighting/PointShadowNode.js';
 export { default as ProjectorLightNode } from './lighting/ProjectorLightNode.js';

package/src/nodes/lighting/LightsNode.js

@@ -418,6 +418,114 @@ class LightsNode extends Node {
 
 }
 
+// WITH_GENESYS
+/**
+ * A lights node that composes a live scene lights node with material-local
+ * lighting nodes like environment, AO and light map lighting.
+ *
+ * @augments LightsNode
+ */
+class MaterialLightsNode extends LightsNode {
+
+	static get type() {
+
+		return 'MaterialLightsNode';
+
+	}
+
+	/**
+	 * Constructs a new material lights node.
+	 *
+	 * @param {LightsNode} lightsNode - The live scene lights node.
+	 * @param {Array<LightingNode>} materialLights - Material-local lighting nodes.
+	 */
+	constructor( lightsNode, materialLights = [] ) {
+
+		super();
+
+		this.lightsNode = lightsNode;
+		this.materialLights = materialLights;
+		this.updateType = lightsNode.getUpdateType();
+		this.updateBeforeType = lightsNode.getUpdateBeforeType();
+		this.updateAfterType = lightsNode.getUpdateAfterType();
+
+	}
+
+	customCacheKey() {
+
+		const hash = [ this.lightsNode.getCacheKey( true ) ];
+
+		for ( const lightNode of this.materialLights ) {
+
+			hash.push( lightNode.getCacheKey( true ) );
+
+		}
+
+		return hashArray( hash );
+
+	}
+
+	setupLights( builder, materialLights ) {
+
+		this.lightsNode.setupLights( builder, this.lightsNode.getLightNodes( builder ) );
+
+		for ( const lightNode of materialLights ) {
+
+			lightNode.build( builder );
+
+		}
+
+	}
+
+	update( frame ) {
+
+		if ( this.lightsNode.update ) this.lightsNode.update( frame );
+
+	}
+
+	updateBefore( frame ) {
+
+		if ( this.lightsNode.updateBefore ) this.lightsNode.updateBefore( frame );
+
+	}
+
+	updateAfter( frame ) {
+
+		if ( this.lightsNode.updateAfter ) this.lightsNode.updateAfter( frame );
+
+	}
+
+	dispose() {
+
+		super.dispose();
+
+		this.lightsNode = null;
+		this.materialLights = null;
+
+	}
+
+	getLightNodes() {
+
+		return this.materialLights;
+
+	}
+
+	getLights() {
+
+		return this.lightsNode.getLights();
+
+	}
+
+	get hasLights() {
+
+		return this.lightsNode.getScope().hasLights || this.materialLights.length > 0;
+
+	}
+
+}
+export { MaterialLightsNode };
+// !WITH_GENESYS
+
 export default LightsNode;
 
 /**

package/src/renderers/common/Lighting.js

@@ -1,4 +1,9 @@
-import { LightsNode } from '../../nodes/Nodes.js';
+import {
+	LightsNode,
+	// WITH_GENESYS
+	MaterialLightsNode,
+	// !WITH_GENESYS
+} from '../../nodes/Nodes.js';
 
 const _defaultLights = /*@__PURE__*/ new LightsNode();
 const _weakMap = /*@__PURE__*/ new WeakMap();
@@ -26,6 +31,22 @@ class Lighting {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Creates a lights node that composes live scene lighting with material-local
+	 * lighting nodes such as environment, AO and light map lighting.
+	 *
+	 * @param {LightsNode} lightsNode - The live scene lights node.
+	 * @param {Array<LightingNode>} materialLights - Material-local lighting nodes.
+	 * @return {MaterialLightsNode} The material lights node.
+	 */
+	createMaterialNode( lightsNode, materialLights = [] ) {
+
+		return new MaterialLightsNode( lightsNode, materialLights );
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Returns a lights node for the given scene and camera.
 	 *

package/src/renderers/common/RenderObjects.js

@@ -72,6 +72,21 @@ class RenderObjects {
 		 */
 		this.chainMaps = {};
 
+		/**
+		 * Strongly tracks every render object created through {@link createRenderObject}
+		 * so {@link dispose} can iterate them. ChainMap is `WeakMap`-backed and not
+		 * iterable, so without this set the dispose listeners installed by
+		 * `RenderObject` on shared materials and geometries (e.g. PMREM, `QuadGeometry`)
+		 * would leak when the renderer is torn down while those singletons live on.
+		 *
+		 * Entries are removed in the same `onDispose` callback that cleans the chain
+		 * map entry, so steady-state behavior is unchanged.
+		 *
+		 * @private
+		 * @type {Set<RenderObject>}
+		 */
+		this._renderObjects = new Set();
+
 	}
 
 	/**
@@ -172,6 +187,18 @@ class RenderObjects {
 	 */
 	dispose() {
 
+		// Snapshot first: `RenderObject.dispose()` fires `onDispose` which
+		// mutates `_renderObjects` (and the chain map). Iterating the live set
+		// would skip entries.
+		const renderObjects = Array.from( this._renderObjects );
+		this._renderObjects.clear();
+
+		for ( const renderObject of renderObjects ) {
+
+			renderObject.dispose();
+
+		}
+
 		this.chainMaps = {};
 
 	}
@@ -198,6 +225,8 @@ class RenderObjects {
 
 		const renderObject = new RenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext, clippingContext );
 
+		this._renderObjects.add( renderObject );
+
 		renderObject.onDispose = () => {
 
 			this.pipelines.delete( renderObject );
@@ -206,6 +235,8 @@ class RenderObjects {
 
 			chainMap.delete( renderObject.getChainArray() );
 
+			this._renderObjects.delete( renderObject );
+
 		};
 
 		return renderObject;

package/src/renderers/common/Renderer.js

@@ -2529,6 +2529,11 @@ class Renderer {
 
 			} );
 
+			// Drop the strong reference to the active `RenderContext` so module-level
+			// `WeakMap<RenderContext, …>` caches can release entries once
+			// `_renderContexts.dispose()` has cleared its dictionary.
+			this._currentRenderContext = null;
+
 		}
 
 		this.setRenderTarget( null );

package/src/renderers/common/Textures.js

@@ -55,6 +55,28 @@ class Textures extends DataMap {
 		 */
 		this._htmlTextures = new Set();
 
+		/**
+		 * Strongly tracks every texture that has had a `'dispose'` listener
+		 * installed by {@link updateTexture}. `DataMap` is `WeakMap`-backed and
+		 * not iterable; without this set the listener (whose closure references
+		 * `Textures` → `renderer`) would leak when {@link dispose} is called
+		 * while shared textures live on.
+		 *
+		 * @private
+		 * @type {Set<Texture>}
+		 */
+		this._textures = new Set();
+
+		/**
+		 * Strongly tracks every render target that has had a `'dispose'` listener
+		 * installed by {@link updateRenderTarget}. Same rationale as
+		 * {@link _textures}.
+		 *
+		 * @private
+		 * @type {Set<RenderTarget>}
+		 */
+		this._renderTargets = new Set();
+
 	}
 
 	/**
@@ -181,6 +203,8 @@ class Textures extends DataMap {
 
 			renderTarget.addEventListener( 'dispose', renderTargetData.onDispose );
 
+			this._renderTargets.add( renderTarget );
+
 		}
 
 	}
@@ -401,6 +425,8 @@ class Textures extends DataMap {
 
 			texture.addEventListener( 'dispose', textureData.onDispose );
 
+			this._textures.add( texture );
+
 		}
 
 		//
@@ -569,6 +595,8 @@ class Textures extends DataMap {
 			this.delete( renderTarget );
 			this.backend.delete( renderTarget );
 
+			this._renderTargets.delete( renderTarget );
+
 			this.info.memory.renderTargets --;
 
 		}
@@ -618,12 +646,50 @@ class Textures extends DataMap {
 
 			this.delete( texture );
 
+			this._textures.delete( texture );
+
 			this.info.destroyTexture( texture );
 
 		}
 
 	}
 
+	/**
+	 * Frees internal resources. Destroys every tracked render target and
+	 * texture so the `'dispose'` listeners installed by {@link updateTexture}
+	 * and {@link updateRenderTarget} are removed; without this, listeners on
+	 * shared textures (PMREM, environment maps, etc.) would retain this
+	 * `Textures` instance (and its renderer) across renderer teardown.
+	 *
+	 * @override
+	 */
+	dispose() {
+
+		// Snapshot first: `_destroy*` mutates the sets.
+		const renderTargets = Array.from( this._renderTargets );
+		this._renderTargets.clear();
+
+		for ( const renderTarget of renderTargets ) {
+
+			this._destroyRenderTarget( renderTarget );
+
+		}
+
+		const textures = Array.from( this._textures );
+		this._textures.clear();
+
+		for ( const texture of textures ) {
+
+			this._destroyTexture( texture );
+
+		}
+
+		this._htmlTextures.clear();
+
+		super.dispose();
+
+	}
+
 }
 
 export default Textures;

package/index.d.ts

@@ -1 +0,0 @@
-export * from '@gnsx/three-types';