super-three 0.136.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/MMDToonShader.js

@@ -55,7 +55,6 @@ void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in Geometric
 	vec3 y = cross( viewDir, x );
 	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5; // 0.495 to remove artifacts caused by undersized matcap disks
 	vec4 matcapColor = texture2D( matcap, uv );
-	matcapColor = matcapTexelToLinear( matcapColor );
 
 	#ifdef MATCAP_BLENDING_MULTIPLY
 

package/examples/js/shaders/SSAOShader.js

@@ -155,7 +155,7 @@
 			vec3 viewNormal = getViewNormal( vUv );
 
 			vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );
-			vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;
+			vec3 random = vec3( texture2D( tNoise, vUv * noiseScale ).r );
 
 			// compute matrix used to reorient a kernel vector
 

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

@@ -0,0 +1,182 @@
+( function () {
+
+	class LDrawUtils {
+
+		static mergeObject( object ) {
+
+			// Merges geometries in object by materials and returns new object. Use on not indexed geometries.
+			// The object buffers reference the old object ones.
+			// Special treatment is done to the conditional lines generated by LDrawLoader.
+			function extractGroup( geometry, group, elementSize, isConditionalLine ) {
+
+				// Extracts a group from a geometry as a new geometry (with attribute buffers referencing original buffers)
+				const newGeometry = new THREE.BufferGeometry();
+				const originalPositions = geometry.getAttribute( 'position' ).array;
+				const originalNormals = elementSize === 3 ? geometry.getAttribute( 'normal' ).array : null;
+				const numVertsGroup = Math.min( group.count, Math.floor( originalPositions.length / 3 ) - group.start );
+				const vertStart = group.start * 3;
+				const vertEnd = ( group.start + numVertsGroup ) * 3;
+				const positions = originalPositions.subarray( vertStart, vertEnd );
+				const normals = originalNormals !== null ? originalNormals.subarray( vertStart, vertEnd ) : null;
+				newGeometry.setAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
+				if ( normals !== null ) newGeometry.setAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
+
+				if ( isConditionalLine ) {
+
+					const controlArray0 = geometry.getAttribute( 'control0' ).array.subarray( vertStart, vertEnd );
+					const controlArray1 = geometry.getAttribute( 'control1' ).array.subarray( vertStart, vertEnd );
+					const directionArray = geometry.getAttribute( 'direction' ).array.subarray( vertStart, vertEnd );
+					newGeometry.setAttribute( 'control0', new THREE.BufferAttribute( controlArray0, 3, false ) );
+					newGeometry.setAttribute( 'control1', new THREE.BufferAttribute( controlArray1, 3, false ) );
+					newGeometry.setAttribute( 'direction', new THREE.BufferAttribute( directionArray, 3, false ) );
+
+				}
+
+				return newGeometry;
+
+			}
+
+			function addGeometry( mat, geometry, geometries ) {
+
+				const geoms = geometries[ mat.uuid ];
+
+				if ( ! geoms ) {
+
+					geometries[ mat.uuid ] = {
+						mat: mat,
+						arr: [ geometry ]
+					};
+
+				} else {
+
+					geoms.arr.push( geometry );
+
+				}
+
+			}
+
+			function permuteAttribute( attribute, elemSize ) {
+
+				// Permutes first two vertices of each attribute element
+				if ( ! attribute ) return;
+				const verts = attribute.array;
+				const numVerts = Math.floor( verts.length / 3 );
+				let offset = 0;
+
+				for ( let i = 0; i < numVerts; i ++ ) {
+
+					const x = verts[ offset ];
+					const y = verts[ offset + 1 ];
+					const z = verts[ offset + 2 ];
+					verts[ offset ] = verts[ offset + 3 ];
+					verts[ offset + 1 ] = verts[ offset + 4 ];
+					verts[ offset + 2 ] = verts[ offset + 5 ];
+					verts[ offset + 3 ] = x;
+					verts[ offset + 4 ] = y;
+					verts[ offset + 5 ] = z;
+					offset += elemSize * 3;
+
+				}
+
+			} // Traverse the object hierarchy collecting geometries and transforming them to world space
+
+
+			const meshGeometries = {};
+			const linesGeometries = {};
+			const condLinesGeometries = {};
+			object.updateMatrixWorld( true );
+			const normalMatrix = new THREE.Matrix3();
+			object.traverse( c => {
+
+				if ( c.isMesh | c.isLineSegments ) {
+
+					const elemSize = c.isMesh ? 3 : 2;
+					const geometry = c.geometry.clone();
+					const matrixIsInverted = c.matrixWorld.determinant() < 0;
+
+					if ( matrixIsInverted ) {
+
+						permuteAttribute( geometry.attributes.position, elemSize );
+						permuteAttribute( geometry.attributes.normal, elemSize );
+
+					}
+
+					geometry.applyMatrix4( c.matrixWorld );
+
+					if ( c.isConditionalLine ) {
+
+						geometry.attributes.control0.applyMatrix4( c.matrixWorld );
+						geometry.attributes.control1.applyMatrix4( c.matrixWorld );
+						normalMatrix.getNormalMatrix( c.matrixWorld );
+						geometry.attributes.direction.applyNormalMatrix( normalMatrix );
+
+					}
+
+					const geometries = c.isMesh ? meshGeometries : c.isConditionalLine ? condLinesGeometries : linesGeometries;
+
+					if ( Array.isArray( c.material ) ) {
+
+						for ( const groupIndex in geometry.groups ) {
+
+							const group = geometry.groups[ groupIndex ];
+							const mat = c.material[ group.materialIndex ];
+							const newGeometry = extractGroup( geometry, group, elemSize, c.isConditionalLine );
+							addGeometry( mat, newGeometry, geometries );
+
+						}
+
+					} else {
+
+						addGeometry( c.material, geometry, geometries );
+
+					}
+
+				}
+
+			} ); // Create object with merged geometries
+
+			const mergedObject = new THREE.Group();
+			const meshMaterialsIds = Object.keys( meshGeometries );
+
+			for ( const meshMaterialsId of meshMaterialsIds ) {
+
+				const meshGeometry = meshGeometries[ meshMaterialsId ];
+				const mergedGeometry = THREE.mergeBufferGeometries( meshGeometry.arr );
+				mergedObject.add( new THREE.Mesh( mergedGeometry, meshGeometry.mat ) );
+
+			}
+
+			const linesMaterialsIds = Object.keys( linesGeometries );
+
+			for ( const linesMaterialsId of linesMaterialsIds ) {
+
+				const lineGeometry = linesGeometries[ linesMaterialsId ];
+				const mergedGeometry = THREE.mergeBufferGeometries( lineGeometry.arr );
+				mergedObject.add( new THREE.LineSegments( mergedGeometry, lineGeometry.mat ) );
+
+			}
+
+			const condLinesMaterialsIds = Object.keys( condLinesGeometries );
+
+			for ( const condLinesMaterialsId of condLinesMaterialsIds ) {
+
+				const condLineGeometry = condLinesGeometries[ condLinesMaterialsId ];
+				const mergedGeometry = THREE.mergeBufferGeometries( condLineGeometry.arr );
+				const condLines = new THREE.LineSegments( mergedGeometry, condLineGeometry.mat );
+				condLines.isConditionalLine = true;
+				mergedObject.add( condLines );
+
+			}
+
+			mergedObject.userData.constructionStep = 0;
+			mergedObject.userData.numConstructionSteps = 1;
+			return mergedObject;
+
+		}
+
+	}
+
+	THREE.LDrawUtils = {};
+	THREE.LDrawUtils.LDrawUtils = LDrawUtils;
+
+} )();