super-three 0.167.0 → 0.169.0

package/src/audio/Audio.js

@@ -158,7 +158,7 @@ class Audio extends Object3D {
 
 	}
 
-	stop() {
+	stop( delay = 0 ) {
 
 		if ( this.hasPlaybackControl === false ) {
 
@@ -171,7 +171,7 @@ class Audio extends Object3D {
 
 		if ( this.source !== null ) {
 
-			this.source.stop();
+			this.source.stop( this.context.currentTime + delay );
 			this.source.onended = null;
 
 		}

package/src/constants.js

@@ -1,4 +1,4 @@
-export const REVISION = '167';
+export const REVISION = '169';
 
 export const MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
 export const TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };

package/src/core/BufferAttribute.js

@@ -3,7 +3,6 @@ import { Vector2 } from '../math/Vector2.js';
 import { denormalize, normalize } from '../math/MathUtils.js';
 import { StaticDrawUsage, FloatType } from '../constants.js';
 import { fromHalfFloat, toHalfFloat } from '../extras/DataUtils.js';
-import { warnOnce } from '../utils.js';
 
 const _vector = /*@__PURE__*/ new Vector3();
 const _vector2 = /*@__PURE__*/ new Vector2();
@@ -28,7 +27,6 @@ class BufferAttribute {
 		this.normalized = normalized;
 
 		this.usage = StaticDrawUsage;
-		this._updateRange = { offset: 0, count: - 1 };
 		this.updateRanges = [];
 		this.gpuType = FloatType;
 
@@ -44,13 +42,6 @@ class BufferAttribute {
 
 	}
 
-	get updateRange() {
-
-		warnOnce( 'THREE.BufferAttribute: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159
-		return this._updateRange;
-
-	}
-
 	setUsage( value ) {
 
 		this.usage = value;

package/src/core/Clock.js

@@ -67,7 +67,7 @@ class Clock {
 
 function now() {
 
-	return ( typeof performance === 'undefined' ? Date : performance ).now(); // see #10732
+	return performance.now();
 
 }
 

package/src/core/InterleavedBuffer.js

@@ -1,6 +1,5 @@
 import * as MathUtils from '../math/MathUtils.js';
 import { StaticDrawUsage } from '../constants.js';
-import { warnOnce } from '../utils.js';
 
 class InterleavedBuffer {
 
@@ -13,7 +12,6 @@ class InterleavedBuffer {
 		this.count = array !== undefined ? array.length / stride : 0;
 
 		this.usage = StaticDrawUsage;
-		this._updateRange = { offset: 0, count: - 1 };
 		this.updateRanges = [];
 
 		this.version = 0;
@@ -30,13 +28,6 @@ class InterleavedBuffer {
 
 	}
 
-	get updateRange() {
-
-		warnOnce( 'THREE.InterleavedBuffer: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159
-		return this._updateRange;
-
-	}
-
 	setUsage( value ) {
 
 		this.usage = value;

package/src/extras/Controls.js

@@ -0,0 +1,32 @@
+import { EventDispatcher } from '../core/EventDispatcher.js';
+
+class Controls extends EventDispatcher {
+
+	constructor( object, domElement = null ) {
+
+		super();
+
+		this.object = object;
+		this.domElement = domElement;
+
+		this.enabled = true;
+
+		this.state = - 1;
+
+		this.keys = {};
+		this.mouseButtons = { LEFT: null, MIDDLE: null, RIGHT: null };
+		this.touches = { ONE: null, TWO: null };
+
+	}
+
+	connect() {}
+
+	disconnect() {}
+
+	dispose() {}
+
+	update( /* delta */ ) {}
+
+}
+
+export { Controls };

package/src/geometries/CylinderGeometry.js

@@ -133,12 +133,19 @@ class CylinderGeometry extends BufferGeometry {
 
 					// faces
 
-					indices.push( a, b, d );
-					indices.push( b, c, d );
+					if ( radiusTop > 0 ) {
 
-					// update group counter
+						indices.push( a, b, d );
+						groupCount += 3;
 
-					groupCount += 6;
+					}
+
+					if ( radiusBottom > 0 ) {
+
+						indices.push( b, c, d );
+						groupCount += 3;
+
+					}
 
 				}
 

package/src/loaders/MaterialLoader.js

@@ -86,7 +86,7 @@ class MaterialLoader extends Loader {
 
 		}
 
-		const material = MaterialLoader.createMaterialFromType( json.type );
+		const material = this.createMaterialFromType( json.type );
 
 		if ( json.uuid !== undefined ) material.uuid = json.uuid;
 		if ( json.name !== undefined ) material.name = json.name;
@@ -342,6 +342,12 @@ class MaterialLoader extends Loader {
 
 	}
 
+	createMaterialFromType( type ) {
+
+		return MaterialLoader.createMaterialFromType( type );
+
+	}
+
 	static createMaterialFromType( type ) {
 
 		const materialLib = {

package/src/loaders/ObjectLoader.js

@@ -851,7 +851,7 @@ class ObjectLoader extends Loader {
 			case 'DirectionalLight':
 
 				object = new DirectionalLight( data.color, data.intensity );
-				object.target = data.target || '';
+				object.target = data.target || '';
 
 				break;
 
@@ -870,7 +870,7 @@ class ObjectLoader extends Loader {
 			case 'SpotLight':
 
 				object = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );
-				object.target = data.target || '';
+				object.target = data.target || '';
 
 				break;
 
@@ -1147,7 +1147,7 @@ class ObjectLoader extends Loader {
 
 		object.traverse( function ( child ) {
 
-			if ( child.isDirectionalLight || child.isSpotLight ) {
+			if ( child.isDirectionalLight || child.isSpotLight ) {
 
 				const uuid = child.target;
 

package/src/{nodes/loaders → loaders/nodes}/NodeLoader.js

@@ -1,7 +1,6 @@
-import { createNodeFromType } from '../core/Node.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import { nodeObject, float } from '../../nodes/tsl/TSLBase.js';
 
-import { Loader } from '../../loaders/Loader.js';
+import { Loader } from '../Loader.js';
 import { FileLoader } from '../../loaders/FileLoader.js';
 
 class NodeLoader extends Loader {
@@ -11,6 +10,7 @@ class NodeLoader extends Loader {
 		super( manager );
 
 		this.textures = {};
+		this.nodes = {};
 
 	}
 
@@ -56,7 +56,7 @@ class NodeLoader extends Loader {
 
 				const { uuid, type } = nodeJSON;
 
-				nodes[ uuid ] = nodeObject( createNodeFromType( type ) ); // @TODO: Maybe nodeObjectify the node in createNodeFromType?
+				nodes[ uuid ] = this.createNodeFromType( type );
 				nodes[ uuid ].uuid = uuid;
 
 			}
@@ -82,7 +82,7 @@ class NodeLoader extends Loader {
 
 	parse( json ) {
 
-		const node = nodeObject( createNodeFromType( json.type ) );
+		const node = this.createNodeFromType( json.type );
 		node.uuid = json.uuid;
 
 		const nodes = this.parseNodes( json.nodes );
@@ -105,6 +105,26 @@ class NodeLoader extends Loader {
 
 	}
 
+	setNodes( value ) {
+
+		this.nodes = value;
+		return this;
+
+	}
+
+	createNodeFromType( type ) {
+
+		if ( this.nodes[ type ] === undefined ) {
+
+			console.error( 'THREE.NodeLoader: Node type not found:', type );
+			return float();
+
+		}
+
+		return nodeObject( new this.nodes[ type ]() );
+
+	}
+
 }
 
 export default NodeLoader;

package/src/{nodes/loaders → loaders/nodes}/NodeMaterialLoader.js

@@ -1,23 +1,5 @@
-import { createNodeMaterialFromType } from '../materials/Materials.js';
-
 import { MaterialLoader } from '../../loaders/MaterialLoader.js';
 
-const superFromTypeFunction = MaterialLoader.createMaterialFromType;
-
-MaterialLoader.createMaterialFromType = function ( type ) {
-
-	const material = createNodeMaterialFromType( type );
-
-	if ( material !== undefined ) {
-
-		return material;
-
-	}
-
-	return superFromTypeFunction.call( this, type );
-
-};
-
 class NodeMaterialLoader extends MaterialLoader {
 
 	constructor( manager ) {
@@ -25,6 +7,7 @@ class NodeMaterialLoader extends MaterialLoader {
 		super( manager );
 
 		this.nodes = {};
+		this.nodeMaterials = {};
 
 	}
 
@@ -50,11 +33,31 @@ class NodeMaterialLoader extends MaterialLoader {
 	setNodes( value ) {
 
 		this.nodes = value;
+		return this;
 
+	}
+
+	setNodeMaterials( value ) {
+
+		this.nodeMaterials = value;
 		return this;
 
 	}
 
+	createMaterialFromType( type ) {
+
+		const materialClass = this.nodeMaterials[ type ];
+
+		if ( materialClass !== undefined ) {
+
+			return new materialClass();
+
+		}
+
+		return super.createMaterialFromType( type );
+
+	}
+
 }
 
 export default NodeMaterialLoader;

package/src/{nodes/loaders → loaders/nodes}/NodeObjectLoader.js

@@ -9,10 +9,27 @@ class NodeObjectLoader extends ObjectLoader {
 
 		super( manager );
 
+		this.nodes = {};
+		this.nodeMaterials = {};
+
 		this._nodesJSON = null;
 
 	}
 
+	setNodes( value ) {
+
+		this.nodes = value;
+		return this;
+
+	}
+
+	setNodeMaterials( value ) {
+
+		this.nodeMaterials = value;
+		return this;
+
+	}
+
 	parse( json, onLoad ) {
 
 		this._nodesJSON = json.nodes;
@@ -30,6 +47,7 @@ class NodeObjectLoader extends ObjectLoader {
 		if ( json !== undefined ) {
 
 			const loader = new NodeLoader();
+			loader.setNodes( this.nodes );
 			loader.setTextures( textures );
 
 			return loader.parseNodes( json );
@@ -51,6 +69,7 @@ class NodeObjectLoader extends ObjectLoader {
 			const loader = new NodeMaterialLoader();
 			loader.setTextures( textures );
 			loader.setNodes( nodes );
+			loader.setNodeMaterials( this.nodeMaterials );
 
 			for ( let i = 0, l = json.length; i < l; i ++ ) {
 

package/src/materials/Material.js

@@ -100,6 +100,10 @@ class Material extends EventDispatcher {
 
 	}
 
+	// onBeforeRender and onBeforeCompile only supported in WebGLRenderer
+
+	onBeforeRender( /* renderer, scene, camera, geometry, object, group */ ) {}
+
 	onBeforeCompile( /* shaderobject, renderer */ ) {}
 
 	customProgramCacheKey() {
@@ -522,13 +526,6 @@ class Material extends EventDispatcher {
 
 	}
 
-	onBeforeRender( /* renderer, scene, camera, geometry, object, group */ ) {
-
-		console.warn( 'Material: onBeforeRender() has been removed.' ); // @deprecated, r166
-
-	}
-
-
 }
 
 export { Material };

package/src/materials/nodes/InstancedPointsNodeMaterial.js

@@ -0,0 +1,156 @@
+import NodeMaterial from './NodeMaterial.js';
+import { attribute } from '../../nodes/core/AttributeNode.js';
+import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
+import { materialColor, materialOpacity, materialPointWidth } from '../../nodes/accessors/MaterialNode.js'; // or should this be a property, instead?
+import { modelViewMatrix } from '../../nodes/accessors/ModelNode.js';
+import { positionGeometry } from '../../nodes/accessors/Position.js';
+import { smoothstep, lengthSq } from '../../nodes/math/MathNode.js';
+import { Fn, vec4, float } from '../../nodes/tsl/TSLBase.js';
+import { uv } from '../../nodes/accessors/UV.js';
+import { viewport } from '../../nodes/display/ScreenNode.js';
+
+import { PointsMaterial } from '../PointsMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new PointsMaterial();
+
+class InstancedPointsNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'InstancedPointsNodeMaterial';
+
+	}
+
+	constructor( params = {} ) {
+
+		super();
+
+		this.lights = false;
+
+		this.useAlphaToCoverage = true;
+
+		this.useColor = params.vertexColors;
+
+		this.pointWidth = 1;
+
+		this.pointColorNode = null;
+
+		this.pointWidthNode = null;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( params );
+
+	}
+
+	setup( builder ) {
+
+		this.setupShaders( builder );
+
+		super.setup( builder );
+
+	}
+
+	setupShaders( { renderer } ) {
+
+		const useAlphaToCoverage = this.alphaToCoverage;
+		const useColor = this.useColor;
+
+		this.vertexNode = Fn( () => {
+
+			const instancePosition = attribute( 'instancePosition' ).xyz;
+
+			// camera space
+			const mvPos = vec4( modelViewMatrix.mul( vec4( instancePosition, 1.0 ) ) );
+
+			const aspect = viewport.z.div( viewport.w );
+
+			// clip space
+			const clipPos = cameraProjectionMatrix.mul( mvPos );
+
+			// offset in ndc space
+			const offset = positionGeometry.xy.toVar();
+
+			offset.mulAssign( this.pointWidthNode ? this.pointWidthNode : materialPointWidth );
+
+			offset.assign( offset.div( viewport.z ) );
+			offset.y.assign( offset.y.mul( aspect ) );
+
+			// back to clip space
+			offset.assign( offset.mul( clipPos.w ) );
+
+			//clipPos.xy += offset;
+			clipPos.addAssign( vec4( offset, 0, 0 ) );
+
+			return clipPos;
+
+		} )();
+
+		this.fragmentNode = Fn( () => {
+
+			const alpha = float( 1 ).toVar();
+
+			const len2 = lengthSq( uv().mul( 2 ).sub( 1 ) );
+
+			if ( useAlphaToCoverage && renderer.samples > 1 ) {
+
+				const dlen = float( len2.fwidth() ).toVar();
+
+				alpha.assign( smoothstep( dlen.oneMinus(), dlen.add( 1 ), len2 ).oneMinus() );
+
+			} else {
+
+				len2.greaterThan( 1.0 ).discard();
+
+			}
+
+			let pointColorNode;
+
+			if ( this.pointColorNode ) {
+
+				pointColorNode = this.pointColorNode;
+
+			} else {
+
+				if ( useColor ) {
+
+					const instanceColor = attribute( 'instanceColor' );
+
+					pointColorNode = instanceColor.mul( materialColor );
+
+				} else {
+
+					pointColorNode = materialColor;
+
+				}
+
+			}
+
+			alpha.mulAssign( materialOpacity );
+
+			return vec4( pointColorNode, alpha );
+
+		} )();
+
+	}
+
+	get alphaToCoverage() {
+
+		return this.useAlphaToCoverage;
+
+	}
+
+	set alphaToCoverage( value ) {
+
+		if ( this.useAlphaToCoverage !== value ) {
+
+			this.useAlphaToCoverage = value;
+			this.needsUpdate = true;
+
+		}
+
+	}
+
+}
+
+export default InstancedPointsNodeMaterial;