super-three 0.137.0 → 0.141.0

package/examples/js/shaders/FreiChenShader.js

@@ -7,7 +7,7 @@
  * aspect: vec2 of (1/width, 1/height)
  */
 
-	var FreiChenShader = {
+	const FreiChenShader = {
 		uniforms: {
 			'tDiffuse': {
 				value: null

package/examples/js/shaders/HorizontalBlurShader.js

@@ -8,7 +8,7 @@
  * - standard deviation 2.7
  * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
  */
-	var HorizontalBlurShader = {
+	const HorizontalBlurShader = {
 		uniforms: {
 			'tDiffuse': {
 				value: null

package/examples/js/shaders/HorizontalTiltShiftShader.js

@@ -8,7 +8,7 @@
  * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
  * - "r" parameter control where "focused" horizontal line lies
  */
-	var HorizontalTiltShiftShader = {
+	const HorizontalTiltShiftShader = {
 		uniforms: {
 			'tDiffuse': {
 				value: null

package/examples/js/shaders/SSRShader.js

@@ -5,7 +5,7 @@
  * https://lettier.github.io/3d-game-shaders-for-beginners/screen-space-reflection.html
  */
 
-	var SSRShader = {
+	const SSRShader = {
 		defines: {
 			MAX_STEP: 0,
 			PERSPECTIVE_CAMERA: true,
@@ -251,7 +251,7 @@
 		}
 	`
 	};
-	var SSRDepthShader = {
+	const SSRDepthShader = {
 		defines: {
 			'PERSPECTIVE_CAMERA': 1
 		},
@@ -320,7 +320,7 @@
 
 	`
 	};
-	var SSRBlurShader = {
+	const SSRBlurShader = {
 		uniforms: {
 			'tDiffuse': {
 				value: null

package/examples/js/shaders/ToneMapShader.js

@@ -3,7 +3,7 @@
 	/**
  * Full-screen tone-mapping shader based on http://www.cis.rit.edu/people/faculty/ferwerda/publications/sig02_paper.pdf
  */
-	var ToneMapShader = {
+	const ToneMapShader = {
 		uniforms: {
 			'tDiffuse': {
 				value: null

package/examples/js/utils/BufferGeometryUtils.js

@@ -1,16 +1,93 @@
 ( function () {
 
-	function computeTangents( geometry ) {
+	function computeTangents() {
 
-		geometry.computeTangents();
-		console.warn( 'THREE.BufferGeometryUtils: .computeTangents() has been removed. Use THREE.BufferGeometry.computeTangents() instead.' );
+		throw new Error( 'BufferGeometryUtils: computeTangents renamed to computeMikkTSpaceTangents.' );
+
+	}
+
+	function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {
+
+		if ( ! MikkTSpace || ! MikkTSpace.isReady ) {
+
+			throw new Error( 'BufferGeometryUtils: Initialized MikkTSpace library required.' );
+
+		}
+
+		if ( ! geometry.hasAttribute( 'position' ) || ! geometry.hasAttribute( 'normal' ) || ! geometry.hasAttribute( 'uv' ) ) {
+
+			throw new Error( 'BufferGeometryUtils: Tangents require "position", "normal", and "uv" attributes.' );
+
+		}
+
+		function getAttributeArray( attribute ) {
+
+			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 );
+
+					if ( attribute.itemSize > 2 ) {
+
+						dstArray[ j ++ ] = THREE.MathUtils.denormalize( attribute.getZ( i ), srcArray );
+
+					}
+
+				}
+
+				return dstArray;
+
+			}
+
+			if ( attribute.array instanceof Float32Array ) {
+
+				return attribute.array;
+
+			}
+
+			return new Float32Array( attribute.array );
+
+		} // MikkTSpace algorithm requires non-indexed input.
+
+
+		const _geometry = geometry.index ? geometry.toNonIndexed() : geometry; // Compute vertex tangents.
+
+
+		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
+		// default of the MikkTSpace library; .w component must be flipped.
+
+		if ( negateSign ) {
+
+			for ( let i = 3; i < tangents.length; i += 4 ) {
+
+				tangents[ i ] *= - 1;
+
+			}
+
+		} //
+
+
+		_geometry.setAttribute( 'tangent', new THREE.BufferAttribute( tangents, 4 ) );
+
+		if ( geometry !== _geometry ) {
+
+			geometry.copy( _geometry );
+
+		}
+
+		return geometry;
 
 	}
 	/**
-	 * @param  {Array<BufferGeometry>} geometries
-	 * @param  {Boolean} useGroups
-	 * @return {BufferGeometry}
-	 */
+ * @param  {Array<BufferGeometry>} geometries
+ * @param  {Boolean} useGroups
+ * @return {BufferGeometry}
+ */
 
 
 	function mergeBufferGeometries( geometries, useGroups = false ) {
@@ -318,13 +395,104 @@
 
 		return res;
 
+	} // returns a new, non-interleaved version of the provided attribute
+
+
+	function deinterleaveAttribute( attribute ) {
+
+		const cons = attribute.data.array.constructor;
+		const count = attribute.count;
+		const itemSize = attribute.itemSize;
+		const normalized = attribute.normalized;
+		const array = new cons( count * itemSize );
+		let newAttribute;
+
+		if ( attribute.isInstancedInterleavedBufferAttribute ) {
+
+			newAttribute = new InstancedBufferAttribute( array, itemSize, normalized, attribute.meshPerAttribute );
+
+		} else {
+
+			newAttribute = new THREE.BufferAttribute( array, itemSize, normalized );
+
+		}
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			newAttribute.setX( i, attribute.getX( i ) );
+
+			if ( itemSize >= 2 ) {
+
+				newAttribute.setY( i, attribute.getY( i ) );
+
+			}
+
+			if ( itemSize >= 3 ) {
+
+				newAttribute.setZ( i, attribute.getZ( i ) );
+
+			}
+
+			if ( itemSize >= 4 ) {
+
+				newAttribute.setW( i, attribute.getW( i ) );
+
+			}
+
+		}
+
+		return newAttribute;
+
+	} // 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 ) ) {
+
+					attrMap.set( attr, deinterleaveAttribute( attr ) );
+
+				}
+
+				attributes[ key ] = attrMap.get( attr );
+
+			}
+
+		}
+
+		for ( const key in morphTargets ) {
+
+			const attr = morphTargets[ key ];
+
+			if ( attr.isInterleavedBufferAttribute ) {
+
+				if ( ! attrMap.has( attr ) ) {
+
+					attrMap.set( attr, deinterleaveAttribute( attr ) );
+
+				}
+
+				morphTargets[ key ] = attrMap.get( attr );
+
+			}
+
+		}
+
 	}
 	/**
  * @param {Array<BufferGeometry>} geometry
  * @return {number}
  */
 
-
 	function estimateBytesUsed( geometry ) {
 
 		// Return the estimated memory used by this geometry in bytes
@@ -623,7 +791,7 @@
 
 		const _morphC = new THREE.Vector3();
 
-		function _calculateMorphedAttributeData( object, material, attribute, morphAttribute, morphTargetsRelative, a, b, c, modifiedAttributeArray ) {
+		function _calculateMorphedAttributeData( object, attribute, morphAttribute, morphTargetsRelative, a, b, c, modifiedAttributeArray ) {
 
 			_vA.fromBufferAttribute( attribute, a );
 
@@ -633,7 +801,7 @@
 
 			const morphInfluences = object.morphTargetInfluences;
 
-			if ( material.morphTargets && morphAttribute && morphInfluences ) {
+			if ( morphAttribute && morphInfluences ) {
 
 				_morphA.set( 0, 0, 0 );
 
@@ -713,7 +881,7 @@
 		const groups = geometry.groups;
 		const drawRange = geometry.drawRange;
 		let i, j, il, jl;
-		let group, groupMaterial;
+		let group;
 		let start, end;
 		const modifiedPosition = new Float32Array( positionAttribute.count * positionAttribute.itemSize );
 		const modifiedNormal = new Float32Array( normalAttribute.count * normalAttribute.itemSize );
@@ -726,7 +894,6 @@
 				for ( i = 0, il = groups.length; i < il; i ++ ) {
 
 					group = groups[ i ];
-					groupMaterial = material[ group.materialIndex ];
 					start = Math.max( group.start, drawRange.start );
 					end = Math.min( group.start + group.count, drawRange.start + drawRange.count );
 
@@ -736,9 +903,9 @@
 						b = index.getX( j + 1 );
 						c = index.getX( j + 2 );
 
-						_calculateMorphedAttributeData( object, groupMaterial, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
+						_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
 
-						_calculateMorphedAttributeData( object, groupMaterial, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
+						_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 					}
 
@@ -755,15 +922,15 @@
 					b = index.getX( i + 1 );
 					c = index.getX( i + 2 );
 
-					_calculateMorphedAttributeData( object, material, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
+					_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
 
-					_calculateMorphedAttributeData( object, material, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
+					_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 				}
 
 			}
 
-		} else if ( positionAttribute !== undefined ) {
+		} else {
 
 			// non-indexed buffer geometry
 			if ( Array.isArray( material ) ) {
@@ -771,7 +938,6 @@
 				for ( i = 0, il = groups.length; i < il; i ++ ) {
 
 					group = groups[ i ];
-					groupMaterial = material[ group.materialIndex ];
 					start = Math.max( group.start, drawRange.start );
 					end = Math.min( group.start + group.count, drawRange.start + drawRange.count );
 
@@ -781,9 +947,9 @@
 						b = j + 1;
 						c = j + 2;
 
-						_calculateMorphedAttributeData( object, groupMaterial, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
+						_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
 
-						_calculateMorphedAttributeData( object, groupMaterial, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
+						_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 					}
 
@@ -800,9 +966,9 @@
 					b = i + 1;
 					c = i + 2;
 
-					_calculateMorphedAttributeData( object, material, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
+					_calculateMorphedAttributeData( object, positionAttribute, morphPosition, morphTargetsRelative, a, b, c, modifiedPosition );
 
-					_calculateMorphedAttributeData( object, material, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
+					_calculateMorphedAttributeData( object, normalAttribute, morphNormal, morphTargetsRelative, a, b, c, modifiedNormal );
 
 				}
 
@@ -821,13 +987,107 @@
 
 	}
 
+	function mergeGroups( geometry ) {
+
+		if ( geometry.groups.length === 0 ) {
+
+			console.warn( 'THREE.BufferGeometryUtils.mergeGroups(): No groups are defined. Nothing to merge.' );
+			return geometry;
+
+		}
+
+		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
+
+		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 );
+
+			}
+
+			geometry.setIndex( indices );
+
+		} // 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 ) );
+
+			}
+
+		}
+
+		geometry.dispose(); // Required to force buffer recreation
+
+		geometry.setIndex( newIndices ); // 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
+
+
+		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;
+
+			} else {
+
+				currentGroup = group;
+				geometry.groups.push( currentGroup );
+
+			}
+
+		}
+
+		return geometry;
+
+	}
+
 	THREE.BufferGeometryUtils = {};
+	THREE.BufferGeometryUtils.computeMikkTSpaceTangents = computeMikkTSpaceTangents;
 	THREE.BufferGeometryUtils.computeMorphedAttributes = computeMorphedAttributes;
 	THREE.BufferGeometryUtils.computeTangents = computeTangents;
+	THREE.BufferGeometryUtils.deinterleaveAttribute = deinterleaveAttribute;
+	THREE.BufferGeometryUtils.deinterleaveGeometry = deinterleaveGeometry;
 	THREE.BufferGeometryUtils.estimateBytesUsed = estimateBytesUsed;
 	THREE.BufferGeometryUtils.interleaveAttributes = interleaveAttributes;
 	THREE.BufferGeometryUtils.mergeBufferAttributes = mergeBufferAttributes;
 	THREE.BufferGeometryUtils.mergeBufferGeometries = mergeBufferGeometries;
+	THREE.BufferGeometryUtils.mergeGroups = mergeGroups;
 	THREE.BufferGeometryUtils.mergeVertices = mergeVertices;
 	THREE.BufferGeometryUtils.toTrianglesDrawMode = toTrianglesDrawMode;
 

package/examples/js/utils/GPUStatsPanel.js

@@ -88,7 +88,7 @@
 
 						this.activeQueries --;
 
-					} else {
+					} else if ( gl.isContextLost() === false ) {
 
 						// otherwise try again the next frame
 						requestAnimationFrame( checkQuery );

package/examples/js/utils/LDrawUtils.js

@@ -138,9 +138,9 @@
 			const mergedObject = new THREE.Group();
 			const meshMaterialsIds = Object.keys( meshGeometries );
 
-			for ( const i in meshMaterialsIds ) {
+			for ( const meshMaterialsId of meshMaterialsIds ) {
 
-				const meshGeometry = meshGeometries[ meshMaterialsIds[ i ] ];
+				const meshGeometry = meshGeometries[ meshMaterialsId ];
 				const mergedGeometry = THREE.mergeBufferGeometries( meshGeometry.arr );
 				mergedObject.add( new THREE.Mesh( mergedGeometry, meshGeometry.mat ) );
 
@@ -148,9 +148,9 @@
 
 			const linesMaterialsIds = Object.keys( linesGeometries );
 
-			for ( const i in linesMaterialsIds ) {
+			for ( const linesMaterialsId of linesMaterialsIds ) {
 
-				const lineGeometry = linesGeometries[ linesMaterialsIds[ i ] ];
+				const lineGeometry = linesGeometries[ linesMaterialsId ];
 				const mergedGeometry = THREE.mergeBufferGeometries( lineGeometry.arr );
 				mergedObject.add( new THREE.LineSegments( mergedGeometry, lineGeometry.mat ) );
 
@@ -158,9 +158,9 @@
 
 			const condLinesMaterialsIds = Object.keys( condLinesGeometries );
 
-			for ( const i in condLinesMaterialsIds ) {
+			for ( const condLinesMaterialsId of condLinesMaterialsIds ) {
 
-				const condLineGeometry = condLinesGeometries[ condLinesMaterialsIds[ i ] ];
+				const condLineGeometry = condLinesGeometries[ condLinesMaterialsId ];
 				const mergedGeometry = THREE.mergeBufferGeometries( condLineGeometry.arr );
 				const condLines = new THREE.LineSegments( mergedGeometry, condLineGeometry.mat );
 				condLines.isConditionalLine = true;

package/examples/js/utils/SceneUtils.js

@@ -23,6 +23,64 @@
 
 	}
 
+	function createMeshesFromMultiMaterialMesh( mesh ) {
+
+		if ( Array.isArray( mesh.material ) === false ) {
+
+			console.warn( 'THREE.SceneUtils.createMeshesFromMultiMaterialMesh(): The given mesh has no multiple materials.' );
+			return mesh;
+
+		}
+
+		const object = new THREE.Group();
+		object.copy( mesh ); // merge groups (which automatically sorts them)
+
+		const geometry = THREE.mergeGroups( mesh.geometry );
+		const index = geometry.index;
+		const groups = geometry.groups;
+		const attributeNames = Object.keys( geometry.attributes ); // create a mesh for each group by extracting the buffer data into a new geometry
+
+		for ( let i = 0; i < groups.length; i ++ ) {
+
+			const group = groups[ i ];
+			const start = group.start;
+			const end = start + group.count;
+			const newGeometry = new THREE.BufferGeometry();
+			const newMaterial = mesh.material[ group.materialIndex ]; // process all buffer attributes
+
+			for ( let j = 0; j < attributeNames.length; j ++ ) {
+
+				const name = attributeNames[ j ];
+				const attribute = geometry.attributes[ name ];
+				const itemSize = attribute.itemSize;
+				const newLength = group.count * itemSize;
+				const type = attribute.array.constructor;
+				const newArray = new type( newLength );
+				const newAttribute = new THREE.BufferAttribute( newArray, itemSize );
+
+				for ( let k = start, n = 0; k < end; k ++, n ++ ) {
+
+					const ind = index.getX( k );
+					if ( itemSize >= 1 ) newAttribute.setX( n, attribute.getX( ind ) );
+					if ( itemSize >= 2 ) newAttribute.setY( n, attribute.getY( ind ) );
+					if ( itemSize >= 3 ) newAttribute.setZ( n, attribute.getZ( ind ) );
+					if ( itemSize >= 4 ) newAttribute.setW( n, attribute.getW( ind ) );
+
+				}
+
+				newGeometry.setAttribute( name, newAttribute );
+
+			}
+
+			const newMesh = new THREE.Mesh( newGeometry, newMaterial );
+			object.add( newMesh );
+
+		}
+
+		return object;
+
+	}
+
 	function createMultiMaterialObject( geometry, materials ) {
 
 		const group = new THREE.Group();
@@ -54,6 +112,7 @@
 	THREE.SceneUtils = {};
 	THREE.SceneUtils.attach = attach;
 	THREE.SceneUtils.createMeshesFromInstancedMesh = createMeshesFromInstancedMesh;
+	THREE.SceneUtils.createMeshesFromMultiMaterialMesh = createMeshesFromMultiMaterialMesh;
 	THREE.SceneUtils.createMultiMaterialObject = createMultiMaterialObject;
 	THREE.SceneUtils.detach = detach;
 

package/examples/js/utils/SkeletonUtils.js

@@ -64,7 +64,7 @@
 				bone = bones[ i ];
 				name = options.names[ bone.name ] || bone.name;
 
-				if ( options.offsets && options.offsets[ name ] ) {
+				if ( options.offsets[ name ] ) {
 
 					bone.matrix.multiply( options.offsets[ name ] );
 					bone.matrix.decompose( bone.position, bone.quaternion, bone.scale );

package/examples/js/utils/UVsDebug.js

@@ -29,46 +29,36 @@
 
 		ctx.fillStyle = 'rgb( 255, 255, 255 )';
 		ctx.fillRect( 0, 0, width, height );
+		const index = geometry.index;
+		const uvAttribute = geometry.attributes.uv;
 
-		if ( geometry.isGeometry ) {
+		if ( index ) {
 
-			console.error( 'THREE.UVsDebug no longer supports Geometry. Use THREE.BufferGeometry instead.' );
-			return;
+			// indexed geometry
+			for ( let i = 0, il = index.count; i < il; i += 3 ) {
 
-		} else {
-
-			const index = geometry.index;
-			const uvAttribute = geometry.attributes.uv;
-
-			if ( index ) {
-
-				// indexed geometry
-				for ( let i = 0, il = index.count; i < il; i += 3 ) {
-
-					face[ 0 ] = index.getX( i );
-					face[ 1 ] = index.getX( i + 1 );
-					face[ 2 ] = index.getX( i + 2 );
-					uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
-					uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
-					uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
-					processFace( face, uvs, i / 3 );
+				face[ 0 ] = index.getX( i );
+				face[ 1 ] = index.getX( i + 1 );
+				face[ 2 ] = index.getX( i + 2 );
+				uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
+				uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
+				uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
+				processFace( face, uvs, i / 3 );
 
-				}
-
-			} else {
+			}
 
-				// non-indexed geometry
-				for ( let i = 0, il = uvAttribute.count; i < il; i += 3 ) {
+		} else {
 
-					face[ 0 ] = i;
-					face[ 1 ] = i + 1;
-					face[ 2 ] = i + 2;
-					uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
-					uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
-					uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
-					processFace( face, uvs, i / 3 );
+			// non-indexed geometry
+			for ( let i = 0, il = uvAttribute.count; i < il; i += 3 ) {
 
-				}
+				face[ 0 ] = i;
+				face[ 1 ] = i + 1;
+				face[ 2 ] = i + 2;
+				uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
+				uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
+				uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
+				processFace( face, uvs, i / 3 );
 
 			}