@needle-tools/three 0.145.2 → 0.146.1

package/examples/js/utils/BufferGeometryUtils.js

@@ -24,17 +24,14 @@
 
 			if ( attribute.normalized || attribute.isInterleavedBufferAttribute ) {
 
-				const srcArray = attribute.isInterleavedBufferAttribute ? attribute.data.array : attribute.array;
 				const dstArray = new Float32Array( attribute.getCount() * attribute.itemSize );
-
 				for ( let i = 0, j = 0; i < attribute.getCount(); i ++ ) {
 
-					dstArray[ j ++ ] = THREE.MathUtils.denormalize( attribute.getX( i ), srcArray );
-					dstArray[ j ++ ] = THREE.MathUtils.denormalize( attribute.getY( i ), srcArray );
-
+					dstArray[ j ++ ] = attribute.getX( i );
+					dstArray[ j ++ ] = attribute.getY( i );
 					if ( attribute.itemSize > 2 ) {
 
-						dstArray[ j ++ ] = THREE.MathUtils.denormalize( attribute.getZ( i ), srcArray );
+						dstArray[ j ++ ] = attribute.getZ( i );
 
 					}
 
@@ -52,13 +49,17 @@
 
 			return new Float32Array( attribute.array );
 
-		} // MikkTSpace algorithm requires non-indexed input.
+		}
+
+		// MikkTSpace algorithm requires non-indexed input.
 
+		const _geometry = geometry.index ? geometry.toNonIndexed() : geometry;
 
-		const _geometry = geometry.index ? geometry.toNonIndexed() : geometry; // Compute vertex tangents.
+		// Compute vertex tangents.
 
+		const tangents = MikkTSpace.generateTangents( getAttributeArray( _geometry.attributes.position ), getAttributeArray( _geometry.attributes.normal ), getAttributeArray( _geometry.attributes.uv ) );
 
-		const tangents = MikkTSpace.generateTangents( getAttributeArray( _geometry.attributes.position ), getAttributeArray( _geometry.attributes.normal ), getAttributeArray( _geometry.attributes.uv ) ); // Texture coordinate convention of glTF differs from the apparent
+		// Texture coordinate convention of glTF differs from the apparent
 		// default of the MikkTSpace library; .w component must be flipped.
 
 		if ( negateSign ) {
@@ -69,11 +70,11 @@
 
 			}
 
-		} //
+		}
 
+		//
 
 		_geometry.setAttribute( 'tangent', new THREE.BufferAttribute( tangents, 4 ) );
-
 		if ( geometry !== _geometry ) {
 
 			geometry.copy( _geometry );
@@ -83,13 +84,12 @@
 		return geometry;
 
 	}
+
 	/**
  * @param  {Array<BufferGeometry>} geometries
  * @param  {Boolean} useGroups
  * @return {BufferGeometry}
  */
-
-
 	function mergeBufferGeometries( geometries, useGroups = false ) {
 
 		const isIndexed = geometries[ 0 ].index !== null;
@@ -100,19 +100,21 @@
 		const morphTargetsRelative = geometries[ 0 ].morphTargetsRelative;
 		const mergedGeometry = new THREE.BufferGeometry();
 		let offset = 0;
-
 		for ( let i = 0; i < geometries.length; ++ i ) {
 
 			const geometry = geometries[ i ];
-			let attributesCount = 0; // ensure that all geometries are indexed, or none
+			let attributesCount = 0;
+
+			// ensure that all geometries are indexed, or none
 
 			if ( isIndexed !== ( geometry.index !== null ) ) {
 
 				console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
 				return null;
 
-			} // gather attributes, exit early if they're different
+			}
 
+			// gather attributes, exit early if they're different
 
 			for ( const name in geometry.attributes ) {
 
@@ -127,16 +129,18 @@
 				attributes[ name ].push( geometry.attributes[ name ] );
 				attributesCount ++;
 
-			} // ensure geometries have the same number of attributes
+			}
 
+			// ensure geometries have the same number of attributes
 
 			if ( attributesCount !== attributesUsed.size ) {
 
 				console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );
 				return null;
 
-			} // gather morph attributes, exit early if they're different
+			}
 
+			// gather morph attributes, exit early if they're different
 
 			if ( morphTargetsRelative !== geometry.morphTargetsRelative ) {
 
@@ -157,16 +161,11 @@
 				if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];
 				morphAttributes[ name ].push( geometry.morphAttributes[ name ] );
 
-			} // gather .userData
-
-
-			mergedGeometry.userData.mergedUserData = mergedGeometry.userData.mergedUserData || [];
-			mergedGeometry.userData.mergedUserData.push( geometry.userData );
+			}
 
 			if ( useGroups ) {
 
 				let count;
-
 				if ( isIndexed ) {
 
 					count = geometry.index.count;
@@ -187,18 +186,17 @@
 
 			}
 
-		} // merge indices
+		}
 
+		// merge indices
 
 		if ( isIndexed ) {
 
 			let indexOffset = 0;
 			const mergedIndex = [];
-
 			for ( let i = 0; i < geometries.length; ++ i ) {
 
 				const index = geometries[ i ].index;
-
 				for ( let j = 0; j < index.count; ++ j ) {
 
 					mergedIndex.push( index.getX( j ) + indexOffset );
@@ -211,13 +209,13 @@
 
 			mergedGeometry.setIndex( mergedIndex );
 
-		} // merge attributes
+		}
 
+		// merge attributes
 
 		for ( const name in attributes ) {
 
 			const mergedAttribute = mergeBufferAttributes( attributes[ name ] );
-
 			if ( ! mergedAttribute ) {
 
 				console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed while trying to merge the ' + name + ' attribute.' );
@@ -227,8 +225,9 @@
 
 			mergedGeometry.setAttribute( name, mergedAttribute );
 
-		} // merge morph attributes
+		}
 
+		// merge morph attributes
 
 		for ( const name in morphAttributes ) {
 
@@ -236,11 +235,9 @@
 			if ( numMorphTargets === 0 ) break;
 			mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
 			mergedGeometry.morphAttributes[ name ] = [];
-
 			for ( let i = 0; i < numMorphTargets; ++ i ) {
 
 				const morphAttributesToMerge = [];
-
 				for ( let j = 0; j < morphAttributes[ name ].length; ++ j ) {
 
 					morphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] );
@@ -248,7 +245,6 @@
 				}
 
 				const mergedMorphAttribute = mergeBufferAttributes( morphAttributesToMerge );
-
 				if ( ! mergedMorphAttribute ) {
 
 					console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );
@@ -265,23 +261,20 @@
 		return mergedGeometry;
 
 	}
+
 	/**
  * @param {Array<BufferAttribute>} attributes
  * @return {BufferAttribute}
  */
-
-
 	function mergeBufferAttributes( attributes ) {
 
 		let TypedArray;
 		let itemSize;
 		let normalized;
 		let arrayLength = 0;
-
 		for ( let i = 0; i < attributes.length; ++ i ) {
 
 			const attribute = attributes[ i ];
-
 			if ( attribute.isInterleavedBufferAttribute ) {
 
 				console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. InterleavedBufferAttributes are not supported.' );
@@ -290,7 +283,6 @@
 			}
 
 			if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
-
 			if ( TypedArray !== attribute.array.constructor ) {
 
 				console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. THREE.BufferAttribute.array must be of consistent array types across matching attributes.' );
@@ -299,7 +291,6 @@
 			}
 
 			if ( itemSize === undefined ) itemSize = attribute.itemSize;
-
 			if ( itemSize !== attribute.itemSize ) {
 
 				console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. THREE.BufferAttribute.itemSize must be consistent across matching attributes.' );
@@ -308,7 +299,6 @@
 			}
 
 			if ( normalized === undefined ) normalized = attribute.normalized;
-
 			if ( normalized !== attribute.normalized ) {
 
 				console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. THREE.BufferAttribute.normalized must be consistent across matching attributes.' );
@@ -322,7 +312,6 @@
 
 		const array = new TypedArray( arrayLength );
 		let offset = 0;
-
 		for ( let i = 0; i < attributes.length; ++ i ) {
 
 			array.set( attributes[ i ].array, offset );
@@ -333,25 +322,46 @@
 		return new THREE.BufferAttribute( array, itemSize, normalized );
 
 	}
+
 	/**
- * @param {Array<BufferAttribute>} attributes
- * @return {Array<InterleavedBufferAttribute>}
+ * @param {BufferAttribute}
+ * @return {BufferAttribute}
  */
+	function deepCloneAttribute( attribute ) {
+
+		if ( attribute.isInstancedInterleavedBufferAttribute || attribute.isInterleavedBufferAttribute ) {
+
+			return deinterleaveAttribute( attribute );
+
+		}
+
+		if ( attribute.isInstancedBufferAttribute ) {
 
+			return new THREE.InstancedBufferAttribute().copy( attribute );
 
+		}
+
+		return new THREE.BufferAttribute().copy( attribute );
+
+	}
+
+	/**
+ * @param {Array<BufferAttribute>} attributes
+ * @return {Array<InterleavedBufferAttribute>}
+ */
 	function interleaveAttributes( attributes ) {
 
 		// Interleaves the provided attributes into an THREE.InterleavedBuffer and returns
 		// a set of InterleavedBufferAttributes for each attribute
 		let TypedArray;
 		let arrayLength = 0;
-		let stride = 0; // calculate the length and type of the interleavedBuffer
+		let stride = 0;
 
+		// calculate the length and type of the interleavedBuffer
 		for ( let i = 0, l = attributes.length; i < l; ++ i ) {
 
 			const attribute = attributes[ i ];
 			if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
-
 			if ( TypedArray !== attribute.array.constructor ) {
 
 				console.error( 'AttributeBuffers of different types cannot be interleaved' );
@@ -362,15 +372,14 @@
 			arrayLength += attribute.array.length;
 			stride += attribute.itemSize;
 
-		} // Create the set of buffer attributes
-
+		}
 
+		// Create the set of buffer attributes
 		const interleavedBuffer = new THREE.InterleavedBuffer( new TypedArray( arrayLength ), stride );
 		let offset = 0;
 		const res = [];
 		const getters = [ 'getX', 'getY', 'getZ', 'getW' ];
 		const setters = [ 'setX', 'setY', 'setZ', 'setW' ];
-
 		for ( let j = 0, l = attributes.length; j < l; j ++ ) {
 
 			const attribute = attributes[ j ];
@@ -378,9 +387,10 @@
 			const count = attribute.count;
 			const iba = new THREE.InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, attribute.normalized );
 			res.push( iba );
-			offset += itemSize; // Move the data for each attribute into the new interleavedBuffer
-			// at the appropriate offset
+			offset += itemSize;
 
+			// Move the data for each attribute into the new interleavedBuffer
+			// at the appropriate offset
 			for ( let c = 0; c < count; c ++ ) {
 
 				for ( let k = 0; k < itemSize; k ++ ) {
@@ -395,9 +405,9 @@
 
 		return res;
 
-	} // returns a new, non-interleaved version of the provided attribute
-
+	}
 
+	// returns a new, non-interleaved version of the provided attribute
 	function deinterleaveAttribute( attribute ) {
 
 		const cons = attribute.data.array.constructor;
@@ -406,7 +416,6 @@
 		const normalized = attribute.normalized;
 		const array = new cons( count * itemSize );
 		let newAttribute;
-
 		if ( attribute.isInstancedInterleavedBufferAttribute ) {
 
 			newAttribute = new THREE.InstancedBufferAttribute( array, itemSize, normalized, attribute.meshPerAttribute );
@@ -420,7 +429,6 @@
 		for ( let i = 0; i < count; i ++ ) {
 
 			newAttribute.setX( i, attribute.getX( i ) );
-
 			if ( itemSize >= 2 ) {
 
 				newAttribute.setY( i, attribute.getY( i ) );
@@ -443,18 +451,17 @@
 
 		return newAttribute;
 
-	} // deinterleaves all attributes on the geometry
+	}
 
+	// deinterleaves all attributes on the geometry
 	function deinterleaveGeometry( geometry ) {
 
 		const attributes = geometry.attributes;
 		const morphTargets = geometry.morphTargets;
 		const attrMap = new Map();
-
 		for ( const key in attributes ) {
 
 			const attr = attributes[ key ];
-
 			if ( attr.isInterleavedBufferAttribute ) {
 
 				if ( ! attrMap.has( attr ) ) {
@@ -472,7 +479,6 @@
 		for ( const key in morphTargets ) {
 
 			const attr = morphTargets[ key ];
-
 			if ( attr.isInterleavedBufferAttribute ) {
 
 				if ( ! attrMap.has( attr ) ) {
@@ -488,18 +494,17 @@
 		}
 
 	}
+
 	/**
  * @param {Array<BufferGeometry>} geometry
  * @return {number}
  */
-
 	function estimateBytesUsed( geometry ) {
 
 		// Return the estimated memory used by this geometry in bytes
 		// Calculate using itemSize, count, and BYTES_PER_ELEMENT to account
 		// for InterleavedBufferAttributes.
 		let mem = 0;
-
 		for ( const name in geometry.attributes ) {
 
 			const attr = geometry.getAttribute( name );
@@ -512,61 +517,64 @@
 		return mem;
 
 	}
+
 	/**
  * @param {BufferGeometry} geometry
  * @param {number} tolerance
  * @return {BufferGeometry}
  */
-
-
 	function mergeVertices( geometry, tolerance = 1e-4 ) {
 
-		tolerance = Math.max( tolerance, Number.EPSILON ); // Generate an index buffer if the geometry doesn't have one, or optimize it
-		// if it's already available.
+		tolerance = Math.max( tolerance, Number.EPSILON );
 
+		// Generate an index buffer if the geometry doesn't have one, or optimize it
+		// if it's already available.
 		const hashToIndex = {};
 		const indices = geometry.getIndex();
 		const positions = geometry.getAttribute( 'position' );
-		const vertexCount = indices ? indices.count : positions.count; // next value for triangle indices
+		const vertexCount = indices ? indices.count : positions.count;
 
-		let nextIndex = 0; // attributes and new attribute arrays
+		// next value for triangle indices
+		let nextIndex = 0;
 
+		// attributes and new attribute arrays
 		const attributeNames = Object.keys( geometry.attributes );
-		const attrArrays = {};
-		const morphAttrsArrays = {};
+		const tmpAttributes = {};
+		const tmpMorphAttributes = {};
 		const newIndices = [];
-		const getters = [ 'getX', 'getY', 'getZ', 'getW' ]; // initialize the arrays
+		const getters = [ 'getX', 'getY', 'getZ', 'getW' ];
+		const setters = [ 'setX', 'setY', 'setZ', 'setW' ];
 
+		// Initialize the arrays, allocating space conservatively. Extra
+		// space will be trimmed in the last step.
 		for ( let i = 0, l = attributeNames.length; i < l; i ++ ) {
 
 			const name = attributeNames[ i ];
-			attrArrays[ name ] = [];
+			const attr = geometry.attributes[ name ];
+			tmpAttributes[ name ] = new THREE.BufferAttribute( new attr.array.constructor( attr.count * attr.itemSize ), attr.itemSize, attr.normalized );
 			const morphAttr = geometry.morphAttributes[ name ];
-
 			if ( morphAttr ) {
 
-				morphAttrsArrays[ name ] = new Array( morphAttr.length ).fill().map( () => [] );
+				tmpMorphAttributes[ name ] = new THREE.BufferAttribute( new morphAttr.array.constructor( morphAttr.count * morphAttr.itemSize ), morphAttr.itemSize, morphAttr.normalized );
 
 			}
 
-		} // convert the error tolerance to an amount of decimal places to truncate to
-
+		}
 
+		// convert the error tolerance to an amount of decimal places to truncate to
 		const decimalShift = Math.log10( 1 / tolerance );
 		const shiftMultiplier = Math.pow( 10, decimalShift );
-
 		for ( let i = 0; i < vertexCount; i ++ ) {
 
-			const index = indices ? indices.getX( i ) : i; // Generate a hash for the vertex attributes at the current index 'i'
+			const index = indices ? indices.getX( i ) : i;
 
+			// Generate a hash for the vertex attributes at the current index 'i'
 			let hash = '';
-
 			for ( let j = 0, l = attributeNames.length; j < l; j ++ ) {
 
 				const name = attributeNames[ j ];
 				const attribute = geometry.getAttribute( name );
 				const itemSize = attribute.itemSize;
-
 				for ( let k = 0; k < itemSize; k ++ ) {
 
 					// double tilde truncates the decimal value
@@ -574,36 +582,35 @@
 
 				}
 
-			} // Add another reference to the vertex if it's already
-			// used by another index
-
+			}
 
+			// Add another reference to the vertex if it's already
+			// used by another index
 			if ( hash in hashToIndex ) {
 
 				newIndices.push( hashToIndex[ hash ] );
 
 			} else {
 
-				// copy data to the new index in the attribute arrays
+				// copy data to the new index in the temporary attributes
 				for ( let j = 0, l = attributeNames.length; j < l; j ++ ) {
 
 					const name = attributeNames[ j ];
 					const attribute = geometry.getAttribute( name );
 					const morphAttr = geometry.morphAttributes[ name ];
 					const itemSize = attribute.itemSize;
-					const newarray = attrArrays[ name ];
-					const newMorphArrays = morphAttrsArrays[ name ];
-
+					const newarray = tmpAttributes[ name ];
+					const newMorphArrays = tmpMorphAttributes[ name ];
 					for ( let k = 0; k < itemSize; k ++ ) {
 
 						const getterFunc = getters[ k ];
-						newarray.push( attribute[ getterFunc ]( index ) );
-
+						const setterFunc = setters[ k ];
+						newarray[ setterFunc ]( nextIndex, attribute[ getterFunc ]( index ) );
 						if ( morphAttr ) {
 
 							for ( let m = 0, ml = morphAttr.length; m < ml; m ++ ) {
 
-								newMorphArrays[ m ].push( morphAttr[ m ][ getterFunc ]( index ) );
+								newMorphArrays[ m ][ setterFunc ]( nextIndex, morphAttr[ m ][ getterFunc ]( index ) );
 
 							}
 
@@ -619,47 +626,36 @@
 
 			}
 
-		} // Generate typed arrays from new attribute arrays and update
-		// the attributeBuffers
-
+		}
 
+		// generate result THREE.BufferGeometry
 		const result = geometry.clone();
+		for ( const name in geometry.attributes ) {
 
-		for ( let i = 0, l = attributeNames.length; i < l; i ++ ) {
-
-			const name = attributeNames[ i ];
-			const oldAttribute = geometry.getAttribute( name );
-			const buffer = new oldAttribute.array.constructor( attrArrays[ name ] );
-			const attribute = new THREE.BufferAttribute( buffer, oldAttribute.itemSize, oldAttribute.normalized );
-			result.setAttribute( name, attribute ); // Update the attribute arrays
-
-			if ( name in morphAttrsArrays ) {
-
-				for ( let j = 0; j < morphAttrsArrays[ name ].length; j ++ ) {
-
-					const oldMorphAttribute = geometry.morphAttributes[ name ][ j ];
-					const buffer = new oldMorphAttribute.array.constructor( morphAttrsArrays[ name ][ j ] );
-					const morphAttribute = new THREE.BufferAttribute( buffer, oldMorphAttribute.itemSize, oldMorphAttribute.normalized );
-					result.morphAttributes[ name ][ j ] = morphAttribute;
+			const tmpAttribute = tmpAttributes[ name ];
+			result.setAttribute( name, new THREE.BufferAttribute( tmpAttribute.array.slice( 0, nextIndex * tmpAttribute.itemSize ), tmpAttribute.itemSize, tmpAttribute.normalized ) );
+			if ( ! ( name in tmpMorphAttributes ) ) continue;
+			for ( let j = 0; j < tmpMorphAttributes[ name ].length; j ++ ) {
 
-				}
+				const tmpMorphAttribute = tmpMorphAttributes[ name ][ j ];
+				result.morphAttributes[ name ][ j ] = new THREE.BufferAttribute( tmpMorphAttribute.array.slice( 0, nextIndex * tmpMorphAttribute.itemSize ), tmpMorphAttribute.itemSize, tmpMorphAttribute.normalized );
 
 			}
 
-		} // indices
+		}
 
+		// indices
 
 		result.setIndex( newIndices );
 		return result;
 
 	}
+
 	/**
  * @param {BufferGeometry} geometry
  * @param {number} drawMode
  * @return {BufferGeometry}
  */
-
-
 	function toTrianglesDrawMode( geometry, drawMode ) {
 
 		if ( drawMode === THREE.TrianglesDrawMode ) {
@@ -671,13 +667,14 @@
 
 		if ( drawMode === THREE.TriangleFanDrawMode || drawMode === THREE.TriangleStripDrawMode ) {
 
-			let index = geometry.getIndex(); // generate index if not present
+			let index = geometry.getIndex();
+
+			// generate index if not present
 
 			if ( index === null ) {
 
 				const indices = [];
 				const position = geometry.getAttribute( 'position' );
-
 				if ( position !== undefined ) {
 
 					for ( let i = 0; i < position.count; i ++ ) {
@@ -696,15 +693,16 @@
 
 				}
 
-			} //
+			}
 
+			//
 
 			const numberOfTriangles = index.count - 2;
 			const newIndices = [];
-
 			if ( drawMode === THREE.TriangleFanDrawMode ) {
 
 				// gl.TRIANGLE_FAN
+
 				for ( let i = 1; i <= numberOfTriangles; i ++ ) {
 
 					newIndices.push( index.getX( 0 ) );
@@ -716,6 +714,7 @@
 			} else {
 
 				// gl.TRIANGLE_STRIP
+
 				for ( let i = 0; i < numberOfTriangles; i ++ ) {
 
 					if ( i % 2 === 0 ) {
@@ -740,8 +739,9 @@
 
 				console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' );
 
-			} // build final geometry
+			}
 
+			// build final geometry
 
 			const newGeometry = geometry.clone();
 			newGeometry.setIndex( newIndices );
@@ -756,14 +756,13 @@
 		}
 
 	}
+
 	/**
  * Calculates the morphed attributes of a morphed/skinned THREE.BufferGeometry.
  * Helpful for Raytracing or Decals.
  * @param {Mesh | Line | Points} object An instance of Mesh, Line or Points.
  * @return {Object} An Object with original position/normal attributes and morphed ones.
  */
-
-
 	function computeMorphedAttributes( object ) {
 
 		if ( object.geometry.isBufferGeometry !== true ) {
@@ -774,67 +773,43 @@
 		}
 
 		const _vA = new THREE.Vector3();
-
 		const _vB = new THREE.Vector3();
-
 		const _vC = new THREE.Vector3();
-
 		const _tempA = new THREE.Vector3();
-
 		const _tempB = new THREE.Vector3();
-
 		const _tempC = new THREE.Vector3();
-
 		const _morphA = new THREE.Vector3();
-
 		const _morphB = new THREE.Vector3();
-
 		const _morphC = new THREE.Vector3();
-
 		function _calculateMorphedAttributeData( object, attribute, morphAttribute, morphTargetsRelative, a, b, c, modifiedAttributeArray ) {
 
 			_vA.fromBufferAttribute( attribute, a );
-
 			_vB.fromBufferAttribute( attribute, b );
-
 			_vC.fromBufferAttribute( attribute, c );
-
 			const morphInfluences = object.morphTargetInfluences;
-
 			if ( morphAttribute && morphInfluences ) {
 
 				_morphA.set( 0, 0, 0 );
-
 				_morphB.set( 0, 0, 0 );
-
 				_morphC.set( 0, 0, 0 );
-
 				for ( let i = 0, il = morphAttribute.length; i < il; i ++ ) {
 
 					const influence = morphInfluences[ i ];
 					const morph = morphAttribute[ i ];
 					if ( influence === 0 ) continue;
-
 					_tempA.fromBufferAttribute( morph, a );
-
 					_tempB.fromBufferAttribute( morph, b );
-
 					_tempC.fromBufferAttribute( morph, c );
-
 					if ( morphTargetsRelative ) {
 
 						_morphA.addScaledVector( _tempA, influence );
-
 						_morphB.addScaledVector( _tempB, influence );
-
 						_morphC.addScaledVector( _tempC, influence );
 
 					} else {
 
 						_morphA.addScaledVector( _tempA.sub( _vA ), influence );
-
 						_morphB.addScaledVector( _tempB.sub( _vB ), influence );
-
 						_morphC.addScaledVector( _tempC.sub( _vC ), influence );
 
 					}
@@ -842,9 +817,7 @@
 				}
 
 				_vA.add( _morphA );
-
 				_vB.add( _morphB );
-
 				_vC.add( _morphC );
 
 			}
@@ -885,10 +858,10 @@
 		let start, end;
 		const modifiedPosition = new Float32Array( positionAttribute.count * positionAttribute.itemSize );
 		const modifiedNormal = new Float32Array( normalAttribute.count * normalAttribute.itemSize );
-
 		if ( index !== null ) {
 
 			// indexed buffer geometry
+
 			if ( Array.isArray( material ) ) {
 
 				for ( i = 0, il = groups.length; i < il; i ++ ) {
@@ -896,15 +869,12 @@
 					group = groups[ i ];
 					start = Math.max( group.start, drawRange.start );
 					end = Math.min( group.start + group.count, drawRange.start + drawRange.count );
-
 					for ( j = start, jl = end; j < jl; j += 3 ) {
 
 						a = index.getX( j );
 						b = index.getX( j + 1 );
 						c = index.getX( j + 2 );
-
 						_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
-
 						_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 					}
@@ -915,15 +885,12 @@
 
 				start = Math.max( 0, drawRange.start );
 				end = Math.min( index.count, drawRange.start + drawRange.count );
-
 				for ( i = start, il = end; i < il; i += 3 ) {
 
 					a = index.getX( i );
 					b = index.getX( i + 1 );
 					c = index.getX( i + 2 );
-
 					_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
-
 					_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 				}
@@ -933,6 +900,7 @@
 		} else {
 
 			// non-indexed buffer geometry
+
 			if ( Array.isArray( material ) ) {
 
 				for ( i = 0, il = groups.length; i < il; i ++ ) {
@@ -940,15 +908,12 @@
 					group = groups[ i ];
 					start = Math.max( group.start, drawRange.start );
 					end = Math.min( group.start + group.count, drawRange.start + drawRange.count );
-
 					for ( j = start, jl = end; j < jl; j += 3 ) {
 
 						a = j;
 						b = j + 1;
 						c = j + 2;
-
 						_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
-
 						_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 					}
@@ -959,15 +924,12 @@
 
 				start = Math.max( 0, drawRange.start );
 				end = Math.min( positionAttribute.count, drawRange.start + drawRange.count );
-
 				for ( i = start, il = end; i < il; i += 3 ) {
 
 					a = i;
 					b = i + 1;
 					c = i + 2;
-
 					_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
-
 					_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 				}
@@ -996,20 +958,23 @@
 
 		}
 
-		let groups = geometry.groups; // sort groups by material index
+		let groups = geometry.groups;
+
+		// sort groups by material index
 
 		groups = groups.sort( ( a, b ) => {
 
 			if ( a.materialIndex !== b.materialIndex ) return a.materialIndex - b.materialIndex;
 			return a.start - b.start;
 
-		} ); // create index for non-indexed geometries
+		} );
+
+		// create index for non-indexed geometries
 
 		if ( geometry.getIndex() === null ) {
 
 			const positionAttribute = geometry.getAttribute( 'position' );
 			const indices = [];
-
 			for ( let i = 0; i < positionAttribute.count; i += 3 ) {
 
 				indices.push( i, i + 1, i + 2 );
@@ -1018,18 +983,17 @@
 
 			geometry.setIndex( indices );
 
-		} // sort index
+		}
 
+		// sort index
 
 		const index = geometry.getIndex();
 		const newIndices = [];
-
 		for ( let i = 0; i < groups.length; i ++ ) {
 
 			const group = groups[ i ];
 			const groupStart = group.start;
 			const groupLength = groupStart + group.count;
-
 			for ( let j = groupStart; j < groupLength; j ++ ) {
 
 				newIndices.push( index.getX( j ) );
@@ -1039,27 +1003,26 @@
 		}
 
 		geometry.dispose(); // Required to force buffer recreation
+		geometry.setIndex( newIndices );
 
-		geometry.setIndex( newIndices ); // update groups indices
+		// update groups indices
 
 		let start = 0;
-
 		for ( let i = 0; i < groups.length; i ++ ) {
 
 			const group = groups[ i ];
 			group.start = start;
 			start += group.count;
 
-		} // merge groups
+		}
 
+		// merge groups
 
 		let currentGroup = groups[ 0 ];
 		geometry.groups = [ currentGroup ];
-
 		for ( let i = 1; i < groups.length; i ++ ) {
 
 			const group = groups[ i ];
-
 			if ( currentGroup.materialIndex === group.materialIndex ) {
 
 				currentGroup.count += group.count;
@@ -1077,10 +1040,112 @@
 
 	}
 
+	// Creates a new, non-indexed geometry with smooth normals everywhere except faces that meet at
+	// an angle greater than the crease angle.
+	function toCreasedNormals( geometry, creaseAngle = Math.PI / 3 /* 60 degrees */ ) {
+
+		const creaseDot = Math.cos( creaseAngle );
+		const hashMultiplier = ( 1 + 1e-10 ) * 1e2;
+
+		// reusable vertors
+		const verts = [ new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3() ];
+		const tempVec1 = new THREE.Vector3();
+		const tempVec2 = new THREE.Vector3();
+		const tempNorm = new THREE.Vector3();
+		const tempNorm2 = new THREE.Vector3();
+
+		// hashes a vector
+		function hashVertex( v ) {
+
+			const x = ~ ~ ( v.x * hashMultiplier );
+			const y = ~ ~ ( v.y * hashMultiplier );
+			const z = ~ ~ ( v.z * hashMultiplier );
+			return `${x},${y},${z}`;
+
+		}
+
+		const resultGeometry = geometry.toNonIndexed();
+		const posAttr = resultGeometry.attributes.position;
+		const vertexMap = {};
+
+		// find all the normals shared by commonly located vertices
+		for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {
+
+			const i3 = 3 * i;
+			const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );
+			const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );
+			const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );
+			tempVec1.subVectors( c, b );
+			tempVec2.subVectors( a, b );
+
+			// add the normal to the map for all vertices
+			const normal = new THREE.Vector3().crossVectors( tempVec1, tempVec2 ).normalize();
+			for ( let n = 0; n < 3; n ++ ) {
+
+				const vert = verts[ n ];
+				const hash = hashVertex( vert );
+				if ( ! ( hash in vertexMap ) ) {
+
+					vertexMap[ hash ] = [];
+
+				}
+
+				vertexMap[ hash ].push( normal );
+
+			}
+
+		}
+
+		// average normals from all vertices that share a common location if they are within the
+		// provided crease threshold
+		const normalArray = new Float32Array( posAttr.count * 3 );
+		const normAttr = new THREE.BufferAttribute( normalArray, 3, false );
+		for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {
+
+			// get the face normal for this vertex
+			const i3 = 3 * i;
+			const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );
+			const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );
+			const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );
+			tempVec1.subVectors( c, b );
+			tempVec2.subVectors( a, b );
+			tempNorm.crossVectors( tempVec1, tempVec2 ).normalize();
+
+			// average all normals that meet the threshold and set the normal value
+			for ( let n = 0; n < 3; n ++ ) {
+
+				const vert = verts[ n ];
+				const hash = hashVertex( vert );
+				const otherNormals = vertexMap[ hash ];
+				tempNorm2.set( 0, 0, 0 );
+				for ( let k = 0, lk = otherNormals.length; k < lk; k ++ ) {
+
+					const otherNorm = otherNormals[ k ];
+					if ( tempNorm.dot( otherNorm ) > creaseDot ) {
+
+						tempNorm2.add( otherNorm );
+
+					}
+
+				}
+
+				tempNorm2.normalize();
+				normAttr.setXYZ( i3 + n, tempNorm2.x, tempNorm2.y, tempNorm2.z );
+
+			}
+
+		}
+
+		resultGeometry.setAttribute( 'normal', normAttr );
+		return resultGeometry;
+
+	}
+
 	THREE.BufferGeometryUtils = {};
 	THREE.BufferGeometryUtils.computeMikkTSpaceTangents = computeMikkTSpaceTangents;
 	THREE.BufferGeometryUtils.computeMorphedAttributes = computeMorphedAttributes;
 	THREE.BufferGeometryUtils.computeTangents = computeTangents;
+	THREE.BufferGeometryUtils.deepCloneAttribute = deepCloneAttribute;
 	THREE.BufferGeometryUtils.deinterleaveAttribute = deinterleaveAttribute;
 	THREE.BufferGeometryUtils.deinterleaveGeometry = deinterleaveGeometry;
 	THREE.BufferGeometryUtils.estimateBytesUsed = estimateBytesUsed;
@@ -1089,6 +1154,7 @@
 	THREE.BufferGeometryUtils.mergeBufferGeometries = mergeBufferGeometries;
 	THREE.BufferGeometryUtils.mergeGroups = mergeGroups;
 	THREE.BufferGeometryUtils.mergeVertices = mergeVertices;
+	THREE.BufferGeometryUtils.toCreasedNormals = toCreasedNormals;
 	THREE.BufferGeometryUtils.toTrianglesDrawMode = toTrianglesDrawMode;
 
 } )();