super-three 0.167.0 → 0.168.0

package/src/renderers/common/nodes/NodeLibrary.js

@@ -0,0 +1,118 @@
+class NodeLibrary {
+
+	constructor() {
+
+		this.lightNodes = new WeakMap();
+		this.materialNodes = new Map();
+		this.toneMappingNodes = new Map();
+		this.colorSpaceNodes = new Map();
+
+	}
+
+	fromMaterial( material ) {
+
+		if ( material.isNodeMaterial ) return material;
+
+		let nodeMaterial = null;
+
+		const nodeMaterialClass = this.getMaterialNodeClass( material.type );
+
+		if ( nodeMaterialClass !== null ) {
+
+			nodeMaterial = new nodeMaterialClass();
+
+			for ( const key in material ) {
+
+				nodeMaterial[ key ] = material[ key ];
+
+			}
+
+		}
+
+		return nodeMaterial;
+
+	}
+
+	addColorSpace( colorSpaceNode, colorSpace ) {
+
+		this.addType( colorSpaceNode, colorSpace, this.colorSpaceNodes );
+
+	}
+
+	getColorSpaceFunction( colorSpace ) {
+
+		return this.colorSpaceNodes.get( colorSpace ) || null;
+
+	}
+
+	addToneMapping( toneMappingNode, toneMapping ) {
+
+		this.addType( toneMappingNode, toneMapping, this.toneMappingNodes );
+
+	}
+
+	getToneMappingFunction( toneMapping ) {
+
+		return this.toneMappingNodes.get( toneMapping ) || null;
+
+	}
+
+	getMaterialNodeClass( materialType ) {
+
+		return this.materialNodes.get( materialType ) || null;
+
+	}
+
+	addMaterial( materialNodeClass, materialClass ) {
+
+		this.addType( materialNodeClass, materialClass.name, this.materialNodes );
+
+	}
+
+	getLightNodeClass( light ) {
+
+		return this.lightNodes.get( light ) || null;
+
+	}
+
+	addLight( lightNodeClass, lightClass ) {
+
+		this.addClass( lightNodeClass, lightClass, this.lightNodes );
+
+	}
+
+	addType( nodeClass, type, library ) {
+
+		if ( library.has( type ) ) {
+
+			console.warn( `Redefinition of node ${ type }` );
+			return;
+
+		}
+
+		if ( typeof nodeClass !== 'function' ) throw new Error( `Node class ${ nodeClass.name } is not a class.` );
+		if ( typeof type === 'function' || typeof type === 'object' ) throw new Error( `Base class ${ type } is not a class.` );
+
+		library.set( type, nodeClass );
+
+	}
+
+	addClass( nodeClass, baseClass, library ) {
+
+		if ( library.has( baseClass ) ) {
+
+			console.warn( `Redefinition of node ${ baseClass.name }` );
+			return;
+
+		}
+
+		if ( typeof nodeClass !== 'function' ) throw new Error( `Node class ${ nodeClass.name } is not a class.` );
+		if ( typeof baseClass !== 'function' ) throw new Error( `Base class ${ baseClass.name } is not a class.` );
+
+		library.set( baseClass, nodeClass );
+
+	}
+
+}
+
+export default NodeLibrary;

package/src/renderers/common/nodes/NodeSampledTexture.js

@@ -13,9 +13,9 @@ class NodeSampledTexture extends SampledTexture {
 
 	}
 
-	get needsBindingsUpdate() {
+	needsBindingsUpdate( generation ) {
 
-		return this.textureNode.value !== this.texture || super.needsBindingsUpdate;
+		return this.textureNode.value !== this.texture || super.needsBindingsUpdate( generation );
 
 	}
 

package/src/renderers/common/nodes/Nodes.js

@@ -1,7 +1,9 @@
 import DataMap from '../DataMap.js';
 import ChainMap from '../ChainMap.js';
 import NodeBuilderState from './NodeBuilderState.js';
-import { NodeFrame, objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, viewportBottomLeft, normalWorld, pmremTexture, viewportTopLeft } from '../../../nodes/Nodes.js';
+import { cubeMapNode } from '../../../nodes/utils/CubeMapNode.js';
+import { NodeFrame } from '../../../nodes/Nodes.js';
+import { objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, normalWorld, pmremTexture, viewportUV } from '../../../nodes/TSL.js';
 
 import { EquirectangularReflectionMapping, EquirectangularRefractionMapping } from '../../../constants.js';
 
@@ -264,17 +266,39 @@ class Nodes extends DataMap {
 
 		if ( background ) {
 
-			if ( sceneData.background !== background ) {
+			const forceUpdate = ( scene.backgroundBlurriness === 0 && sceneData.backgroundBlurriness > 0 ) || ( scene.backgroundBlurriness > 0 && sceneData.backgroundBlurriness === 0 );
+
+			if ( sceneData.background !== background || forceUpdate ) {
 
 				let backgroundNode = null;
 
 				if ( background.isCubeTexture === true || ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping ) ) {
 
-					backgroundNode = pmremTexture( background, normalWorld );
+					if ( scene.backgroundBlurriness > 0 ) {
+
+						backgroundNode = pmremTexture( background, normalWorld );
+
+					} else {
+
+						let envMap;
+
+						if ( background.isCubeTexture === true ) {
+
+							envMap = cubeTexture( background );
+
+						} else {
+
+							envMap = texture( background );
+
+						}
+
+						backgroundNode = cubeMapNode( envMap );
+
+					}
 
 				} else if ( background.isTexture === true ) {
 
-					backgroundNode = texture( background, viewportBottomLeft ).setUpdateMatrix( true );
+					backgroundNode = texture( background, viewportUV.flipY() ).setUpdateMatrix( true );
 
 				} else if ( background.isColor !== true ) {
 
@@ -284,6 +308,7 @@ class Nodes extends DataMap {
 
 				sceneData.backgroundNode = backgroundNode;
 				sceneData.background = background;
+				sceneData.backgroundBlurriness = scene.backgroundBlurriness;
 
 			}
 
@@ -414,7 +439,7 @@ class Nodes extends DataMap {
 		const renderer = this.renderer;
 		const cacheKey = this.getOutputCacheKey();
 
-		const output = texture( outputTexture, viewportTopLeft ).renderOutput( renderer.toneMapping, renderer.currentColorSpace );
+		const output = texture( outputTexture, viewportUV ).renderOutput( renderer.toneMapping, renderer.currentColorSpace );
 
 		outputNodeMap.set( outputTexture, cacheKey );
 
@@ -424,12 +449,13 @@ class Nodes extends DataMap {
 
 	updateBefore( renderObject ) {
 
-		const nodeFrame = this.getNodeFrameForRender( renderObject );
 		const nodeBuilder = renderObject.getNodeBuilderState();
 
 		for ( const node of nodeBuilder.updateBeforeNodes ) {
 
-			nodeFrame.updateBeforeNode( node );
+			// update frame state for each node
+
+			this.getNodeFrameForRender( renderObject ).updateBeforeNode( node );
 
 		}
 
@@ -437,12 +463,13 @@ class Nodes extends DataMap {
 
 	updateAfter( renderObject ) {
 
-		const nodeFrame = this.getNodeFrameForRender( renderObject );
 		const nodeBuilder = renderObject.getNodeBuilderState();
 
 		for ( const node of nodeBuilder.updateAfterNodes ) {
 
-			nodeFrame.updateAfterNode( node );
+			// update frame state for each node
+
+			this.getNodeFrameForRender( renderObject ).updateAfterNode( node );
 
 		}
 

package/src/renderers/common/nodes/StandardNodeLibrary.js

@@ -0,0 +1,105 @@
+import NodeLibrary from './NodeLibrary.js';
+
+// Materials
+import { MeshPhongMaterial } from '../../../materials/MeshPhongMaterial.js';
+import MeshPhongNodeMaterial from '../../../materials/nodes/MeshPhongNodeMaterial.js';
+import { MeshStandardMaterial } from '../../../materials/MeshStandardMaterial.js';
+import MeshStandardNodeMaterial from '../../../materials/nodes/MeshStandardNodeMaterial.js';
+import { MeshPhysicalMaterial } from '../../../materials/MeshPhysicalMaterial.js';
+import MeshPhysicalNodeMaterial from '../../../materials/nodes/MeshPhysicalNodeMaterial.js';
+import { MeshToonMaterial } from '../../../materials/MeshToonMaterial.js';
+import MeshToonNodeMaterial from '../../../materials/nodes/MeshToonNodeMaterial.js';
+import { MeshBasicMaterial } from '../../../materials/MeshBasicMaterial.js';
+import MeshBasicNodeMaterial from '../../../materials/nodes/MeshBasicNodeMaterial.js';
+import { MeshLambertMaterial } from '../../../materials/MeshLambertMaterial.js';
+import MeshLambertNodeMaterial from '../../../materials/nodes/MeshLambertNodeMaterial.js';
+import { MeshNormalMaterial } from '../../../materials/MeshNormalMaterial.js';
+import MeshNormalNodeMaterial from '../../../materials/nodes/MeshNormalNodeMaterial.js';
+import { MeshMatcapMaterial } from '../../../materials/MeshMatcapMaterial.js';
+import MeshMatcapNodeMaterial from '../../../materials/nodes/MeshMatcapNodeMaterial.js';
+import { LineBasicMaterial } from '../../../materials/LineBasicMaterial.js';
+import LineBasicNodeMaterial from '../../../materials/nodes/LineBasicNodeMaterial.js';
+import { LineDashedMaterial } from '../../../materials/LineDashedMaterial.js';
+import LineDashedNodeMaterial from '../../../materials/nodes/LineDashedNodeMaterial.js';
+import { PointsMaterial } from '../../../materials/PointsMaterial.js';
+import PointsNodeMaterial from '../../../materials/nodes/PointsNodeMaterial.js';
+import { SpriteMaterial } from '../../../materials/SpriteMaterial.js';
+import SpriteNodeMaterial from '../../../materials/nodes/SpriteNodeMaterial.js';
+import { ShadowMaterial } from '../../../materials/ShadowMaterial.js';
+import ShadowNodeMaterial from '../../../materials/nodes/ShadowNodeMaterial.js';
+//import { MeshDepthMaterial } from '../../../materials/MeshDepthMaterial.js';
+//import MeshDepthNodeMaterial from '../../../materials/nodes/MeshDepthNodeMaterial.js';
+//import { MeshDistanceMaterial } from '../../../materials/MeshDistanceMaterial.js';
+//import MeshDistanceNodeMaterial from '../../../materials/nodes/MeshDistanceNodeMaterial.js';
+
+// Lights
+import { PointLight } from '../../../lights/PointLight.js';
+import { PointLightNode } from '../../../nodes/Nodes.js';
+import { DirectionalLight } from '../../../lights/DirectionalLight.js';
+import { DirectionalLightNode } from '../../../nodes/Nodes.js';
+import { RectAreaLight } from '../../../lights/RectAreaLight.js';
+import { RectAreaLightNode } from '../../../nodes/Nodes.js';
+import { SpotLight } from '../../../lights/SpotLight.js';
+import { SpotLightNode } from '../../../nodes/Nodes.js';
+import { AmbientLight } from '../../../lights/AmbientLight.js';
+import { AmbientLightNode } from '../../../nodes/Nodes.js';
+import { HemisphereLight } from '../../../lights/HemisphereLight.js';
+import { HemisphereLightNode } from '../../../nodes/Nodes.js';
+import { LightProbe } from '../../../lights/LightProbe.js';
+import { LightProbeNode } from '../../../nodes/Nodes.js';
+import IESSpotLight from '../../../lights/webgpu/IESSpotLight.js';
+import { IESSpotLightNode } from '../../../nodes/Nodes.js';
+
+// Tone Mapping
+import { LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping } from '../../../constants.js';
+import * as TMF from '../../../nodes/display/ToneMappingFunctions.js';
+
+// Color Space
+import { LinearSRGBColorSpace, SRGBColorSpace } from '../../../constants.js';
+import { getColorSpaceMethod } from '../../../nodes/display/ColorSpaceNode.js';
+import * as CSF from '../../../nodes/display/ColorSpaceFunctions.js';
+
+class StandardNodeLibrary extends NodeLibrary {
+
+	constructor() {
+
+		super();
+
+		this.addMaterial( MeshPhongNodeMaterial, MeshPhongMaterial );
+		this.addMaterial( MeshStandardNodeMaterial, MeshStandardMaterial );
+		this.addMaterial( MeshPhysicalNodeMaterial, MeshPhysicalMaterial );
+		this.addMaterial( MeshToonNodeMaterial, MeshToonMaterial );
+		this.addMaterial( MeshBasicNodeMaterial, MeshBasicMaterial );
+		this.addMaterial( MeshLambertNodeMaterial, MeshLambertMaterial );
+		this.addMaterial( MeshNormalNodeMaterial, MeshNormalMaterial );
+		this.addMaterial( MeshMatcapNodeMaterial, MeshMatcapMaterial );
+		this.addMaterial( LineBasicNodeMaterial, LineBasicMaterial );
+		this.addMaterial( LineDashedNodeMaterial, LineDashedMaterial );
+		this.addMaterial( PointsNodeMaterial, PointsMaterial );
+		this.addMaterial( SpriteNodeMaterial, SpriteMaterial );
+		this.addMaterial( ShadowNodeMaterial, ShadowMaterial );
+
+		this.addLight( PointLightNode, PointLight );
+		this.addLight( DirectionalLightNode, DirectionalLight );
+		this.addLight( RectAreaLightNode, RectAreaLight );
+		this.addLight( SpotLightNode, SpotLight );
+		this.addLight( AmbientLightNode, AmbientLight );
+		this.addLight( HemisphereLightNode, HemisphereLight );
+		this.addLight( LightProbeNode, LightProbe );
+		this.addLight( IESSpotLightNode, IESSpotLight );
+
+		this.addToneMapping( TMF.LinearToneMapping, LinearToneMapping );
+		this.addToneMapping( TMF.ReinhardToneMapping, ReinhardToneMapping );
+		this.addToneMapping( TMF.CineonToneMapping, CineonToneMapping );
+		this.addToneMapping( TMF.ACESFilmicToneMapping, ACESFilmicToneMapping );
+		this.addToneMapping( TMF.AgXToneMapping, AgXToneMapping );
+		this.addToneMapping( TMF.NeutralToneMapping, NeutralToneMapping );
+
+		this.addColorSpace( CSF.LinearTosRGB, getColorSpaceMethod( LinearSRGBColorSpace, SRGBColorSpace ) );
+		this.addColorSpace( CSF.sRGBToLinear, getColorSpaceMethod( SRGBColorSpace, LinearSRGBColorSpace ) );
+
+	}
+
+}
+
+export default StandardNodeLibrary;

package/src/renderers/shaders/ShaderChunk/tonemapping_pars_fragment.glsl.js

@@ -22,9 +22,9 @@ vec3 ReinhardToneMapping( vec3 color ) {
 }
 
 // source: http://filmicworlds.com/blog/filmic-tonemapping-operators/
-vec3 OptimizedCineonToneMapping( vec3 color ) {
+vec3 CineonToneMapping( vec3 color ) {
 
-	// optimized filmic operator by Jim Hejl and Richard Burgess-Dawson
+	// filmic operator by Jim Hejl and Richard Burgess-Dawson
 	color *= toneMappingExposure;
 	color = max( vec3( 0.0 ), color - 0.004 );
 	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );

package/src/renderers/webgl/WebGLProgram.js

@@ -114,7 +114,7 @@ function getToneMappingFunction( functionName, toneMapping ) {
 			break;
 
 		case CineonToneMapping:
-			toneMappingName = 'OptimizedCineon';
+			toneMappingName = 'Cineon';
 			break;
 
 		case ACESFilmicToneMapping:

package/src/renderers/webgl/WebGLProperties.js

@@ -2,6 +2,12 @@ function WebGLProperties() {
 
 	let properties = new WeakMap();
 
+	function has( object ) {
+
+		return properties.has( object );
+
+	}
+
 	function get( object ) {
 
 		let map = properties.get( object );
@@ -36,6 +42,7 @@ function WebGLProperties() {
 	}
 
 	return {
+		has: has,
 		get: get,
 		remove: remove,
 		update: update,

package/src/renderers/webgl/WebGLTextures.js

@@ -1722,6 +1722,37 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 		const renderTargetProperties = properties.get( renderTarget );
 		const isCube = ( renderTarget.isWebGLCubeRenderTarget === true );
 
+		// if the bound depth texture has changed
+		if ( renderTargetProperties.__boundDepthTexture !== renderTarget.depthTexture ) {
+
+			// fire the dispose event to get rid of stored state associated with the previously bound depth buffer
+			const depthTexture = renderTarget.depthTexture;
+			if ( renderTargetProperties.__depthDisposeCallback ) {
+
+				renderTargetProperties.__depthDisposeCallback();
+
+			}
+
+			// set up dispose listeners to track when the currently attached buffer is implicitly unbound
+			if ( depthTexture ) {
+
+				const disposeEvent = () => {
+
+					delete renderTargetProperties.__boundDepthTexture;
+					delete renderTargetProperties.__depthDisposeCallback;
+					depthTexture.removeEventListener( 'dispose', disposeEvent );
+
+				};
+
+				depthTexture.addEventListener( 'dispose', disposeEvent );
+				renderTargetProperties.__depthDisposeCallback = disposeEvent;
+
+			}
+
+			renderTargetProperties.__boundDepthTexture = depthTexture;
+
+		}
+
 		if ( renderTarget.depthTexture && ! renderTargetProperties.__autoAllocateDepthBuffer ) {
 
 			if ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' );
@@ -1737,16 +1768,42 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 				for ( let i = 0; i < 6; i ++ ) {
 
 					state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );
-					renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();
-					setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget, false );
+
+					if ( renderTargetProperties.__webglDepthbuffer[ i ] === undefined ) {
+
+						renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();
+						setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget, false );
+
+					} else {
+
+						// attach buffer if it's been created already
+						const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
+						const renderbuffer = renderTargetProperties.__webglDepthbuffer[ i ];
+						_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );
+						_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer );
+
+					}
 
 				}
 
 			} else {
 
 				state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
-				renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
-				setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget, false );
+
+				if ( renderTargetProperties.__webglDepthbuffer === undefined ) {
+
+					renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
+					setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget, false );
+
+				} else {
+
+					// attach buffer if it's been created already
+					const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
+					const renderbuffer = renderTargetProperties.__webglDepthbuffer;
+					_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );
+					_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer );
+
+				}
 
 			}