super-three 0.181.0 → 0.185.0

package/examples/jsm/materials/LDrawConditionalLineNodeMaterial.js

@@ -1,5 +1,5 @@
-import { Color } from 'three';
-import { attribute, cameraProjectionMatrix, dot, float, Fn, modelViewMatrix, modelViewProjection, NodeMaterial, normalize, positionGeometry, sign, uniform, varyingProperty, vec2, vec4 } from 'three/tsl';
+import { Color, NodeMaterial } from 'three/webgpu';
+import { attribute, cameraProjectionMatrix, dot, float, Fn, modelViewMatrix, modelViewProjection, normalize, positionGeometry, sign, uniform, varyingProperty, vec2, vec4 } from 'three/tsl';
 
 /**
  * A special line material for meshes loaded via {@link LDrawLoader}.

package/examples/jsm/materials/WoodNodeMaterial.js

@@ -297,7 +297,7 @@ const woodParams = {
 	teak: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.11, largeWarpScale: 0.32, largeGrainStretch: 0.24, smallWarpStrength: 0.059,
-		smallWarpScale: 2, fineWarpStrength: 0.006, fineWarpScale: 32.8, ringThickness: 1/34,
+		smallWarpScale: 2, fineWarpStrength: 0.006, fineWarpScale: 32.8, ringThickness: 1 / 34,
 		ringBias: 0.03, ringSizeVariance: 0.03, ringVarianceScale: 4.4, barkThickness: 0.3,
 		splotchScale: 0.2, splotchIntensity: 0.541, cellScale: 910, cellSize: 0.1,
 		darkGrainColor: '#0c0504', lightGrainColor: '#926c50'
@@ -305,7 +305,7 @@ const woodParams = {
 	walnut: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.07, largeWarpScale: 0.42, largeGrainStretch: 0.34, smallWarpStrength: 0.016,
-		smallWarpScale: 10.3, fineWarpStrength: 0.028, fineWarpScale: 12.7, ringThickness: 1/32,
+		smallWarpScale: 10.3, fineWarpStrength: 0.028, fineWarpScale: 12.7, ringThickness: 1 / 32,
 		ringBias: 0.08, ringSizeVariance: 0.03, ringVarianceScale: 5.5, barkThickness: 0.98,
 		splotchScale: 1.84, splotchIntensity: 0.97, cellScale: 710, cellSize: 0.31,
 		darkGrainColor: '#311e13', lightGrainColor: '#523424'
@@ -313,7 +313,7 @@ const woodParams = {
 	white_oak: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.23, largeWarpScale: 0.21, largeGrainStretch: 0.21, smallWarpStrength: 0.034,
-		smallWarpScale: 2.44, fineWarpStrength: 0.01, fineWarpScale: 14.3, ringThickness: 1/34,
+		smallWarpScale: 2.44, fineWarpStrength: 0.01, fineWarpScale: 14.3, ringThickness: 1 / 34,
 		ringBias: 0.82, ringSizeVariance: 0.16, ringVarianceScale: 1.4, barkThickness: 0.7,
 		splotchScale: 0.2, splotchIntensity: 0.541, cellScale: 800, cellSize: 0.28,
 		darkGrainColor: '#8b4c21', lightGrainColor: '#c57e43'
@@ -321,7 +321,7 @@ const woodParams = {
 	pine: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.23, largeWarpScale: 0.21, largeGrainStretch: 0.18, smallWarpStrength: 0.041,
-		smallWarpScale: 2.44, fineWarpStrength: 0.006, fineWarpScale: 23.2, ringThickness: 1/24,
+		smallWarpScale: 2.44, fineWarpStrength: 0.006, fineWarpScale: 23.2, ringThickness: 1 / 24,
 		ringBias: 0.1, ringSizeVariance: 0.07, ringVarianceScale: 5, barkThickness: 0.35,
 		splotchScale: 0.51, splotchIntensity: 3.32, cellScale: 1480, cellSize: 0.07,
 		darkGrainColor: '#c58355', lightGrainColor: '#d19d61'
@@ -329,7 +329,7 @@ const woodParams = {
 	poplar: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.43, largeWarpScale: 0.33, largeGrainStretch: 0.18, smallWarpStrength: 0.04,
-		smallWarpScale: 4.3, fineWarpStrength: 0.004, fineWarpScale: 33.6, ringThickness: 1/37,
+		smallWarpScale: 4.3, fineWarpStrength: 0.004, fineWarpScale: 33.6, ringThickness: 1 / 37,
 		ringBias: 0.07, ringSizeVariance: 0.03, ringVarianceScale: 3.8, barkThickness: 0.3,
 		splotchScale: 1.92, splotchIntensity: 0.71, cellScale: 830, cellSize: 0.04,
 		darkGrainColor: '#716347', lightGrainColor: '#998966'
@@ -337,7 +337,7 @@ const woodParams = {
 	maple: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.4, largeWarpScale: 0.38, largeGrainStretch: 0.25, smallWarpStrength: 0.067,
-		smallWarpScale: 2.5, fineWarpStrength: 0.005, fineWarpScale: 33.6, ringThickness: 1/35,
+		smallWarpScale: 2.5, fineWarpStrength: 0.005, fineWarpScale: 33.6, ringThickness: 1 / 35,
 		ringBias: 0.1, ringSizeVariance: 0.07, ringVarianceScale: 4.6, barkThickness: 0.61,
 		splotchScale: 0.46, splotchIntensity: 1.49, cellScale: 800, cellSize: 0.03,
 		darkGrainColor: '#b08969', lightGrainColor: '#bc9d7d'
@@ -345,7 +345,7 @@ const woodParams = {
 	red_oak: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.21, largeWarpScale: 0.24, largeGrainStretch: 0.25, smallWarpStrength: 0.044,
-		smallWarpScale: 2.54, fineWarpStrength: 0.01, fineWarpScale: 14.5, ringThickness: 1/34,
+		smallWarpScale: 2.54, fineWarpStrength: 0.01, fineWarpScale: 14.5, ringThickness: 1 / 34,
 		ringBias: 0.92, ringSizeVariance: 0.03, ringVarianceScale: 5.6, barkThickness: 1.01,
 		splotchScale: 0.28, splotchIntensity: 3.48, cellScale: 800, cellSize: 0.25,
 		darkGrainColor: '#af613b', lightGrainColor: '#e0a27a'
@@ -353,7 +353,7 @@ const woodParams = {
 	cherry: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.33, largeWarpScale: 0.11, largeGrainStretch: 0.33, smallWarpStrength: 0.024,
-		smallWarpScale: 2.48, fineWarpStrength: 0.01, fineWarpScale: 15.3, ringThickness: 1/36,
+		smallWarpScale: 2.48, fineWarpStrength: 0.01, fineWarpScale: 15.3, ringThickness: 1 / 36,
 		ringBias: 0.02, ringSizeVariance: 0.04, ringVarianceScale: 6.5, barkThickness: 0.09,
 		splotchScale: 1.27, splotchIntensity: 1.24, cellScale: 1530, cellSize: 0.15,
 		darkGrainColor: '#913f27', lightGrainColor: '#b45837'
@@ -361,7 +361,7 @@ const woodParams = {
 	cedar: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.11, largeWarpScale: 0.39, largeGrainStretch: 0.12, smallWarpStrength: 0.061,
-		smallWarpScale: 1.9, fineWarpStrength: 0.006, fineWarpScale: 4.8, ringThickness: 1/25,
+		smallWarpScale: 1.9, fineWarpStrength: 0.006, fineWarpScale: 4.8, ringThickness: 1 / 25,
 		ringBias: 0.01, ringSizeVariance: 0.07, ringVarianceScale: 6.7, barkThickness: 0.1,
 		splotchScale: 0.61, splotchIntensity: 2.54, cellScale: 630, cellSize: 0.19,
 		darkGrainColor: '#9a5b49', lightGrainColor: '#ae745e'
@@ -369,7 +369,7 @@ const woodParams = {
 	mahogany: {
 		transformationMatrix: new THREE.Matrix4().identity(),
 		centerSize: 1.25, largeWarpScale: 0.26, largeGrainStretch: 0.29, smallWarpStrength: 0.044,
-		smallWarpScale: 2.54, fineWarpStrength: 0.01, fineWarpScale: 15.3, ringThickness: 1/38,
+		smallWarpScale: 2.54, fineWarpStrength: 0.01, fineWarpScale: 15.3, ringThickness: 1 / 38,
 		ringBias: 0.01, ringSizeVariance: 0.33, ringVarianceScale: 1.2, barkThickness: 0.07,
 		splotchScale: 0.77, splotchIntensity: 1.39, cellScale: 1400, cellSize: 0.23,
 		darkGrainColor: '#501d12', lightGrainColor: '#6d3722'
@@ -433,7 +433,7 @@ uniforms.lightGrainColor = TSL.uniform( new THREE.Color( params.lightGrainColor
 uniforms.transformationMatrix = TSL.uniform( new THREE.Matrix4().copy( params.transformationMatrix ) ).onObjectUpdate( ( { material } ) => material.transformationMatrix );
 
 const colorNode = wood(
-	uniforms.transformationMatrix.mul( TSL.vec4(TSL.positionLocal, 1) ).xyz,
+	uniforms.transformationMatrix.mul( TSL.vec4( TSL.positionLocal, 1 ) ).xyz,
 	uniforms.centerSize,
 	uniforms.largeWarpScale,
 	uniforms.largeGrainStretch,

package/examples/jsm/math/Octree.js

@@ -17,8 +17,10 @@ const _point2 = new Vector3();
 const _plane = new Plane();
 const _line1 = new Line3();
 const _line2 = new Line3();
+const _box = new Box3();
 const _sphere = new Sphere();
 const _capsule = new Capsule();
+const _center = new Vector3();
 
 const _temp1 = new Vector3();
 const _temp2 = new Vector3();
@@ -373,6 +375,61 @@ class Octree {
 
 	}
 
+	/**
+	 * Computes the intersection between the given bounding box and triangle.
+	 *
+	 * @param {Box3} box - The bounding box to test.
+	 * @param {Triangle} triangle - The triangle to test.
+	 * @return {Object|false} The intersection object. If no intersection
+	 * is detected, the method returns `false`.
+	 */
+	triangleBoxIntersect( box, triangle ) {
+
+		// cheap check
+
+		if ( Math.max( triangle.a.x, triangle.b.x, triangle.c.x ) < box.min.x ||
+				Math.min( triangle.a.x, triangle.b.x, triangle.c.x ) > box.max.x ||
+				Math.max( triangle.a.y, triangle.b.y, triangle.c.y ) < box.min.y ||
+				Math.min( triangle.a.y, triangle.b.y, triangle.c.y ) > box.max.y ||
+				Math.max( triangle.a.z, triangle.b.z, triangle.c.z ) < box.min.z ||
+				Math.min( triangle.a.z, triangle.b.z, triangle.c.z ) > box.max.z ) {
+
+			return false;
+
+		}
+
+		// expensive check
+
+		if ( ! box.intersectsTriangle( triangle ) ) return false;
+
+		// there is an intersection, now compute collision data
+
+		triangle.getPlane( _plane );
+
+		// determine which corner of the box is "deepest" into the plane
+
+		_v1.x = ( _plane.normal.x > 0 ) ? box.min.x : box.max.x;
+		_v1.y = ( _plane.normal.y > 0 ) ? box.min.y : box.max.y;
+		_v1.z = ( _plane.normal.z > 0 ) ? box.min.z : box.max.z;
+
+		// Calculate the distance from the plane to that corner (the distance will be negative
+		// because of the intersection)
+
+		const distance = _plane.distanceToPoint( _v1 );
+
+		const intersection = {
+			depth: - distance, // Flip sign so depth is positive
+			normal: _plane.normal.clone(),
+			point: _v1.clone()
+		};
+
+		// project the point onto the triangle surface
+		intersection.point.addScaledVector( intersection.normal, distance );
+
+		return intersection;
+
+	}
+
 	/**
 	 * Computes the intersection between the given sphere and triangle.
 	 *
@@ -455,6 +512,38 @@ class Octree {
 
 	}
 
+	/**
+	 * Computes the triangles that potentially intersect with the given bounding box.
+	 *
+	 * @param {Box3} box - The bounding box.
+	 * @param {Array<Triangle>} triangles - The target array that holds the triangles.
+	 */
+	getBoxTriangles( box, triangles ) {
+
+		for ( let i = 0; i < this.subTrees.length; i ++ ) {
+
+			const subTree = this.subTrees[ i ];
+
+			if ( ! box.intersectsBox( subTree.box ) ) continue;
+
+			if ( subTree.triangles.length > 0 ) {
+
+				for ( let j = 0; j < subTree.triangles.length; j ++ ) {
+
+					if ( triangles.indexOf( subTree.triangles[ j ] ) === - 1 ) triangles.push( subTree.triangles[ j ] );
+
+				}
+
+			} else {
+
+				subTree.getBoxTriangles( box, triangles );
+
+			}
+
+		}
+
+	}
+
 	/**
 	 * Computes the triangles that potentially intersect with the given capsule.
 	 *
@@ -487,6 +576,47 @@ class Octree {
 
 	}
 
+	/**
+	 * Performs a bounding box intersection test with this Octree.
+	 *
+	 * @param {Box3} box - The bounding box to test.
+	 * @return {Object|boolean} The intersection object. If no intersection
+	 * is detected, the method returns `false`.
+	 */
+	boxIntersect( box ) {
+
+		_box.copy( box );
+
+		const triangles = [];
+		let result, hit = false;
+
+		this.getBoxTriangles( box, triangles );
+
+		for ( let i = 0; i < triangles.length; i ++ ) {
+
+			if ( result = this.triangleBoxIntersect( _box, triangles[ i ] ) ) {
+
+				hit = true;
+
+				_box.translate( result.normal.multiplyScalar( result.depth ) );
+
+			}
+
+		}
+
+		if ( hit ) {
+
+			const collisionVector = _box.getCenter( _center ).sub( box.getCenter( _v1 ) );
+			const depth = collisionVector.length();
+
+			return { normal: collisionVector.normalize(), depth: depth };
+
+		}
+
+		return false;
+
+	}
+
 	/**
 	 * Performs a bounding sphere intersection test with this Octree.
 	 *
@@ -558,7 +688,7 @@ class Octree {
 
 		if ( hit ) {
 
-			const collisionVector = _capsule.getCenter( new Vector3() ).sub( capsule.getCenter( _v1 ) );
+			const collisionVector = _capsule.getCenter( _center ).sub( capsule.getCenter( _v1 ) );
 			const depth = collisionVector.length();
 
 			return { normal: collisionVector.normalize(), depth: depth };

package/examples/jsm/misc/GPUComputationRenderer.js

@@ -339,6 +339,8 @@ class GPUComputationRenderer {
 
 				}
 
+				variable.material.dispose();
+
 			}
 
 		};

package/examples/jsm/misc/RollerCoaster.js

@@ -195,6 +195,10 @@ class RollerCoasterGeometry extends BufferGeometry {
 
 		const offset = new Vector3();
 
+		const sample1 = new Vector3();
+		const sample2 = new Vector3();
+		const rollQuaternion = new Quaternion();
+
 		for ( let i = 1; i <= divisions; i ++ ) {
 
 			point.copy( curve.getPointAt( i / divisions ) );
@@ -209,6 +213,20 @@ class RollerCoasterGeometry extends BufferGeometry {
 
 			quaternion.setFromAxisAngle( up, angle );
 
+			// banking
+
+			const bankDelta = 0.01;
+			const t = i / divisions;
+
+			sample1.copy( curve.getTangentAt( ( ( t - bankDelta ) % 1 + 1 ) % 1 ) );
+			sample2.copy( curve.getTangentAt( ( t + bankDelta ) % 1 ) );
+
+			let headingChange = Math.atan2( sample2.x, sample2.z ) - Math.atan2( sample1.x, sample1.z );
+			if ( headingChange > Math.PI ) headingChange -= Math.PI * 2;
+			if ( headingChange < -Math.PI ) headingChange += Math.PI * 2;
+
+			quaternion.premultiply( rollQuaternion.setFromAxisAngle( forward, - Math.atan( headingChange * 8 ) * 0.5 ) );
+
 			if ( i % 2 === 0 ) {
 
 				drawShape( step, color2 );
@@ -356,6 +374,11 @@ class RollerCoasterLiftersGeometry extends BufferGeometry {
 		const fromPoint = new Vector3();
 		const toPoint = new Vector3();
 
+		const sample1 = new Vector3();
+		const sample2 = new Vector3();
+		const bankedQuaternion = new Quaternion();
+		const rollQuaternion = new Quaternion();
+
 		for ( let i = 1; i <= divisions; i ++ ) {
 
 			point.copy( curve.getPointAt( i / divisions ) );
@@ -365,6 +388,22 @@ class RollerCoasterLiftersGeometry extends BufferGeometry {
 
 			quaternion.setFromAxisAngle( up, angle );
 
+			// banking
+
+			const bankDelta = 0.01;
+			const t = i / divisions;
+
+			sample1.copy( curve.getTangentAt( ( ( t - bankDelta ) % 1 + 1 ) % 1 ) );
+			sample2.copy( curve.getTangentAt( ( t + bankDelta ) % 1 ) );
+
+			let headingChange = Math.atan2( sample2.x, sample2.z ) - Math.atan2( sample1.x, sample1.z );
+			if ( headingChange > Math.PI ) headingChange -= Math.PI * 2;
+			if ( headingChange < -Math.PI ) headingChange += Math.PI * 2;
+
+			bankedQuaternion.copy( quaternion );
+			rollQuaternion.setFromAxisAngle( tangent, - Math.atan( headingChange * 8 ) * 0.5 );
+			bankedQuaternion.premultiply( rollQuaternion );
+
 			//
 
 			if ( point.y > 10 ) {
@@ -402,12 +441,11 @@ class RollerCoasterLiftersGeometry extends BufferGeometry {
 			} else {
 
 				fromPoint.set( 0, - 0.2, 0 );
-				fromPoint.applyQuaternion( quaternion );
+				fromPoint.applyQuaternion( bankedQuaternion );
 				fromPoint.add( point );
 
-				toPoint.set( 0, - point.y, 0 );
-				toPoint.applyQuaternion( quaternion );
-				toPoint.add( point );
+				toPoint.copy( fromPoint );
+				toPoint.y = 0;
 
 				extrudeShape( tube3, fromPoint, toPoint );
 

package/examples/jsm/misc/TileCreasedNormalsPlugin.js

@@ -0,0 +1,270 @@
+import { BufferAttribute } from 'three';
+
+/**
+ * A plugin for `3d-tiles-renderer` that computes creased vertex normals for the
+ * geometry of each loaded tile: smooth normals everywhere except where faces meet
+ * at an angle greater than the crease angle. Useful for photogrammetry tile sets
+ * like Google Photorealistic 3D Tiles which come without vertex normals.
+ *
+ * The normals are computed in a Web Worker so tile processing doesn't block the
+ * main thread. Tiles are displayed once their normals are ready.
+ *
+ * ```js
+ * tiles.registerPlugin( new TileCreasedNormalsPlugin( { creaseAngle: Math.PI / 6 } ) );
+ * ```
+ *
+ * @three_import import { TileCreasedNormalsPlugin } from 'three/addons/misc/TileCreasedNormalsPlugin.js';
+ */
+class TileCreasedNormalsPlugin {
+
+	/**
+	 * Constructs a new plugin.
+	 *
+	 * @param {Object} [options] - The configuration options.
+	 * @param {number} [options.creaseAngle=Math.PI/3] - The crease angle in radians.
+	 */
+	constructor( { creaseAngle = Math.PI / 3 } = {} ) {
+
+		/**
+		 * The crease angle in radians.
+		 *
+		 * @type {number}
+		 */
+		this.creaseAngle = creaseAngle;
+
+		this._requestId = 0;
+		this._pending = new Map();
+
+		const workerCode = `
+
+			${ computeCreasedNormals.toString() }
+
+			onmessage = ( { data } ) => {
+
+				const { id, positions, creaseAngle } = data;
+				const normals = computeCreasedNormals( positions, creaseAngle );
+				postMessage( { id, positions, normals }, [ positions.buffer, normals.buffer ] );
+
+			};
+
+		`;
+
+		this._worker = new Worker( URL.createObjectURL( new Blob( [ workerCode ] ) ) );
+		this._worker.onmessage = ( { data } ) => {
+
+			this._pending.get( data.id )( data );
+			this._pending.delete( data.id );
+
+		};
+
+	}
+
+	/**
+	 * Called by the tiles renderer for each loaded tile model. The tile is
+	 * displayed once the returned promise resolves.
+	 *
+	 * @param {Object3D} scene - The tile model.
+	 * @return {Promise} A promise that resolves when all geometries have creased normals.
+	 */
+	processTileModel( scene ) {
+
+		const promises = [];
+
+		scene.traverse( ( mesh ) => {
+
+			if ( mesh.geometry ) {
+
+				promises.push( this._processMesh( mesh ) );
+
+			}
+
+		} );
+
+		return Promise.all( promises );
+
+	}
+
+	_processMesh( mesh ) {
+
+		const geometry = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.geometry;
+		const positions = geometry.attributes.position.array;
+
+		const id = this._requestId ++;
+		this._worker.postMessage( { id, positions, creaseAngle: this.creaseAngle }, [ positions.buffer ] );
+
+		return new Promise( ( resolve ) => {
+
+			this._pending.set( id, ( { positions, normals } ) => {
+
+				geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+				geometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+				mesh.geometry = geometry;
+				resolve();
+
+			} );
+
+		} );
+
+	}
+
+	/**
+	 * Called by the tiles renderer when the plugin is unregistered or the
+	 * tiles renderer is disposed.
+	 */
+	dispose() {
+
+		this._worker.terminate();
+
+	}
+
+}
+
+// Computes creased normals for non-indexed triangle positions. The function is
+// self-contained so it can be serialized into the worker.
+function computeCreasedNormals( positions, creaseAngle ) {
+
+	const creaseDot = Math.cos( creaseAngle );
+	const hashMultiplier = ( 1 + 1e-10 ) * 1e2;
+
+	const vertexCount = positions.length / 3;
+	const faceCount = vertexCount / 3;
+
+	// compute the normal of each face
+	const faceNormals = new Float64Array( faceCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f9 = 9 * f;
+		const ax = positions[ f9 + 0 ], ay = positions[ f9 + 1 ], az = positions[ f9 + 2 ];
+		const bx = positions[ f9 + 3 ], by = positions[ f9 + 4 ], bz = positions[ f9 + 5 ];
+		const cx = positions[ f9 + 6 ], cy = positions[ f9 + 7 ], cz = positions[ f9 + 8 ];
+
+		const v1x = cx - bx, v1y = cy - by, v1z = cz - bz;
+		const v2x = ax - bx, v2y = ay - by, v2z = az - bz;
+
+		const nx = v1y * v2z - v1z * v2y;
+		const ny = v1z * v2x - v1x * v2z;
+		const nz = v1x * v2y - v1y * v2x;
+
+		const invLength = 1 / ( Math.sqrt( nx * nx + ny * ny + nz * nz ) || 1 );
+		faceNormals[ 3 * f + 0 ] = nx * invLength;
+		faceNormals[ 3 * f + 1 ] = ny * invLength;
+		faceNormals[ 3 * f + 2 ] = nz * invLength;
+
+	}
+
+	// assign an id to each vertex, sharing the id between vertices with the same
+	// quantized position via an open-addressed hash table (slots hold id + 1, 0 means empty)
+	const vertexIds = new Int32Array( vertexCount );
+	const quantized = new Int32Array( vertexCount * 3 );
+
+	let tableSize = 1;
+	while ( tableSize < vertexCount * 2 ) tableSize <<= 1;
+	const tableMask = tableSize - 1;
+	const table = new Int32Array( tableSize );
+
+	let uniqueCount = 0;
+	for ( let i = 0; i < vertexCount; i ++ ) {
+
+		const i3 = 3 * i;
+		const qx = ~ ~ ( positions[ i3 + 0 ] * hashMultiplier );
+		const qy = ~ ~ ( positions[ i3 + 1 ] * hashMultiplier );
+		const qz = ~ ~ ( positions[ i3 + 2 ] * hashMultiplier );
+
+		let slot = ( Math.imul( qx, 73856093 ) ^ Math.imul( qy, 19349663 ) ^ Math.imul( qz, 83492791 ) ) & tableMask;
+
+		while ( true ) {
+
+			const id = table[ slot ];
+
+			if ( id === 0 ) {
+
+				const q3 = 3 * uniqueCount;
+				quantized[ q3 + 0 ] = qx;
+				quantized[ q3 + 1 ] = qy;
+				quantized[ q3 + 2 ] = qz;
+
+				table[ slot ] = uniqueCount + 1;
+				vertexIds[ i ] = uniqueCount ++;
+				break;
+
+			}
+
+			const q3 = 3 * ( id - 1 );
+
+			if ( quantized[ q3 + 0 ] === qx && quantized[ q3 + 1 ] === qy && quantized[ q3 + 2 ] === qz ) {
+
+				vertexIds[ i ] = id - 1;
+				break;
+
+			}
+
+			slot = ( slot + 1 ) & tableMask;
+
+		}
+
+	}
+
+	// bucket the faces surrounding each unique vertex position
+	const bucketOffsets = new Int32Array( uniqueCount + 1 );
+	for ( let i = 0; i < vertexCount; i ++ ) bucketOffsets[ vertexIds[ i ] + 1 ] ++;
+	for ( let i = 0; i < uniqueCount; i ++ ) bucketOffsets[ i + 1 ] += bucketOffsets[ i ];
+
+	const bucketFaces = new Int32Array( vertexCount );
+	const bucketCursors = bucketOffsets.slice( 0, uniqueCount );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f3 = 3 * f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 0 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 1 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 2 ] ] ++ ] = f;
+
+	}
+
+	// average the normals of the faces surrounding each vertex if they are within the
+	// provided crease threshold
+	const normalArray = new Float32Array( vertexCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f3 = 3 * f;
+		const nx = faceNormals[ f3 + 0 ];
+		const ny = faceNormals[ f3 + 1 ];
+		const nz = faceNormals[ f3 + 2 ];
+
+		for ( let n = 0; n < 3; n ++ ) {
+
+			const i = f3 + n;
+			const id = vertexIds[ i ];
+
+			let sumX = 0, sumY = 0, sumZ = 0;
+
+			for ( let k = bucketOffsets[ id ], end = bucketOffsets[ id + 1 ]; k < end; k ++ ) {
+
+				const o3 = 3 * bucketFaces[ k ];
+				const ox = faceNormals[ o3 + 0 ];
+				const oy = faceNormals[ o3 + 1 ];
+				const oz = faceNormals[ o3 + 2 ];
+
+				if ( nx * ox + ny * oy + nz * oz > creaseDot ) {
+
+					sumX += ox;
+					sumY += oy;
+					sumZ += oz;
+
+				}
+
+			}
+
+			const invLength = 1 / ( Math.sqrt( sumX * sumX + sumY * sumY + sumZ * sumZ ) || 1 );
+			normalArray[ 3 * i + 0 ] = sumX * invLength;
+			normalArray[ 3 * i + 1 ] = sumY * invLength;
+			normalArray[ 3 * i + 2 ] = sumZ * invLength;
+
+		}
+
+	}
+
+	return normalArray;
+
+}
+
+export { TileCreasedNormalsPlugin };

package/examples/jsm/misc/Volume.js

@@ -122,8 +122,7 @@ class Volume {
 				case 'unsigned long long int' :
 				case 'uint64' :
 				case 'uint64_t' :
-					throw new Error( 'Error in Volume constructor : this type is not supported in JavaScript' );
-					break;
+					throw new Error( 'THREE.Volume: type is not supported in JavaScript.' );
 				case 'Float32' :
 				case 'float32' :
 				case 'float' :
@@ -141,7 +140,7 @@ class Volume {
 
 			if ( this.data.length !== this.xLength * this.yLength * this.zLength ) {
 
-				throw new Error( 'Error in Volume constructor, lengths are not matching arrayBuffer size' );
+				throw new Error( 'THREE.Volume: lengths are not matching arrayBuffer size.' );
 
 			}
 

package/examples/jsm/misc/VolumeSlice.js

@@ -54,7 +54,6 @@ class VolumeSlice {
 
 				index = value;
 				slice.geometryNeedsUpdate = true;
-				return index;
 
 			}
 		} );

package/examples/jsm/modifiers/TessellateModifier.js

@@ -46,7 +46,7 @@ class TessellateModifier {
 	}
 
 	/**
-	 * Returns a new, modified version of the given geometry by applying a tesselation.
+	 * Returns a new, modified version of the given geometry by applying a tessellation.
 	 * Please note that the resulting geometry is always non-indexed.
 	 *
 	 * @param {BufferGeometry} geometry - The geometry to modify.

package/examples/jsm/objects/GroundedSkybox.js

@@ -32,7 +32,7 @@ class GroundedSkybox extends Mesh {
 
 		if ( height <= 0 || radius <= 0 || resolution <= 0 ) {
 
-			throw new Error( 'GroundedSkybox height, radius, and resolution must be positive.' );
+			throw new Error( 'THREE.GroundedSkybox: height, radius, and resolution must be positive.' );
 
 		}
 

package/examples/jsm/objects/LensflareMesh.js

@@ -215,7 +215,7 @@ class LensflareMesh extends Mesh {
 
 			renderer.getViewport( viewport );
 
-			viewport.multiplyScalar( window.devicePixelRatio );
+			viewport.multiplyScalar( renderer.getPixelRatio() ).floor();
 
 			const renderTarget = renderer.getRenderTarget();
 			const type = ( renderTarget !== null ) ? renderTarget.texture.type : UnsignedByteType;