super-three 0.136.0 → 0.141.0

package/src/math/MathUtils.js

@@ -24,8 +24,8 @@ function generateUUID() {
 			_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
 			_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
 
-	// .toUpperCase() here flattens concatenated strings to save heap memory space.
-	return uuid.toUpperCase();
+	// .toLowerCase() here flattens concatenated strings to save heap memory space.
+	return uuid.toLowerCase();
 
 }
 
@@ -35,7 +35,7 @@ function clamp( value, min, max ) {
 
 }
 
-// compute euclidian modulo of m % n
+// compute euclidean modulo of m % n
 // https://en.wikipedia.org/wiki/Modulo_operation
 function euclideanModulo( n, m ) {
 
@@ -133,13 +133,17 @@ function randFloatSpread( range ) {
 // Deterministic pseudo-random float in the interval [ 0, 1 ]
 function seededRandom( s ) {
 
-	if ( s !== undefined ) _seed = s % 2147483647;
+	if ( s !== undefined ) _seed = s;
 
-	// Park-Miller algorithm
+	// Mulberry32 generator
 
-	_seed = _seed * 16807 % 2147483647;
+	let t = _seed += 0x6D2B79F5;
 
-	return ( _seed - 1 ) / 2147483646;
+	t = Math.imul( t ^ t >>> 15, t | 1 );
+
+	t ^= t + Math.imul( t ^ t >>> 7, t | 61 );
+
+	return ( ( t ^ t >>> 14 ) >>> 0 ) / 4294967296;
 
 }
 
@@ -229,6 +233,69 @@ function setQuaternionFromProperEuler( q, a, b, c, order ) {
 
 }
 
+function denormalize( value, array ) {
+
+	switch ( array.constructor ) {
+
+		case Float32Array:
+
+			return value;
+
+		case Uint16Array:
+
+			return value / 65535.0;
+
+		case Uint8Array:
+
+			return value / 255.0;
+
+		case Int16Array:
+
+			return Math.max( value / 32767.0, - 1.0 );
+
+		case Int8Array:
+
+			return Math.max( value / 127.0, - 1.0 );
+
+		default:
+
+			throw new Error( 'Invalid component type.' );
+
+	}
+
+}
+
+function normalize( value, array ) {
+
+	switch ( array.constructor ) {
+
+		case Float32Array:
+
+			return value;
+
+		case Uint16Array:
+
+			return Math.round( value * 65535.0 );
+
+		case Uint8Array:
+
+			return Math.round( value * 255.0 );
+
+		case Int16Array:
+
+			return Math.round( value * 32767.0 );
+
+		case Int8Array:
+
+			return Math.round( value * 127.0 );
+
+		default:
+
+			throw new Error( 'Invalid component type.' );
+
+	}
+
+}
 
 
 
@@ -255,4 +322,6 @@ export {
 	ceilPowerOfTwo,
 	floorPowerOfTwo,
 	setQuaternionFromProperEuler,
+	normalize,
+	denormalize,
 };

package/src/math/Matrix3.js

@@ -2,6 +2,8 @@ class Matrix3 {
 
 	constructor() {
 
+		this.isMatrix3 = true;
+
 		this.elements = [
 
 			1, 0, 0,
@@ -334,6 +336,4 @@ class Matrix3 {
 
 }
 
-Matrix3.prototype.isMatrix3 = true;
-
 export { Matrix3 };

package/src/math/Matrix4.js

@@ -1,9 +1,10 @@
 import { Vector3 } from './Vector3.js';
-
 class Matrix4 {
 
 	constructor() {
 
+		this.isMatrix4 = true;
+
 		this.elements = [
 
 			1, 0, 0, 0,
@@ -872,8 +873,6 @@ class Matrix4 {
 
 }
 
-Matrix4.prototype.isMatrix4 = true;
-
 const _v1 = /*@__PURE__*/ new Vector3();
 const _m1 = /*@__PURE__*/ new Matrix4();
 const _zero = /*@__PURE__*/ new Vector3( 0, 0, 0 );

package/src/math/Plane.js

@@ -9,6 +9,8 @@ class Plane {
 
 	constructor( normal = new Vector3( 1, 0, 0 ), constant = 0 ) {
 
+		this.isPlane = true;
+
 		// normal is assumed to be normalized
 
 		this.normal = normal;
@@ -200,6 +202,4 @@ class Plane {
 
 }
 
-Plane.prototype.isPlane = true;
-
 export { Plane };

package/src/math/Quaternion.js

@@ -4,6 +4,8 @@ class Quaternion {
 
 	constructor( x = 0, y = 0, z = 0, w = 1 ) {
 
+		this.isQuaternion = true;
+
 		this._x = x;
 		this._y = y;
 		this._z = z;
@@ -604,7 +606,7 @@ class Quaternion {
 
 	slerpQuaternions( qa, qb, t ) {
 
-		this.copy( qa ).slerp( qb, t );
+		return this.copy( qa ).slerp( qb, t );
 
 	}
 
@@ -682,8 +684,15 @@ class Quaternion {
 
 	_onChangeCallback() {}
 
-}
+	*[ Symbol.iterator ]() {
+
+		yield this._x;
+		yield this._y;
+		yield this._z;
+		yield this._w;
 
-Quaternion.prototype.isQuaternion = true;
+	}
+
+}
 
 export { Quaternion };

package/src/math/Spherical.js

@@ -39,7 +39,7 @@ class Spherical {
 
 	}
 
-	// restrict phi to be betwee EPS and PI-EPS
+	// restrict phi to be between EPS and PI-EPS
 	makeSafe() {
 
 		const EPS = 0.000001;

package/src/math/SphericalHarmonics3.js

@@ -14,6 +14,8 @@ class SphericalHarmonics3 {
 
 	constructor() {
 
+		this.isSphericalHarmonics3 = true;
+
 		this.coefficients = [];
 
 		for ( let i = 0; i < 9; i ++ ) {
@@ -238,6 +240,4 @@ class SphericalHarmonics3 {
 
 }
 
-SphericalHarmonics3.prototype.isSphericalHarmonics3 = true;
-
 export { SphericalHarmonics3 };

package/src/math/Vector2.js

@@ -2,6 +2,8 @@ class Vector2 {
 
 	constructor( x = 0, y = 0 ) {
 
+		this.isVector2 = true;
+
 		this.x = x;
 		this.y = y;
 
@@ -479,6 +481,4 @@ class Vector2 {
 
 }
 
-Vector2.prototype.isVector2 = true;
-
 export { Vector2 };

package/src/math/Vector3.js

@@ -1,10 +1,11 @@
 import * as MathUtils from './MathUtils.js';
 import { Quaternion } from './Quaternion.js';
-
 class Vector3 {
 
 	constructor( x = 0, y = 0, z = 0 ) {
 
+		this.isVector3 = true;
+
 		this.x = x;
 		this.y = y;
 		this.z = z;
@@ -659,6 +660,16 @@ class Vector3 {
 
 	}
 
+	setFromEuler( e ) {
+
+		this.x = e._x;
+		this.y = e._y;
+		this.z = e._z;
+
+		return this;
+
+	}
+
 	equals( v ) {
 
 		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );
@@ -737,8 +748,6 @@ class Vector3 {
 
 }
 
-Vector3.prototype.isVector3 = true;
-
 const _vector = /*@__PURE__*/ new Vector3();
 const _quaternion = /*@__PURE__*/ new Quaternion();
 

package/src/math/Vector4.js

@@ -2,6 +2,8 @@ class Vector4 {
 
 	constructor( x = 0, y = 0, z = 0, w = 1 ) {
 
+		this.isVector4 = true;
+
 		this.x = x;
 		this.y = y;
 		this.z = z;
@@ -659,6 +661,4 @@ class Vector4 {
 
 }
 
-Vector4.prototype.isVector4 = true;
-
 export { Vector4 };

package/src/math/interpolants/DiscreteInterpolant.js

@@ -2,7 +2,7 @@ import { Interpolant } from '../Interpolant.js';
 
 /**
  *
- * Interpolant that evaluates to the sample value at the position preceeding
+ * Interpolant that evaluates to the sample value at the position preceding
  * the parameter.
  */
 

package/src/objects/Bone.js

@@ -6,12 +6,12 @@ class Bone extends Object3D {
 
 		super();
 
+		this.isBone = true;
+
 		this.type = 'Bone';
 
 	}
 
 }
 
-Bone.prototype.isBone = true;
-
 export { Bone };

package/src/objects/Group.js

@@ -6,12 +6,12 @@ class Group extends Object3D {
 
 		super();
 
+		this.isGroup = true;
+
 		this.type = 'Group';
 
 	}
 
 }
 
-Group.prototype.isGroup = true;
-
 export { Group };

package/src/objects/InstancedMesh.js

@@ -15,6 +15,8 @@ class InstancedMesh extends Mesh {
 
 		super( geometry, material );
 
+		this.isInstancedMesh = true;
+
 		this.instanceMatrix = new InstancedBufferAttribute( new Float32Array( count * 16 ), 16 );
 		this.instanceColor = null;
 
@@ -24,9 +26,9 @@ class InstancedMesh extends Mesh {
 
 	}
 
-	copy( source ) {
+	copy( source, recursive ) {
 
-		super.copy( source );
+		super.copy( source, recursive );
 
 		this.instanceMatrix.copy( source.instanceMatrix );
 
@@ -121,6 +123,4 @@ class InstancedMesh extends Mesh {
 
 }
 
-InstancedMesh.prototype.isInstancedMesh = true;
-
 export { InstancedMesh };

package/src/objects/Line.js

@@ -19,6 +19,8 @@ class Line extends Object3D {
 
 		super();
 
+		this.isLine = true;
+
 		this.type = 'Line';
 
 		this.geometry = geometry;
@@ -28,9 +30,9 @@ class Line extends Object3D {
 
 	}
 
-	copy( source ) {
+	copy( source, recursive ) {
 
-		super.copy( source );
+		super.copy( source, recursive );
 
 		this.material = source.material;
 		this.geometry = source.geometry;
@@ -43,36 +45,28 @@ class Line extends Object3D {
 
 		const geometry = this.geometry;
 
-		if ( geometry.isBufferGeometry ) {
-
-			// we assume non-indexed geometry
-
-			if ( geometry.index === null ) {
-
-				const positionAttribute = geometry.attributes.position;
-				const lineDistances = [ 0 ];
+		// we assume non-indexed geometry
 
-				for ( let i = 1, l = positionAttribute.count; i < l; i ++ ) {
+		if ( geometry.index === null ) {
 
-					_start.fromBufferAttribute( positionAttribute, i - 1 );
-					_end.fromBufferAttribute( positionAttribute, i );
-
-					lineDistances[ i ] = lineDistances[ i - 1 ];
-					lineDistances[ i ] += _start.distanceTo( _end );
-
-				}
+			const positionAttribute = geometry.attributes.position;
+			const lineDistances = [ 0 ];
 
-				geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );
+			for ( let i = 1, l = positionAttribute.count; i < l; i ++ ) {
 
-			} else {
+				_start.fromBufferAttribute( positionAttribute, i - 1 );
+				_end.fromBufferAttribute( positionAttribute, i );
 
-				console.warn( 'THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );
+				lineDistances[ i ] = lineDistances[ i - 1 ];
+				lineDistances[ i ] += _start.distanceTo( _end );
 
 			}
 
-		} else if ( geometry.isGeometry ) {
+			geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );
 
-			console.error( 'THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );
+		} else {
+
+			console.warn( 'THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );
 
 		}
 
@@ -111,91 +105,83 @@ class Line extends Object3D {
 		const interRay = new Vector3();
 		const step = this.isLineSegments ? 2 : 1;
 
-		if ( geometry.isBufferGeometry ) {
+		const index = geometry.index;
+		const attributes = geometry.attributes;
+		const positionAttribute = attributes.position;
 
-			const index = geometry.index;
-			const attributes = geometry.attributes;
-			const positionAttribute = attributes.position;
+		if ( index !== null ) {
 
-			if ( index !== null ) {
+			const start = Math.max( 0, drawRange.start );
+			const end = Math.min( index.count, ( drawRange.start + drawRange.count ) );
 
-				const start = Math.max( 0, drawRange.start );
-				const end = Math.min( index.count, ( drawRange.start + drawRange.count ) );
+			for ( let i = start, l = end - 1; i < l; i += step ) {
 
-				for ( let i = start, l = end - 1; i < l; i += step ) {
+				const a = index.getX( i );
+				const b = index.getX( i + 1 );
 
-					const a = index.getX( i );
-					const b = index.getX( i + 1 );
+				vStart.fromBufferAttribute( positionAttribute, a );
+				vEnd.fromBufferAttribute( positionAttribute, b );
 
-					vStart.fromBufferAttribute( positionAttribute, a );
-					vEnd.fromBufferAttribute( positionAttribute, b );
+				const distSq = _ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
 
-					const distSq = _ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
+				if ( distSq > localThresholdSq ) continue;
 
-					if ( distSq > localThresholdSq ) continue;
+				interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
 
-					interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
+				const distance = raycaster.ray.origin.distanceTo( interRay );
 
-					const distance = raycaster.ray.origin.distanceTo( interRay );
+				if ( distance < raycaster.near || distance > raycaster.far ) continue;
 
-					if ( distance < raycaster.near || distance > raycaster.far ) continue;
+				intersects.push( {
 
-					intersects.push( {
+					distance: distance,
+					// What do we want? intersection point on the ray or on the segment??
+					// point: raycaster.ray.at( distance ),
+					point: interSegment.clone().applyMatrix4( this.matrixWorld ),
+					index: i,
+					face: null,
+					faceIndex: null,
+					object: this
 
-						distance: distance,
-						// What do we want? intersection point on the ray or on the segment??
-						// point: raycaster.ray.at( distance ),
-						point: interSegment.clone().applyMatrix4( this.matrixWorld ),
-						index: i,
-						face: null,
-						faceIndex: null,
-						object: this
+				} );
 
-					} );
-
-				}
-
-			} else {
+			}
 
-				const start = Math.max( 0, drawRange.start );
-				const end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) );
+		} else {
 
-				for ( let i = start, l = end - 1; i < l; i += step ) {
+			const start = Math.max( 0, drawRange.start );
+			const end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) );
 
-					vStart.fromBufferAttribute( positionAttribute, i );
-					vEnd.fromBufferAttribute( positionAttribute, i + 1 );
+			for ( let i = start, l = end - 1; i < l; i += step ) {
 
-					const distSq = _ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
+				vStart.fromBufferAttribute( positionAttribute, i );
+				vEnd.fromBufferAttribute( positionAttribute, i + 1 );
 
-					if ( distSq > localThresholdSq ) continue;
+				const distSq = _ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
 
-					interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
+				if ( distSq > localThresholdSq ) continue;
 
-					const distance = raycaster.ray.origin.distanceTo( interRay );
+				interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
 
-					if ( distance < raycaster.near || distance > raycaster.far ) continue;
+				const distance = raycaster.ray.origin.distanceTo( interRay );
 
-					intersects.push( {
+				if ( distance < raycaster.near || distance > raycaster.far ) continue;
 
-						distance: distance,
-						// What do we want? intersection point on the ray or on the segment??
-						// point: raycaster.ray.at( distance ),
-						point: interSegment.clone().applyMatrix4( this.matrixWorld ),
-						index: i,
-						face: null,
-						faceIndex: null,
-						object: this
+				intersects.push( {
 
-					} );
+					distance: distance,
+					// What do we want? intersection point on the ray or on the segment??
+					// point: raycaster.ray.at( distance ),
+					point: interSegment.clone().applyMatrix4( this.matrixWorld ),
+					index: i,
+					face: null,
+					faceIndex: null,
+					object: this
 
-				}
+				} );
 
 			}
 
-		} else if ( geometry.isGeometry ) {
-
-			console.error( 'THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );
-
 		}
 
 	}
@@ -204,50 +190,33 @@ class Line extends Object3D {
 
 		const geometry = this.geometry;
 
-		if ( geometry.isBufferGeometry ) {
-
-			const morphAttributes = geometry.morphAttributes;
-			const keys = Object.keys( morphAttributes );
+		const morphAttributes = geometry.morphAttributes;
+		const keys = Object.keys( morphAttributes );
 
-			if ( keys.length > 0 ) {
+		if ( keys.length > 0 ) {
 
-				const morphAttribute = morphAttributes[ keys[ 0 ] ];
+			const morphAttribute = morphAttributes[ keys[ 0 ] ];
 
-				if ( morphAttribute !== undefined ) {
+			if ( morphAttribute !== undefined ) {
 
-					this.morphTargetInfluences = [];
-					this.morphTargetDictionary = {};
+				this.morphTargetInfluences = [];
+				this.morphTargetDictionary = {};
 
-					for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {
+				for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {
 
-						const name = morphAttribute[ m ].name || String( m );
+					const name = morphAttribute[ m ].name || String( m );
 
-						this.morphTargetInfluences.push( 0 );
-						this.morphTargetDictionary[ name ] = m;
-
-					}
+					this.morphTargetInfluences.push( 0 );
+					this.morphTargetDictionary[ name ] = m;
 
 				}
 
 			}
 
-		} else {
-
-			const morphTargets = geometry.morphTargets;
-
-			if ( morphTargets !== undefined && morphTargets.length > 0 ) {
-
-				console.error( 'THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.' );
-
-			}
-
 		}
 
 	}
 
 }
 
-Line.prototype.isLine = true;
-
-
 export { Line };

package/src/objects/LineLoop.js

@@ -6,12 +6,12 @@ class LineLoop extends Line {
 
 		super( geometry, material );
 
+		this.isLineLoop = true;
+
 		this.type = 'LineLoop';
 
 	}
 
 }
 
-LineLoop.prototype.isLineLoop = true;
-
 export { LineLoop };