@needle-tools/three 0.162.12 → 0.169.2

package/examples/jsm/postprocessing/OutlinePass.js

@@ -35,7 +35,7 @@ class OutlinePass extends Pass {
 		this.pulsePeriod = 0;
 
 		this._visibilityCache = new Map();
-
+		this._selectionCache = new Set();
 
 		this.resolution = ( resolution !== undefined ) ? new Vector2( resolution.x, resolution.y ) : new Vector2( 256, 256 );
 
@@ -172,29 +172,18 @@ class OutlinePass extends Pass {
 
 	}
 
-	changeVisibilityOfSelectedObjects( bVisible ) {
+	updateSelectionCache() {
 
-		const cache = this._visibilityCache;
+		const cache = this._selectionCache;
 
 		function gatherSelectedMeshesCallBack( object ) {
 
-			if ( object.isMesh ) {
-
-				if ( bVisible === true ) {
-
-					object.visible = cache.get( object );
-
-				} else {
-
-					cache.set( object, object.visible );
-					object.visible = bVisible;
-
-				}
-
-			}
+			if ( object.isMesh ) cache.add( object );
 
 		}
 
+		cache.clear();
+
 		for ( let i = 0; i < this.selectedObjects.length; i ++ ) {
 
 			const selectedObject = this.selectedObjects[ i ];
@@ -204,56 +193,49 @@ class OutlinePass extends Pass {
 
 	}
 
-	changeVisibilityOfNonSelectedObjects( bVisible ) {
+	changeVisibilityOfSelectedObjects( bVisible ) {
 
 		const cache = this._visibilityCache;
-		const selectedMeshes = [];
-
-		function gatherSelectedMeshesCallBack( object ) {
-
-			if ( object.isMesh ) selectedMeshes.push( object );
 
-		}
-
-		for ( let i = 0; i < this.selectedObjects.length; i ++ ) {
+		for ( const mesh of this._selectionCache ) {
 
-			const selectedObject = this.selectedObjects[ i ];
-			selectedObject.traverse( gatherSelectedMeshesCallBack );
+			if ( bVisible === true ) {
 
-		}
+				mesh.visible = cache.get( mesh );
 
-		function VisibilityChangeCallBack( object ) {
+			} else {
 
-			if ( object.isMesh || object.isSprite ) {
+				cache.set( mesh, mesh.visible );
+				mesh.visible = bVisible;
 
-				// only meshes and sprites are supported by OutlinePass
+			}
 
-				let bFound = false;
+		}
 
-				for ( let i = 0; i < selectedMeshes.length; i ++ ) {
+	}
 
-					const selectedObjectId = selectedMeshes[ i ].id;
+	changeVisibilityOfNonSelectedObjects( bVisible ) {
 
-					if ( selectedObjectId === object.id ) {
+		const visibilityCache = this._visibilityCache;
+		const selectionCache = this._selectionCache;
 
-						bFound = true;
-						break;
+		function VisibilityChangeCallBack( object ) {
 
-					}
+			if ( object.isMesh || object.isSprite ) {
 
-				}
+				// only meshes and sprites are supported by OutlinePass
 
-				if ( bFound === false ) {
+				if ( ! selectionCache.has( object ) ) {
 
 					const visibility = object.visible;
 
-					if ( bVisible === false || cache.get( object ) === true ) {
+					if ( bVisible === false || visibilityCache.get( object ) === true ) {
 
 						object.visible = bVisible;
 
 					}
 
-					cache.set( object, visibility );
+					visibilityCache.set( object, visibility );
 
 				}
 
@@ -264,11 +246,11 @@ class OutlinePass extends Pass {
 
 				if ( bVisible === true ) {
 
-					object.visible = cache.get( object ); // restore
+					object.visible = visibilityCache.get( object ); // restore
 
 				} else {
 
-					cache.set( object, object.visible );
+					visibilityCache.set( object, object.visible );
 					object.visible = bVisible;
 
 				}
@@ -306,6 +288,8 @@ class OutlinePass extends Pass {
 
 			renderer.setClearColor( 0xffffff, 1 );
 
+			this.updateSelectionCache();
+
 			// Make selected objects invisible
 			this.changeVisibilityOfSelectedObjects( false );
 
@@ -337,6 +321,7 @@ class OutlinePass extends Pass {
 			this.renderScene.overrideMaterial = null;
 			this.changeVisibilityOfNonSelectedObjects( true );
 			this._visibilityCache.clear();
+			this._selectionCache.clear();
 
 			this.renderScene.background = currentBackground;
 
@@ -462,7 +447,7 @@ class OutlinePass extends Pass {
 						worldPosition = instanceMatrix * worldPosition;
 
 					#endif
-					
+
 					worldPosition = modelMatrix * worldPosition;
 
 					projTexCoord = textureMatrix * worldPosition;

package/examples/jsm/postprocessing/RenderPass.js

@@ -42,7 +42,7 @@ class RenderPass extends Pass {
 		if ( this.clearColor !== null ) {
 
 			renderer.getClearColor( this._oldClearColor );
-			renderer.setClearColor( this.clearColor );
+			renderer.setClearColor( this.clearColor, renderer.getClearAlpha() );
 
 		}
 

package/examples/jsm/postprocessing/RenderTransitionPass.js

@@ -0,0 +1,168 @@
+import {
+	HalfFloatType,
+	ShaderMaterial,
+	WebGLRenderTarget
+} from 'three';
+import { FullScreenQuad, Pass } from './Pass.js';
+
+class RenderTransitionPass extends Pass {
+
+	constructor( sceneA, cameraA, sceneB, cameraB ) {
+
+		super();
+
+		this.material = this.createMaterial();
+		this.fsQuad = new FullScreenQuad( this.material );
+
+		this.sceneA = sceneA;
+		this.cameraA = cameraA;
+		this.sceneB = sceneB;
+		this.cameraB = cameraB;
+
+		this.renderTargetA = new WebGLRenderTarget();
+		this.renderTargetA.texture.type = HalfFloatType;
+		this.renderTargetB = new WebGLRenderTarget();
+		this.renderTargetB.texture.type = HalfFloatType;
+
+	}
+
+	setTransition( value ) {
+
+		this.material.uniforms.mixRatio.value = value;
+
+	}
+
+	useTexture( value ) {
+
+		this.material.uniforms.useTexture.value = value ? 1 : 0;
+
+	}
+
+	setTexture( value ) {
+
+		this.material.uniforms.tMixTexture.value = value;
+
+	}
+
+	setTextureThreshold( value ) {
+
+		this.material.uniforms.threshold.value = value;
+
+	}
+
+	setSize( width, height ) {
+
+		this.renderTargetA.setSize( width, height );
+		this.renderTargetB.setSize( width, height );
+
+	}
+
+	render( renderer, writeBuffer ) {
+
+		renderer.setRenderTarget( this.renderTargetA );
+		renderer.render( this.sceneA, this.cameraA );
+		renderer.setRenderTarget( this.renderTargetB );
+		renderer.render( this.sceneB, this.cameraB );
+
+		const uniforms = this.fsQuad.material.uniforms;
+		uniforms.tDiffuse1.value = this.renderTargetA.texture;
+		uniforms.tDiffuse2.value = this.renderTargetB.texture;
+
+		if ( this.renderToScreen ) {
+
+			renderer.setRenderTarget( null );
+			renderer.clear();
+
+		} else {
+
+			renderer.setRenderTarget( writeBuffer );
+			if ( this.clear ) renderer.clear();
+
+		}
+
+		this.fsQuad.render( renderer );
+
+	}
+
+	dispose() {
+
+		this.renderTargetA.dispose();
+		this.renderTargetB.dispose();
+		this.material.dispose();
+		this.fsQuad.dispose();
+
+	}
+
+	createMaterial() {
+
+		return new ShaderMaterial( {
+			uniforms: {
+				tDiffuse1: {
+					value: null
+				},
+				tDiffuse2: {
+					value: null
+				},
+				mixRatio: {
+					value: 0.0
+				},
+				threshold: {
+					value: 0.1
+				},
+				useTexture: {
+					value: 1
+				},
+				tMixTexture: {
+					value: null
+				}
+			},
+			vertexShader: /* glsl */`
+				varying vec2 vUv;
+
+				void main() {
+
+					vUv = vec2( uv.x, uv.y );
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+			`,
+			fragmentShader: /* glsl */`
+				uniform float mixRatio;
+
+				uniform sampler2D tDiffuse1;
+				uniform sampler2D tDiffuse2;
+				uniform sampler2D tMixTexture;
+
+				uniform int useTexture;
+				uniform float threshold;
+
+				varying vec2 vUv;
+
+				void main() {
+
+					vec4 texel1 = texture2D( tDiffuse1, vUv );
+					vec4 texel2 = texture2D( tDiffuse2, vUv );
+
+					if (useTexture == 1) {
+
+						vec4 transitionTexel = texture2D( tMixTexture, vUv );
+						float r = mixRatio * ( 1.0 + threshold * 2.0 ) - threshold;
+						float mixf = clamp( ( transitionTexel.r - r ) * ( 1.0 / threshold ), 0.0, 1.0 );
+
+						gl_FragColor = mix( texel1, texel2, mixf );
+
+					} else {
+
+						gl_FragColor = mix( texel2, texel1, mixRatio );
+
+					}
+
+				}
+			`
+		} );
+
+	}
+
+}
+
+export { RenderTransitionPass };

package/examples/jsm/postprocessing/SAOPass.js

@@ -81,7 +81,6 @@ class SAOPass extends Pass {
 			vertexShader: SAOShader.vertexShader,
 			uniforms: UniformsUtils.clone( SAOShader.uniforms )
 		} );
-		this.saoMaterial.extensions.derivatives = true;
 		this.saoMaterial.defines[ 'PERSPECTIVE_CAMERA' ] = this.camera.isPerspectiveCamera ? 1 : 0;
 		this.saoMaterial.uniforms[ 'tDepth' ].value = depthTexture;
 		this.saoMaterial.uniforms[ 'tNormal' ].value = this.normalRenderTarget.texture;

package/examples/jsm/postprocessing/SSAARenderPass.js

@@ -31,6 +31,8 @@ class SSAARenderPass extends Pass {
 		this.sampleLevel = 4; // specified as n, where the number of samples is 2^n, so sampleLevel = 4, is 2^4 samples, 16.
 		this.unbiased = true;
 
+		this.stencilBuffer = false;
+
 		// as we need to clear the buffer in this pass, clearColor must be set to something, defaults to black.
 		this.clearColor = ( clearColor !== undefined ) ? clearColor : 0x000000;
 		this.clearAlpha = ( clearAlpha !== undefined ) ? clearAlpha : 0;
@@ -79,7 +81,7 @@ class SSAARenderPass extends Pass {
 
 		if ( ! this.sampleRenderTarget ) {
 
-			this.sampleRenderTarget = new WebGLRenderTarget( readBuffer.width, readBuffer.height, { type: HalfFloatType } );
+			this.sampleRenderTarget = new WebGLRenderTarget( readBuffer.width, readBuffer.height, { type: HalfFloatType, stencilBuffer: this.stencilBuffer } );
 			this.sampleRenderTarget.texture.name = 'SSAARenderPass.sample';
 
 		}

package/examples/jsm/postprocessing/SSAOPass.js

@@ -13,7 +13,6 @@ import {
 	NearestFilter,
 	NoBlending,
 	RedFormat,
-	LuminanceFormat,
 	DepthStencilFormat,
 	UnsignedInt248Type,
 	RepeatWrapping,
@@ -40,6 +39,7 @@ class SSAOPass extends Pass {
 		this.height = ( height !== undefined ) ? height : 512;
 
 		this.clear = true;
+		this.needsSwap = false;
 
 		this.camera = camera;
 		this.scene = scene;
@@ -177,8 +177,6 @@ class SSAOPass extends Pass {
 
 	render( renderer, writeBuffer, readBuffer /*, deltaTime, maskActive */ ) {
 
-		if ( renderer.capabilities.isWebGL2 === false ) this.noiseTexture.format = LuminanceFormat;
-
 		// render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
 
 		this.overrideVisibility();
@@ -204,7 +202,7 @@ class SSAOPass extends Pass {
 
 				this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.ssaoRenderTarget.texture;
 				this.copyMaterial.blending = NoBlending;
-				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer );
+				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : readBuffer );
 
 				break;
 
@@ -212,13 +210,13 @@ class SSAOPass extends Pass {
 
 				this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.blurRenderTarget.texture;
 				this.copyMaterial.blending = NoBlending;
-				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer );
+				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : readBuffer );
 
 				break;
 
 			case SSAOPass.OUTPUT.Depth:
 
-				this.renderPass( renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer );
+				this.renderPass( renderer, this.depthRenderMaterial, this.renderToScreen ? null : readBuffer );
 
 				break;
 
@@ -226,19 +224,15 @@ class SSAOPass extends Pass {
 
 				this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.normalRenderTarget.texture;
 				this.copyMaterial.blending = NoBlending;
-				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer );
+				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : readBuffer );
 
 				break;
 
 			case SSAOPass.OUTPUT.Default:
 
-				this.copyMaterial.uniforms[ 'tDiffuse' ].value = readBuffer.texture;
-				this.copyMaterial.blending = NoBlending;
-				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer );
-
 				this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.blurRenderTarget.texture;
 				this.copyMaterial.blending = CustomBlending;
-				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer );
+				this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : readBuffer );
 
 				break;
 

package/examples/jsm/postprocessing/UnrealBloomPass.js

@@ -49,12 +49,12 @@ class UnrealBloomPass extends Pass {
 
 		for ( let i = 0; i < this.nMips; i ++ ) {
 
-			const renderTargetHorizonal = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
+			const renderTargetHorizontal = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
 
-			renderTargetHorizonal.texture.name = 'UnrealBloomPass.h' + i;
-			renderTargetHorizonal.texture.generateMipmaps = false;
+			renderTargetHorizontal.texture.name = 'UnrealBloomPass.h' + i;
+			renderTargetHorizontal.texture.generateMipmaps = false;
 
-			this.renderTargetsHorizontal.push( renderTargetHorizonal );
+			this.renderTargetsHorizontal.push( renderTargetHorizontal );
 
 			const renderTargetVertical = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
 

package/examples/jsm/renderers/CSS2DRenderer.js

@@ -114,22 +114,42 @@ class CSS2DRenderer {
 
 		};
 
+		function hideObject( object ) {
+
+			if ( object.isCSS2DObject ) object.element.style.display = 'none';
+
+			for ( let i = 0, l = object.children.length; i < l; i ++ ) {
+
+				hideObject( object.children[ i ] );
+
+			}
+
+		}
+
 		function renderObject( object, scene, camera ) {
 
+			if ( object.visible === false ) {
+
+				hideObject( object );
+
+				return;
+
+			}
+			
 			if ( object.isCSS2DObject ) {
 
 				_vector.setFromMatrixPosition( object.matrixWorld );
 				_vector.applyMatrix4( _viewProjectionMatrix );
 
-				const visible = ( object.visible === true ) && ( _vector.z >= - 1 && _vector.z <= 1 ) && ( object.layers.test( camera.layers ) === true );
-				object.element.style.display = ( visible === true ) ? '' : 'none';
+				const visible = ( _vector.z >= - 1 && _vector.z <= 1 ) && ( object.layers.test( camera.layers ) === true );
+
+				const element = object.element;
+				element.style.display = visible === true ? '' : 'none';
 
 				if ( visible === true ) {
 
 					object.onBeforeRender( _this, scene, camera );
 
-					const element = object.element;
-
 					element.style.transform = 'translate(' + ( - 100 * object.center.x ) + '%,' + ( - 100 * object.center.y ) + '%)' + 'translate(' + ( _vector.x * _widthHalf + _widthHalf ) + 'px,' + ( - _vector.y * _heightHalf + _heightHalf ) + 'px)';
 
 					if ( element.parentNode !== domElement ) {
@@ -171,7 +191,7 @@ class CSS2DRenderer {
 
 			const result = [];
 
-			scene.traverse( function ( object ) {
+			scene.traverseVisible( function ( object ) {
 
 				if ( object.isCSS2DObject ) result.push( object );
 

package/examples/jsm/renderers/CSS3DRenderer.js

@@ -251,12 +251,34 @@ class CSS3DRenderer {
 
 		}
 
+		function hideObject( object ) {
+
+			if ( object.isCSS3DObject ) object.element.style.display = 'none';
+	  
+			for ( let i = 0, l = object.children.length; i < l; i ++ ) {
+
+			  hideObject( object.children[ i ] );
+
+			}
+
+		}
+
 		function renderObject( object, scene, camera, cameraCSSMatrix ) {
 
+			if ( object.visible === false ) {
+
+				hideObject( object );
+
+				return;
+
+			}
+
 			if ( object.isCSS3DObject ) {
 
-				const visible = ( object.visible === true ) && ( object.layers.test( camera.layers ) === true );
-				object.element.style.display = ( visible === true ) ? '' : 'none';
+				const visible = ( object.layers.test( camera.layers ) === true );
+
+				const element = object.element;
+				element.style.display = visible === true ? '' : 'none';
 
 				if ( visible === true ) {
 
@@ -290,7 +312,6 @@ class CSS3DRenderer {
 
 					}
 
-					const element = object.element;
 					const cachedObject = cache.objects.get( object );
 
 					if ( cachedObject === undefined || cachedObject.style !== style ) {

package/examples/jsm/renderers/webgl-legacy/nodes/GLSL1NodeBuilder.js

@@ -1,4 +1,4 @@
-import { MathNode, GLSLNodeParser, NodeBuilder } from '../../../nodes/Nodes.js';
+import { MathNode, GLSLNodeParser, NodeBuilder } from 'three';
 
 const glslMethods = {
 	[ MathNode.ATAN2 ]: 'atan'
@@ -40,8 +40,6 @@ class GLSL1NodeBuilder extends NodeBuilder {
 
 	getTextureBias( texture, textureProperty, uvSnippet, biasSnippet ) {
 
-		if ( this.material.extensions !== undefined ) this.material.extensions.shaderTextureLOD = true;
-
 		return `textureLod( ${textureProperty}, ${uvSnippet}, ${biasSnippet} )`;
 
 	}

package/examples/jsm/renderers/webgl-legacy/nodes/SlotNode.js

@@ -1,4 +1,4 @@
-import { Node } from '../../../nodes/Nodes.js';
+import { Node } from 'three';
 
 class SlotNode extends Node {
 

package/examples/jsm/renderers/webgl-legacy/nodes/WebGLNodeBuilder.js

@@ -1,9 +1,10 @@
-import { defaultShaderStages, NodeFrame, MathNode, GLSLNodeParser, NodeBuilder, normalView } from '../../../nodes/Nodes.js';
+import { defaultShaderStages, NodeFrame, GLSLNodeParser, NodeBuilder, normalView } from 'three';
 import SlotNode from './SlotNode.js';
 import { PerspectiveCamera, ShaderChunk, ShaderLib, UniformsUtils, UniformsLib } from 'three';
 
 const nodeFrame = new NodeFrame();
 nodeFrame.camera = new PerspectiveCamera();
+export { nodeFrame };
 
 const nodeShaderLib = {
 	LineBasicNodeMaterial: ShaderLib.basic,
@@ -15,7 +16,7 @@ const nodeShaderLib = {
 };
 
 const glslMethods = {
-	[ MathNode.ATAN2 ]: 'atan'
+	[ 'atan2' ]: 'atan'
 };
 
 const precisionLib = {
@@ -51,6 +52,8 @@ class WebGLNodeBuilder extends NodeBuilder {
 
 		this._sortSlotsToFlow();
 
+		this.useComparisonMethod = true;
+
 	}
 
 	getMethod( method ) {
@@ -433,8 +436,6 @@ class WebGLNodeBuilder extends NodeBuilder {
 
 	generateTextureLevel( texture, textureProperty, uvSnippet, biasSnippet ) {
 
-		if ( this.material.extensions !== undefined ) this.material.extensions.shaderTextureLOD = true;
-
 		return `textureLod( ${textureProperty}, ${uvSnippet}, ${biasSnippet} )`;
 
 	}
@@ -780,6 +781,8 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 
 		nodeFrame.object = this.object;
 		nodeFrame.renderer = this.renderer;
+		nodeFrame.material = this.material;
+		nodeFrame.scene = this.scene;
 
 		for ( const node of this.updateNodes ) {
 

package/examples/jsm/renderers/webgl-legacy/nodes/WebGLNodes.js

@@ -1,10 +1,7 @@
-import { WebGLNodeBuilder } from './WebGLNodeBuilder.js';
-import { NodeFrame } from '../../../nodes/Nodes.js';
-
+import { nodeFrame, WebGLNodeBuilder } from './WebGLNodeBuilder.js';
 import { Material } from 'three';
 
 const builders = new WeakMap();
-export const nodeFrame = new NodeFrame();
 
 Material.prototype.onBuild = function ( object, parameters, renderer ) {
 
@@ -12,7 +9,19 @@ Material.prototype.onBuild = function ( object, parameters, renderer ) {
 
 	if ( material.isNodeMaterial === true ) {
 
-		builders.set( material, new WebGLNodeBuilder( object, renderer, parameters, material ).build() );
+		let newBuilder;
+		try {
+
+			newBuilder = new WebGLNodeBuilder( object, renderer, parameters, material ).build();
+			builders.set( material, newBuilder );
+
+		} catch ( e ) {
+
+			console.error( 'Material.prototype.onBuild: ', e );
+
+		}
+
+		// console.log( 'Material.prototype.onBuild: new builder', this, newBuilder );
 
 	}
 
@@ -22,12 +31,17 @@ Material.prototype.onBeforeRender = function ( renderer, scene, camera, geometry
 
 	const nodeBuilder = builders.get( this );
 
+	// if ( this.isNodeMaterial )
+	//	console.log( 'Material.prototype.onBeforeRender', this, nodeBuilder );
+
 	if ( nodeBuilder !== undefined ) {
 
 		nodeFrame.material = this;
 		nodeFrame.camera = camera;
 		nodeFrame.object = object;
 		nodeFrame.renderer = renderer;
+		nodeFrame.scene = scene;
+		nodeFrame.geometry = geometry;
 
 		const updateNodes = nodeBuilder.updateNodes;
 

package/examples/jsm/shaders/BleachBypassShader.js

@@ -38,8 +38,7 @@ const BleachBypassShader = {
 
 			vec4 base = texture2D( tDiffuse, vUv );
 
-			vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );
-			float lum = dot( lumCoeff, base.rgb );
+			float lum = luminance( base.rgb );
 			vec3 blend = vec3( lum );
 
 			float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );