@lampdotdev/lamp 0.0.0-stage → 0.36.2-nightly.16

package/Resources/WebLibraries/three/addons/misc/SculptorUtils.js

@@ -0,0 +1,345 @@
+/*!
+ * Portions adapted from SculptGL by Stéphane Ginier.
+ * Copyright (c) 2019 Stéphane GINIER
+ * Licensed under the MIT License; see ./SculptGL.LICENSE.txt.
+ */
+
+const TRI_INDEX = 4294967295;
+
+const MAX_FLAG = 0x7fffffff;
+
+let _memoryBuffer = new ArrayBuffer( 100000 );
+const _sortByIndex = ( a, b ) => a - b;
+
+function getMemory( byteLength ) {
+
+	if ( _memoryBuffer.byteLength < byteLength ) {
+
+		_memoryBuffer = new ArrayBuffer( Math.max( byteLength, _memoryBuffer.byteLength * 2 ) );
+
+	}
+
+	return _memoryBuffer;
+
+}
+
+function replaceElement( array, oldValue, newValue ) {
+
+	for ( let i = 0, l = array.length; i < l; ++ i ) {
+
+		if ( array[ i ] === oldValue ) {
+
+			array[ i ] = newValue;
+			return;
+
+		}
+
+	}
+
+}
+
+function removeElement( array, value ) {
+
+	for ( let i = 0, l = array.length; i < l; ++ i ) {
+
+		if ( array[ i ] === value ) {
+
+			array[ i ] = array[ l - 1 ];
+			array.pop();
+			return;
+
+		}
+
+	}
+
+}
+
+function tidy( array ) {
+
+	if ( array.length < 2 ) return;
+
+	array.sort( _sortByIndex );
+	let writeIndex = 1;
+
+	for ( let i = 1; i < array.length; i ++ ) {
+
+		if ( array[ writeIndex - 1 ] !== array[ i ] ) array[ writeIndex ++ ] = array[ i ];
+
+	}
+
+	array.length = writeIndex;
+
+}
+
+// Geometry helpers
+
+const _edge1 = [ 0, 0, 0 ];
+const _edge2 = [ 0, 0, 0 ];
+const _pvec = [ 0, 0, 0 ];
+const _tvec = [ 0, 0, 0 ];
+const _qvec = [ 0, 0, 0 ];
+const _scaledDir = [ 0, 0, 0 ];
+const RAY_EPSILON = 1e-15;
+
+function cross( out, a, b ) {
+
+	out[ 0 ] = a[ 1 ] * b[ 2 ] - a[ 2 ] * b[ 1 ];
+	out[ 1 ] = a[ 2 ] * b[ 0 ] - a[ 0 ] * b[ 2 ];
+	out[ 2 ] = a[ 0 ] * b[ 1 ] - a[ 1 ] * b[ 0 ];
+	return out;
+
+}
+
+function dot( a, b ) {
+
+	return a[ 0 ] * b[ 0 ] + a[ 1 ] * b[ 1 ] + a[ 2 ] * b[ 2 ];
+
+}
+
+function sub( out, a, b ) {
+
+	out[ 0 ] = a[ 0 ] - b[ 0 ];
+	out[ 1 ] = a[ 1 ] - b[ 1 ];
+	out[ 2 ] = a[ 2 ] - b[ 2 ];
+	return out;
+
+}
+
+function sqrDist( a, b ) {
+
+	const dx = a[ 0 ] - b[ 0 ], dy = a[ 1 ] - b[ 1 ], dz = a[ 2 ] - b[ 2 ];
+	return dx * dx + dy * dy + dz * dz;
+
+}
+
+function setRayIntersection( target, origin, direction, distance ) {
+
+	if ( ! target ) return;
+
+	target[ 0 ] = origin[ 0 ] + direction[ 0 ] * distance;
+	target[ 1 ] = origin[ 1 ] + direction[ 1 ] * distance;
+	target[ 2 ] = origin[ 2 ] + direction[ 2 ] * distance;
+
+}
+
+function intersectionRayTriangleScaled( orig, dir, v1, v2, v3, vertInter ) {
+
+	sub( _edge1, v2, v1 );
+	sub( _edge2, v3, v1 );
+
+	const edge1Scale = Math.max( Math.abs( _edge1[ 0 ] ), Math.abs( _edge1[ 1 ] ), Math.abs( _edge1[ 2 ] ) );
+	const edge2Scale = Math.max( Math.abs( _edge2[ 0 ] ), Math.abs( _edge2[ 1 ] ), Math.abs( _edge2[ 2 ] ) );
+	const dirScale = Math.max( Math.abs( dir[ 0 ] ), Math.abs( dir[ 1 ] ), Math.abs( dir[ 2 ] ) );
+
+	if ( edge1Scale === 0 || edge2Scale === 0 || dirScale === 0 ||
+		Number.isFinite( edge1Scale ) === false || Number.isFinite( edge2Scale ) === false || Number.isFinite( dirScale ) === false ) return - 1.0;
+
+	_edge1[ 0 ] /= edge1Scale; _edge1[ 1 ] /= edge1Scale; _edge1[ 2 ] /= edge1Scale;
+	_edge2[ 0 ] /= edge2Scale; _edge2[ 1 ] /= edge2Scale; _edge2[ 2 ] /= edge2Scale;
+	_scaledDir[ 0 ] = dir[ 0 ] / dirScale;
+	_scaledDir[ 1 ] = dir[ 1 ] / dirScale;
+	_scaledDir[ 2 ] = dir[ 2 ] / dirScale;
+
+	cross( _pvec, _scaledDir, _edge2 );
+	const det = dot( _edge1, _pvec );
+	const determinantScale = Math.hypot( _edge1[ 0 ], _edge1[ 1 ], _edge1[ 2 ] ) *
+		Math.hypot( _edge2[ 0 ], _edge2[ 1 ], _edge2[ 2 ] ) *
+		Math.hypot( _scaledDir[ 0 ], _scaledDir[ 1 ], _scaledDir[ 2 ] );
+
+	if ( Math.abs( det ) <= RAY_EPSILON * determinantScale ) return - 1.0;
+
+	const invDet = 1.0 / det;
+	sub( _tvec, orig, v1 );
+	const translationScale = Math.max( Math.abs( _tvec[ 0 ] ), Math.abs( _tvec[ 1 ] ), Math.abs( _tvec[ 2 ] ) );
+
+	if ( Number.isFinite( translationScale ) === false ) return - 1.0;
+
+	if ( translationScale !== 0 ) {
+
+		_tvec[ 0 ] /= translationScale; _tvec[ 1 ] /= translationScale; _tvec[ 2 ] /= translationScale;
+
+	}
+
+	const u = dot( _tvec, _pvec ) * invDet * translationScale / edge1Scale;
+	if ( u < - RAY_EPSILON || u > 1.0 + RAY_EPSILON ) return - 1.0;
+	cross( _qvec, _tvec, _edge1 );
+	const v = dot( _scaledDir, _qvec ) * invDet * translationScale / edge2Scale;
+	if ( v < - RAY_EPSILON || u + v > 1.0 + RAY_EPSILON ) return - 1.0;
+	const t = dot( _edge2, _qvec ) * invDet * translationScale / dirScale;
+	if ( t < - RAY_EPSILON ) return - 1.0;
+
+	setRayIntersection( vertInter, orig, dir, t );
+
+	return t;
+
+}
+
+function intersectionRayTriangle( orig, dir, v1, v2, v3, vertInter ) {
+
+	sub( _edge1, v2, v1 );
+	sub( _edge2, v3, v1 );
+	cross( _pvec, dir, _edge2 );
+	const det = dot( _edge1, _pvec );
+	const determinantScale = Math.hypot( _edge1[ 0 ], _edge1[ 1 ], _edge1[ 2 ] ) *
+		Math.hypot( _edge2[ 0 ], _edge2[ 1 ], _edge2[ 2 ] ) *
+		Math.hypot( dir[ 0 ], dir[ 1 ], dir[ 2 ] );
+	const determinantTolerance = RAY_EPSILON * determinantScale;
+	if ( Number.isFinite( det ) === false || Number.isFinite( determinantScale ) === false || determinantTolerance === 0 ) {
+
+		return intersectionRayTriangleScaled( orig, dir, v1, v2, v3, vertInter );
+
+	}
+
+	if ( Math.abs( det ) <= determinantTolerance ) return - 1.0;
+	const invDet = 1.0 / det;
+	sub( _tvec, orig, v1 );
+	const u = dot( _tvec, _pvec ) * invDet;
+	if ( Number.isFinite( u ) === false ) return intersectionRayTriangleScaled( orig, dir, v1, v2, v3, vertInter );
+	if ( u < - RAY_EPSILON || u > 1.0 + RAY_EPSILON ) return - 1.0;
+	cross( _qvec, _tvec, _edge1 );
+	const v = dot( dir, _qvec ) * invDet;
+	if ( Number.isFinite( v ) === false ) return intersectionRayTriangleScaled( orig, dir, v1, v2, v3, vertInter );
+	if ( v < - RAY_EPSILON || u + v > 1.0 + RAY_EPSILON ) return - 1.0;
+	const t = dot( _edge2, _qvec ) * invDet;
+	if ( Number.isFinite( t ) === false ) return intersectionRayTriangleScaled( orig, dir, v1, v2, v3, vertInter );
+	if ( t < - RAY_EPSILON ) return - 1.0;
+
+	setRayIntersection( vertInter, orig, dir, t );
+
+	return t;
+
+}
+
+function distanceSqToSegment( point, v1, v2 ) {
+
+	const ptx = point[ 0 ] - v1[ 0 ], pty = point[ 1 ] - v1[ 1 ], ptz = point[ 2 ] - v1[ 2 ];
+	const vx = v2[ 0 ] - v1[ 0 ], vy = v2[ 1 ] - v1[ 1 ], vz = v2[ 2 ] - v1[ 2 ];
+	const lengthSquared = vx * vx + vy * vy + vz * vz;
+	if ( lengthSquared === 0 ) return ptx * ptx + pty * pty + ptz * ptz;
+
+	const t = ( ptx * vx + pty * vy + ptz * vz ) / lengthSquared;
+	if ( t < 0 ) return ptx * ptx + pty * pty + ptz * ptz;
+	if ( t > 1 ) {
+
+		const dx = point[ 0 ] - v2[ 0 ], dy = point[ 1 ] - v2[ 1 ], dz = point[ 2 ] - v2[ 2 ];
+		return dx * dx + dy * dy + dz * dz;
+
+	}
+
+	const rx = point[ 0 ] - v1[ 0 ] - t * vx;
+	const ry = point[ 1 ] - v1[ 1 ] - t * vy;
+	const rz = point[ 2 ] - v1[ 2 ] - t * vz;
+	return rx * rx + ry * ry + rz * rz;
+
+}
+
+function distanceSqToTriangle( point, v1, v2, v3 ) {
+
+	const abx = v2[ 0 ] - v1[ 0 ], aby = v2[ 1 ] - v1[ 1 ], abz = v2[ 2 ] - v1[ 2 ];
+	const acx = v3[ 0 ] - v1[ 0 ], acy = v3[ 1 ] - v1[ 1 ], acz = v3[ 2 ] - v1[ 2 ];
+	const bcx = v3[ 0 ] - v2[ 0 ], bcy = v3[ 1 ] - v2[ 1 ], bcz = v3[ 2 ] - v2[ 2 ];
+	const crossX = aby * acz - abz * acy;
+	const crossY = abz * acx - abx * acz;
+	const crossZ = abx * acy - aby * acx;
+	const areaSquared = crossX * crossX + crossY * crossY + crossZ * crossZ;
+	const maxEdgeSquared = Math.max(
+		abx * abx + aby * aby + abz * abz,
+		acx * acx + acy * acy + acz * acz,
+		bcx * bcx + bcy * bcy + bcz * bcz
+	);
+
+	if ( areaSquared <= Number.EPSILON * maxEdgeSquared * maxEdgeSquared ) {
+
+		return Math.min(
+			distanceSqToSegment( point, v1, v2 ),
+			distanceSqToSegment( point, v2, v3 ),
+			distanceSqToSegment( point, v3, v1 )
+		);
+
+	}
+
+	const apx = point[ 0 ] - v1[ 0 ], apy = point[ 1 ] - v1[ 1 ], apz = point[ 2 ] - v1[ 2 ];
+	const d1 = abx * apx + aby * apy + abz * apz;
+	const d2 = acx * apx + acy * apy + acz * apz;
+
+	if ( d1 <= 0 && d2 <= 0 ) return apx * apx + apy * apy + apz * apz;
+
+	const bpx = point[ 0 ] - v2[ 0 ], bpy = point[ 1 ] - v2[ 1 ], bpz = point[ 2 ] - v2[ 2 ];
+	const d3 = abx * bpx + aby * bpy + abz * bpz;
+	const d4 = acx * bpx + acy * bpy + acz * bpz;
+
+	if ( d3 >= 0 && d4 <= d3 ) return bpx * bpx + bpy * bpy + bpz * bpz;
+
+	const vc = d1 * d4 - d3 * d2;
+
+	if ( vc <= 0 && d1 >= 0 && d3 <= 0 ) {
+
+		const v = d1 / ( d1 - d3 );
+		const dx = apx - abx * v, dy = apy - aby * v, dz = apz - abz * v;
+		return dx * dx + dy * dy + dz * dz;
+
+	}
+
+	const cpx = point[ 0 ] - v3[ 0 ], cpy = point[ 1 ] - v3[ 1 ], cpz = point[ 2 ] - v3[ 2 ];
+	const d5 = abx * cpx + aby * cpy + abz * cpz;
+	const d6 = acx * cpx + acy * cpy + acz * cpz;
+
+	if ( d6 >= 0 && d5 <= d6 ) return cpx * cpx + cpy * cpy + cpz * cpz;
+
+	const vb = d5 * d2 - d1 * d6;
+
+	if ( vb <= 0 && d2 >= 0 && d6 <= 0 ) {
+
+		const w = d2 / ( d2 - d6 );
+		const dx = apx - acx * w, dy = apy - acy * w, dz = apz - acz * w;
+		return dx * dx + dy * dy + dz * dz;
+
+	}
+
+	const va = d3 * d6 - d5 * d4;
+
+	if ( va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0 ) {
+
+		const edgeX = v3[ 0 ] - v2[ 0 ], edgeY = v3[ 1 ] - v2[ 1 ], edgeZ = v3[ 2 ] - v2[ 2 ];
+		const w = ( d4 - d3 ) / ( d4 - d3 + d5 - d6 );
+		const dx = bpx - edgeX * w, dy = bpy - edgeY * w, dz = bpz - edgeZ * w;
+		return dx * dx + dy * dy + dz * dz;
+
+	}
+
+	const denominator = va + vb + vc;
+	const inverse = 1.0 / denominator;
+	const v = vb * inverse;
+	const w = vc * inverse;
+	const dx = apx - abx * v - acx * w;
+	const dy = apy - aby * v - acy * w;
+	const dz = apz - abz * v - acz * w;
+	return dx * dx + dy * dy + dz * dz;
+
+}
+
+function triangleInsideSphere( point, radiusSquared, v1, v2, v3 ) {
+
+	return distanceSqToTriangle( point, v1, v2, v3 ) < radiusSquared;
+
+}
+
+function falloff( dist ) {
+
+	const d2 = dist * dist;
+	return 3.0 * d2 * d2 - 4.0 * d2 * dist + 1.0;
+
+}
+
+export {
+	TRI_INDEX,
+	MAX_FLAG,
+	getMemory,
+	replaceElement,
+	removeElement,
+	tidy,
+	sqrDist,
+	intersectionRayTriangle,
+	triangleInsideSphere,
+	falloff
+};

package/Resources/WebLibraries/three/addons/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 };