easy-three-utils 0.0.1

package/src/tileRenderer/three/math/GeoUtils.js

@@ -0,0 +1,106 @@
+import { Spherical, Vector3, MathUtils } from 'three';
+
+const _spherical = new Spherical();
+const _vec = new Vector3();
+const _geoResults = {};
+
+// Cesium / 3D tiles Spheroid:
+// - Up is Z at 90 degrees latitude
+// - 0, 0 latitude, longitude is X axis
+//      Z
+//      |
+//      |
+//      .----- Y
+//     /
+//   X
+
+
+// Three.js Spherical Coordinates
+// - Up is Y at 90 degrees latitude
+// - 0, 0 latitude, longitude is Z
+//       Y
+//      |
+//      |
+//      .----- X
+//     /
+//   Z
+
+export function swapToGeoFrame( target ) {
+
+	const { x, y, z } = target;
+	target.x = z;
+	target.y = x;
+	target.z = y;
+
+}
+
+export function swapToThreeFrame( target ) {
+
+	const { x, y, z } = target;
+	target.z = x;
+	target.x = y;
+	target.y = z;
+
+}
+
+export function sphericalPhiToLatitude( phi ) {
+
+	return - ( phi - Math.PI / 2 );
+
+}
+
+export function latitudeToSphericalPhi( latitude ) {
+
+	return - latitude + Math.PI / 2;
+
+}
+
+function correctGeoCoordWrap( lat, lon, target = {} ) {
+
+	_spherical.theta = lon;
+	_spherical.phi = latitudeToSphericalPhi( lat );
+	_vec.setFromSpherical( _spherical );
+
+	_spherical.setFromVector3( _vec );
+	target.lat = sphericalPhiToLatitude( _spherical.phi );
+	target.lon = _spherical.theta;
+	return target;
+
+}
+
+function toHoursMinutesSecondsString( value, pos = 'E', neg = 'W' ) {
+
+	const direction = value < 0 ? neg : pos;
+	value = Math.abs( value );
+
+	const hours = ~ ~ value;
+
+	const minDec = ( value - hours ) * 60;
+	const minutes = ~ ~ minDec;
+
+	const secDec = ( minDec - minutes ) * 60;
+	const seconds = ~ ~ secDec;
+
+	return `${ hours }° ${ minutes }' ${ seconds }" ${ direction }`;
+
+}
+
+export function toLatLonString( lat, lon, decimalFormat = false ) {
+
+	const result = correctGeoCoordWrap( lat, lon, _geoResults );
+	let latString, lonString;
+	if ( decimalFormat ) {
+
+		latString = `${ ( MathUtils.RAD2DEG * result.lat ).toFixed( 4 ) }°`;
+		lonString = `${ ( MathUtils.RAD2DEG * result.lon ).toFixed( 4 ) }°`;
+
+	} else {
+
+		latString = toHoursMinutesSecondsString( MathUtils.RAD2DEG * result.lat, 'N', 'S' );
+		lonString = toHoursMinutesSecondsString( MathUtils.RAD2DEG * result.lon, 'E', 'W' );
+
+	}
+
+	return `${ latString } ${ lonString }`;
+
+}

package/src/tileRenderer/three/math/OBB.js

@@ -0,0 +1,179 @@
+import { Matrix4, Box3, Vector3, Plane, Ray } from 'three';
+
+const _worldMin = new Vector3();
+const _worldMax = new Vector3();
+const _norm = new Vector3();
+const _ray = new Ray();
+
+export class OBB {
+
+	constructor( box = new Box3(), transform = new Matrix4() ) {
+
+		this.box = box.clone();
+		this.transform = transform.clone();
+		this.inverseTransform = new Matrix4();
+		this.points = new Array( 8 ).fill().map( () => new Vector3() );
+		this.planes = new Array( 6 ).fill().map( () => new Plane() );
+
+	}
+
+	/**
+	 * Clamps the given point within the bounds of this OBB
+	 * @param {Vector3} point
+	 * @param {Vector3} result
+	 * @returns {Vector3}
+	 */
+	clampPoint( point, result ) {
+
+		return result.copy( point )
+			.applyMatrix4( this.inverseTransform )
+			.clamp( this.box.min, this.box.max )
+			.applyMatrix4( this.transform );
+
+	}
+
+	/**
+	 * Returns the distance from any edge of this OBB to the specified point.
+	 * If the point lies inside of this box, the distance will be 0.
+	 * @param {Vector3} point
+	 * @returns {number}
+	 */
+	distanceToPoint( point ) {
+
+		return this.clampPoint( point, _norm ).distanceTo( point );
+
+	}
+
+	containsPoint( point ) {
+
+		_norm.copy( point ).applyMatrix4( this.inverseTransform );
+		return this.box.containsPoint( _norm );
+
+	}
+
+	// returns boolean indicating whether the ray has intersected the obb
+	intersectsRay( ray ) {
+
+		_ray.copy( ray ).applyMatrix4( this.inverseTransform );
+		return _ray.intersectsBox( this.box );
+
+	}
+
+	// Sets "target" equal to the intersection point.
+	// Returns "null" if no intersection found.
+	intersectRay( ray, target ) {
+
+		_ray.copy( ray ).applyMatrix4( this.inverseTransform );
+		if ( _ray.intersectBox( this.box, target ) ) {
+
+			target.applyMatrix4( this.transform );
+			return target;
+
+		} else {
+
+			return null;
+
+		}
+
+	}
+
+	update() {
+
+		const { points, inverseTransform, transform, box } = this;
+		inverseTransform.copy( transform ).invert();
+
+		const { min, max } = box;
+		let index = 0;
+		for ( let x = - 1; x <= 1; x += 2 ) {
+
+			for ( let y = - 1; y <= 1; y += 2 ) {
+
+				for ( let z = - 1; z <= 1; z += 2 ) {
+
+					points[ index ].set(
+						x < 0 ? min.x : max.x,
+						y < 0 ? min.y : max.y,
+						z < 0 ? min.z : max.z,
+					).applyMatrix4( transform );
+					index ++;
+
+				}
+
+			}
+
+		}
+
+		this.updatePlanes();
+
+	}
+
+	updatePlanes() {
+
+		_worldMin.copy( this.box.min ).applyMatrix4( this.transform );
+		_worldMax.copy( this.box.max ).applyMatrix4( this.transform );
+
+		_norm.set( 0, 0, 1 ).transformDirection( this.transform );
+		this.planes[ 0 ].setFromNormalAndCoplanarPoint( _norm, _worldMin );
+		this.planes[ 1 ].setFromNormalAndCoplanarPoint( _norm, _worldMax ).negate();
+
+		_norm.set( 0, 1, 0 ).transformDirection( this.transform );
+		this.planes[ 2 ].setFromNormalAndCoplanarPoint( _norm, _worldMin );
+		this.planes[ 3 ].setFromNormalAndCoplanarPoint( _norm, _worldMax ).negate();
+
+		_norm.set( 1, 0, 0 ).transformDirection( this.transform );
+		this.planes[ 4 ].setFromNormalAndCoplanarPoint( _norm, _worldMin );
+		this.planes[ 5 ].setFromNormalAndCoplanarPoint( _norm, _worldMax ).negate();
+
+	}
+
+	// based on three.js' Box3 "intersects frustum" function
+	intersectsFrustum( frustum ) {
+
+		const { points } = this;
+		const { planes } = frustum;
+		for ( let i = 0; i < 6; i ++ ) {
+
+			const plane = planes[ i ];
+			let maxDistance = - Infinity;
+			for ( let j = 0; j < 8; j ++ ) {
+
+				const v = points[ j ];
+				const dist = plane.distanceToPoint( v );
+				maxDistance = maxDistance < dist ? dist : maxDistance;
+
+			}
+
+			if ( maxDistance < 0 ) {
+
+				return false;
+
+			}
+
+		}
+
+		// do the opposite check using the obb planes to avoid false positives
+		for ( let i = 0; i < 6; i ++ ) {
+
+			const plane = this.planes[ i ];
+			let maxDistance = - Infinity;
+			for ( let j = 0; j < 8; j ++ ) {
+
+				const v = frustum.points[ j ];
+				const dist = plane.distanceToPoint( v );
+				maxDistance = maxDistance < dist ? dist : maxDistance;
+
+			}
+
+			if ( maxDistance < 0 ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+}

package/src/tileRenderer/three/math/TileBoundingVolume.js

@@ -0,0 +1,272 @@
+import { Vector3, Sphere } from 'three';
+import { OBB } from './OBB.js';
+import { EllipsoidRegion } from './EllipsoidRegion.js';
+
+const _vecX = new Vector3();
+const _vecY = new Vector3();
+const _vecZ = new Vector3();
+const _sphereVec = new Vector3();
+const _obbVec = new Vector3();
+
+// TODO: check region more precisely in all functions
+export class TileBoundingVolume {
+
+	constructor() {
+
+		this.sphere = null;
+		this.obb = null;
+		this.region = null;
+
+		this.regionObb = null;
+
+	}
+
+	intersectsRay( ray ) {
+
+		const sphere = this.sphere;
+		const obb = this.obb || this.regionObb;
+
+		// Early out if we don't hit this tile sphere
+		if ( sphere && ! ray.intersectsSphere( sphere ) ) {
+
+			return false;
+
+		}
+
+		// Early out if we don't this this tile box
+		if ( obb && ! obb.intersectsRay( ray ) ) {
+
+			return false;
+
+		}
+
+		return true;
+
+	}
+
+	intersectRay( ray, target = null ) {
+
+		const sphere = this.sphere;
+		const obb = this.obb || this.regionObb;
+
+		let sphereDistSq = - Infinity;
+		let obbDistSq = - Infinity;
+
+		if ( sphere ) {
+
+			if ( ray.intersectSphere( sphere, _sphereVec ) ) {
+
+				sphereDistSq = sphere.containsPoint( ray.origin ) ? 0 : ray.origin.distanceToSquared( _sphereVec );
+
+			}
+
+		}
+
+		if ( obb ) {
+
+			if ( obb.intersectRay( ray, _obbVec ) ) {
+
+				obbDistSq = obb.containsPoint( ray.origin ) ? 0 : ray.origin.distanceToSquared( _obbVec );
+
+			}
+
+		}
+
+		// if we didn't hit anything then exit
+		const furthestDist = Math.max( sphereDistSq, obbDistSq );
+		if ( furthestDist === - Infinity ) {
+
+			return null;
+
+		}
+
+		// get the furthest hit point if needed
+		ray.at( Math.sqrt( furthestDist ), target );
+		return target;
+
+	}
+
+	distanceToPoint( point ) {
+
+		const sphere = this.sphere;
+		const obb = this.obb || this.regionObb;
+
+		let sphereDistance = - Infinity;
+		let obbDistance = - Infinity;
+
+		if ( sphere ) {
+
+			// Sphere#distanceToPoint is negative inside the sphere, whereas Box3#distanceToPoint is
+			// zero inside the box. Clipping the distance to a minimum of zero ensures that both
+			// types of bounding volume behave the same way.
+			sphereDistance = Math.max( sphere.distanceToPoint( point ), 0 );
+
+		}
+
+		if ( obb ) {
+
+			obbDistance = obb.distanceToPoint( point );
+
+		}
+
+		// return the further distance of the two volumes
+		return sphereDistance > obbDistance ? sphereDistance : obbDistance;
+
+	}
+
+	intersectsFrustum( frustum ) {
+
+		const obb = this.obb || this.regionObb;
+		const sphere = this.sphere;
+		if ( sphere && ! frustum.intersectsSphere( sphere ) ) {
+
+			return false;
+
+		}
+
+		if ( obb && ! obb.intersectsFrustum( frustum ) ) {
+
+			return false;
+
+		}
+
+		// if we don't have a sphere or obb then just say we did intersect
+		return Boolean( sphere || obb );
+
+	}
+
+	getOBB( targetBox, targetMatrix ) {
+
+		const obb = this.obb || this.regionObb;
+		if ( obb ) {
+
+			targetBox.copy( obb.box );
+			targetMatrix.copy( obb.transform );
+
+		} else {
+
+			this.getAABB( targetBox );
+			targetMatrix.identity();
+
+		}
+
+	}
+
+	getAABB( target ) {
+
+		if ( this.sphere ) {
+
+			this.sphere.getBoundingBox( target );
+
+		} else {
+
+			const obb = this.obb || this.regionObb;
+			target.copy( obb.box ).applyMatrix4( obb.transform );
+
+		}
+
+	}
+
+	getSphere( target ) {
+
+		if ( this.sphere ) {
+
+			target.copy( this.sphere );
+
+		} else if ( this.region ) {
+
+			this.region.getBoundingSphere( target );
+
+		} else {
+
+			const obb = this.obb || this.regionObb;
+			obb.box.getBoundingSphere( target );
+			target.applyMatrix4( obb.transform );
+
+		}
+
+	}
+
+	setObbData( data, transform ) {
+
+		const obb = new OBB();
+
+		// get the extents of the bounds in each axis
+		_vecX.set( data[ 3 ], data[ 4 ], data[ 5 ] );
+		_vecY.set( data[ 6 ], data[ 7 ], data[ 8 ] );
+		_vecZ.set( data[ 9 ], data[ 10 ], data[ 11 ] );
+
+		const scaleX = _vecX.length();
+		const scaleY = _vecY.length();
+		const scaleZ = _vecZ.length();
+
+		_vecX.normalize();
+		_vecY.normalize();
+		_vecZ.normalize();
+
+		// handle the case where the box has a dimension of 0 in one axis
+		if ( scaleX === 0 ) {
+
+			_vecX.crossVectors( _vecY, _vecZ );
+
+		}
+
+		if ( scaleY === 0 ) {
+
+			_vecY.crossVectors( _vecX, _vecZ );
+
+		}
+
+		if ( scaleZ === 0 ) {
+
+			_vecZ.crossVectors( _vecX, _vecY );
+
+		}
+
+		// create the oriented frame that the box exists in
+		obb.transform
+			.set(
+				_vecX.x, _vecY.x, _vecZ.x, data[ 0 ],
+				_vecX.y, _vecY.y, _vecZ.y, data[ 1 ],
+				_vecX.z, _vecY.z, _vecZ.z, data[ 2 ],
+				0, 0, 0, 1
+			)
+			.premultiply( transform );
+
+		// scale the box by the extents
+		obb.box.min.set( - scaleX, - scaleY, - scaleZ );
+		obb.box.max.set( scaleX, scaleY, scaleZ );
+		obb.update();
+		this.obb = obb;
+
+	}
+
+	setSphereData( x, y, z, radius, transform ) {
+
+		const sphere = new Sphere();
+		sphere.center.set( x, y, z );
+		sphere.radius = radius;
+		sphere.applyMatrix4( transform );
+		this.sphere = sphere;
+
+	}
+
+	setRegionData( ellipsoid, west, south, east, north, minHeight, maxHeight ) {
+
+		const region = new EllipsoidRegion(
+			...ellipsoid.radius,
+			south, north,
+			west, east,
+			minHeight, maxHeight,
+		);
+
+		const obb = new OBB();
+		region.getBoundingBox( obb.box, obb.transform );
+		obb.update();
+
+		this.region = region;
+		this.regionObb = obb;
+
+	}
+
+}

package/src/tileRenderer/three/plugins/CesiumIonAuthPlugin.js

@@ -0,0 +1,12 @@
+import { CesiumIonAuthPlugin as CesiumIonAuthPluginImpl } from '../../plugins/index.js';
+
+export class CesiumIonAuthPlugin extends CesiumIonAuthPluginImpl {
+
+	constructor( ...args ) {
+
+		super( ...args );
+		console.warn( 'CesiumIonAuthPlugin: Plugins should now be imported from "3d-tiles-renderer/plugins" path.' );
+
+	}
+
+}

package/src/tileRenderer/three/plugins/DebugTilesPlugin.js

@@ -0,0 +1,26 @@
+import { DebugTilesPlugin as DebugTilesPluginImpl } from '../../plugins/three/DebugTilesPlugin.js';
+
+export {
+	NONE,
+	SCREEN_ERROR,
+	GEOMETRIC_ERROR,
+	DISTANCE,
+	DEPTH,
+	RELATIVE_DEPTH,
+	IS_LEAF,
+	RANDOM_COLOR,
+	RANDOM_NODE_COLOR,
+	CUSTOM_COLOR,
+	LOAD_ORDER,
+} from '../../plugins/three/DebugTilesPlugin.js';
+
+export class DebugTilesPlugin extends DebugTilesPluginImpl {
+
+	constructor( ...args ) {
+
+		super( ...args );
+		console.warn( 'DebugTilesPlugin: Plugins should now be imported from "3d-tiles-renderer/plugins" path.' );
+
+	}
+
+}

package/src/tileRenderer/three/plugins/GoogleCloudAuthPlugin.js

@@ -0,0 +1,12 @@
+import { GoogleCloudAuthPlugin as GoogleCloudAuthPluginImpl } from '../../plugins/index.js';
+
+export class GoogleCloudAuthPlugin extends GoogleCloudAuthPluginImpl {
+
+	constructor( ...args ) {
+
+		super( ...args );
+		console.warn( 'GoogleCloudAuthPlugin: Plugins should now be imported from "3d-tiles-renderer/plugins" path.' );
+
+	}
+
+}