easy-three-utils 0.0.1

package/src/tileRenderer/three/raycastTraverse.js

@@ -0,0 +1,178 @@
+import { Matrix4, Ray, Vector3, REVISION } from 'three';
+
+// In three.js r165 and higher raycast traversal can be ended early
+const REVISION_LESS_165 = parseInt( REVISION ) < 165;
+const _mat = new Matrix4();
+const _localRay = new Ray();
+const _vec = new Vector3();
+const _hitArray = [];
+
+function distanceSort( a, b ) {
+
+	return a.distance - b.distance;
+
+}
+
+function intersectTileScene( tile, raycaster, renderer, intersects ) {
+
+	const { scene } = tile.cached;
+	if ( REVISION_LESS_165 ) {
+
+		// Don't intersect the box3 helpers because those are used for debugging
+		scene.traverse( c => {
+
+			// We set the default raycast function to empty so three.js doesn't automatically cast against it
+			Object.getPrototypeOf( c ).raycast.call( c, raycaster, intersects );
+
+		} );
+
+	} else {
+
+		const didRaycast = renderer.invokeOnePlugin( plugin => plugin.raycastTile && plugin.raycastTile( tile, scene, raycaster, intersects ) );
+		if ( ! didRaycast ) {
+
+			raycaster.intersectObject( scene, true, intersects );
+
+		}
+
+	}
+
+}
+
+function intersectTileSceneFirstHist( tile, raycaster, renderer ) {
+
+	intersectTileScene( tile, raycaster, renderer, _hitArray );
+	_hitArray.sort( distanceSort );
+
+	const hit = _hitArray[ 0 ] || null;
+	_hitArray.length = 0;
+	return hit;
+
+}
+
+// Returns the closest hit when traversing the tree
+export function raycastTraverseFirstHit( renderer, tile, raycaster, localRay = null ) {
+
+	const { group, activeTiles } = renderer;
+	renderer.ensureChildrenArePreprocessed( tile );
+
+	// get the ray in the local group frame
+	if ( localRay === null ) {
+
+		localRay = _localRay;
+		_mat.copy( group.matrixWorld ).invert();
+		localRay.copy( raycaster.ray ).applyMatrix4( _mat );
+
+	}
+
+	// get a set of intersections so we intersect the nearest one first
+	const array = [];
+	const children = tile.children;
+	for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+		const child = children[ i ];
+		if ( ! child.__used ) {
+
+			continue;
+
+		}
+
+		// track the tile and hit distance for sorting
+		const boundingVolume = child.cached.boundingVolume;
+		if ( boundingVolume.intersectRay( localRay, _vec ) !== null ) {
+
+			_vec.applyMatrix4( group.matrixWorld );
+			array.push( {
+				distance: _vec.distanceToSquared( raycaster.ray.origin ),
+				tile: child,
+			} );
+
+		}
+
+	}
+
+	// sort them by ascending distance
+	array.sort( distanceSort );
+
+	// If the root is active make sure we've checked it
+	let bestHit = null;
+	let bestHitDistSq = Infinity;
+	if ( activeTiles.has( tile ) ) {
+
+		const hit = intersectTileSceneFirstHist( tile, raycaster, renderer );
+		if ( hit ) {
+
+			bestHit = hit;
+			bestHitDistSq = hit.distance * hit.distance;
+
+		}
+
+	}
+
+	// traverse until we find the best hit and early out if a tile bounds
+	// couldn't possible include a best hit
+	for ( let i = 0, l = array.length; i < l; i ++ ) {
+
+		const data = array[ i ];
+		const boundingVolumeDistSq = data.distance;
+		const tile = data.tile;
+		if ( boundingVolumeDistSq > bestHitDistSq ) {
+
+			break;
+
+		}
+
+		const hit = raycastTraverseFirstHit( renderer, tile, raycaster, localRay );
+		if ( hit ) {
+
+			const hitDistSq = hit.distance * hit.distance;
+			if ( hitDistSq < bestHitDistSq ) {
+
+				bestHit = hit;
+				bestHitDistSq = hitDistSq;
+
+			}
+
+		}
+
+	}
+
+	return bestHit;
+
+}
+
+export function raycastTraverse( renderer, tile, raycaster, intersects, localRay = null ) {
+
+	const { group, activeTiles } = renderer;
+	const { boundingVolume } = tile.cached;
+	renderer.ensureChildrenArePreprocessed( tile );
+
+	// get the ray in the local group frame
+	if ( localRay === null ) {
+
+		localRay = _localRay;
+		_mat.copy( group.matrixWorld ).invert();
+		localRay.copy( raycaster.ray ).applyMatrix4( _mat );
+
+	}
+
+	if ( ! tile.__used || ! boundingVolume.intersectsRay( localRay ) ) {
+
+		return;
+
+	}
+
+	if ( activeTiles.has( tile ) ) {
+
+		intersectTileScene( tile, raycaster, renderer, intersects );
+
+	}
+
+	const children = tile.children;
+	for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+		raycastTraverse( renderer, children[ i ], raycaster, intersects, localRay );
+
+	}
+
+}

package/src/tileRenderer/three/renderers/CesiumIonTilesRenderer.d.ts

@@ -0,0 +1,14 @@
+import { TilesRenderer } from '../TilesRenderer';
+import { DebugTilesRenderer } from '../DebugTilesRenderer';
+
+export class CesiumIonTilesRenderer extends TilesRenderer {
+
+	constructor( ionAssetId: String, ionAccessToken: String );
+
+}
+
+export class DebugCesiumIonTilesRenderer extends DebugTilesRenderer {
+
+	constructor( ionAssetId: String, ionAccessToken: String );
+
+}

package/src/tileRenderer/three/renderers/CesiumIonTilesRenderer.js

@@ -0,0 +1,21 @@
+import { TilesRenderer } from '../TilesRenderer.js';
+import { DebugTilesRenderer } from '../DebugTilesRenderer.js';
+import { CesiumIonAuthPlugin } from '../plugins/CesiumIonAuthPlugin.js';
+
+const CesiumIonTilesRendererMixin = base => class extends base {
+
+	constructor( ionAssetId, ionAccessToken ) {
+
+		super();
+
+		this.registerPlugin( new CesiumIonAuthPlugin( { apiToken: ionAccessToken, assetId: ionAssetId } ) );
+		console.warn( 'CesiumIonTilesRenderer: Class has been deprecated. Use "TilesRenderer" with "CesiumIonAuthPlugin" instead.' );
+
+	}
+
+};
+
+export const CesiumIonTilesRenderer = CesiumIonTilesRendererMixin( TilesRenderer );
+export const DebugCesiumIonTilesRenderer = CesiumIonTilesRendererMixin( DebugTilesRenderer );
+
+

package/src/tileRenderer/three/renderers/GoogleTilesRenderer.d.ts

@@ -0,0 +1,43 @@
+import { TilesRenderer } from '../TilesRenderer';
+import { DebugTilesRenderer } from '../DebugTilesRenderer';
+import { Ellipsoid } from '../math/Ellipsoid';
+
+export class GoogleTilesRenderer extends TilesRenderer {
+
+	ellipsoid: Ellipsoid;
+
+	constructor( apiKey: String );
+	getCreditsString(): String;
+	setLatLonToYUp( lat: Number, lon: Number ): void;
+
+}
+
+export class DebugGoogleTilesRenderer extends DebugTilesRenderer {
+
+	ellipsoid: Ellipsoid;
+
+	constructor( apiKey: String );
+	getCreditsString(): String;
+	setLatLonToYUp( lat: Number, lon: Number ): void;
+
+}
+
+export class GooglePhotorealisticTilesRenderer extends TilesRenderer {
+
+	ellipsoid: Ellipsoid;
+
+	constructor( url?: string );
+	getCreditsString(): String;
+	setLatLonToYUp( lat: Number, lon: Number ): void;
+
+}
+
+export class DebugGooglePhotorealisticTilesRenderer extends DebugTilesRenderer {
+
+	ellipsoid: Ellipsoid;
+
+	constructor( url?: string );
+	getCreditsString(): String;
+	setLatLonToYUp( lat: Number, lon: Number ): void;
+
+}

package/src/tileRenderer/three/renderers/GoogleTilesRenderer.js

@@ -0,0 +1,48 @@
+import { TilesRenderer } from '../TilesRenderer.js';
+import { DebugTilesRenderer } from '../DebugTilesRenderer.js';
+import { GoogleCloudAuthPlugin } from '../plugins/GoogleCloudAuthPlugin.js';
+
+const API_ORIGIN = 'https://tile.googleapis.com';
+const TILE_URL = `${ API_ORIGIN }/v1/3dtiles/root.json`;
+
+const GooglePhotorealisticTilesRendererMixin = base => class extends base {
+
+	constructor( url = TILE_URL ) {
+
+		super( url );
+
+		console.warn( 'GooglePhotorealisticTilesRenderer: Class has been deprecated. Use "TilesRenderer" with "GoogleCloudAuthPlugin" instead.' );
+
+		this.parseQueue.maxJobs = 10;
+		this.downloadQueue.maxJobs = 30;
+		this.errorTarget = 40;
+
+	}
+
+	getCreditsString() {
+
+		console.warn( 'GooglePhotorealisticTilesRenderer: "getCreditsString" function is deprecated. Use "getAttributions", instead.' );
+		return this.getAttributions()[ 0 ].value;
+
+	}
+
+};
+
+const GoogleTilesRendererMixin = base => class extends GooglePhotorealisticTilesRendererMixin( base ) {
+
+	constructor( apiToken, url ) {
+
+		super( url );
+		this.registerPlugin( new GoogleCloudAuthPlugin( { apiToken } ) );
+
+		console.warn( 'GoogleTilesRenderer: Class has been deprecated. Use "GoogleCloudAuthPlugin" instead.' );
+
+	}
+
+};
+
+export const GoogleTilesRenderer = GoogleTilesRendererMixin( TilesRenderer );
+export const DebugGoogleTilesRenderer = GoogleTilesRendererMixin( DebugTilesRenderer );
+
+export const GooglePhotorealisticTilesRenderer = GooglePhotorealisticTilesRendererMixin( TilesRenderer );
+export const DebugGooglePhotorealisticTilesRenderer = GooglePhotorealisticTilesRendererMixin( DebugTilesRenderer );

package/src/tileRenderer/three/utilities.js

@@ -0,0 +1,54 @@
+import { estimateBytesUsed as _estimateBytesUsed } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import * as THREE from 'three';
+
+// Returns the estimated number of bytes used by the object
+export function estimateBytesUsed( object ) {
+
+	// NOTE: This is for backwards compatibility and should be removed later
+	const { TextureUtils } = THREE;
+	if ( ! TextureUtils ) {
+
+		return 0;
+
+	}
+
+	const dedupeSet = new Set();
+
+	let totalBytes = 0;
+	object.traverse( c => {
+
+		// get geometry bytes
+		if ( c.geometry && ! dedupeSet.has( c.geometry ) ) {
+
+			totalBytes += _estimateBytesUsed( c.geometry );
+			dedupeSet.add( c.geometry );
+
+		}
+
+		// get material bytes
+		if ( c.material ) {
+
+			const material = c.material;
+			for ( const key in material ) {
+
+				const value = material[ key ];
+				if ( value && value.isTexture && ! dedupeSet.has( value ) ) {
+
+					const { format, type, image } = value;
+					const { width, height } = image;
+					const bytes = TextureUtils.getByteLength( width, height, format, type );
+					totalBytes += value.generateMipmaps ? bytes * 4 / 3 : bytes;
+
+					dedupeSet.add( value );
+
+				}
+
+			}
+
+		}
+
+	} );
+
+	return totalBytes;
+
+}

package/src/tileRenderer/utilities/BatchTable.d.ts

@@ -0,0 +1,24 @@
+export class BatchTable {
+
+	count : Number;
+
+	constructor(
+		buffer : ArrayBuffer,
+		count : Number,
+		start : Number,
+		headerLength : Number,
+		binLength : Number
+	);
+
+	getKeys() : Array< String >;
+
+	getDataFromId(
+		id: Number,
+		target?: Object
+	) : Object;
+
+	getPropertyArray(
+		key: String,
+	) : Number | String | ArrayBufferView;
+
+}

package/src/tileRenderer/utilities/BatchTable.js

@@ -0,0 +1,82 @@
+import { BatchTableHierarchyExtension } from './BatchTableHierarchyExtension.js';
+import { FeatureTable } from './FeatureTable.js';
+
+export class BatchTable extends FeatureTable {
+
+	get batchSize() {
+
+		console.warn( 'BatchTable.batchSize has been deprecated and replaced with BatchTable.count.' );
+		return this.count;
+
+	}
+
+	constructor( buffer, count, start, headerLength, binLength ) {
+
+		super( buffer, start, headerLength, binLength );
+		this.count = count;
+
+		this.extensions = {};
+		const extensions = this.header.extensions;
+		if ( extensions ) {
+
+			if ( extensions[ '3DTILES_batch_table_hierarchy' ] ) {
+
+				this.extensions[ '3DTILES_batch_table_hierarchy' ] = new BatchTableHierarchyExtension( this );
+
+			}
+
+		}
+
+	}
+
+	getData( key, componentType = null, type = null ) {
+
+		console.warn( 'BatchTable: BatchTable.getData is deprecated. Use BatchTable.getDataFromId to get all' +
+			'properties for an id or BatchTable.getPropertyArray for getting an array of value for a property.' );
+		return super.getData( key, this.count, componentType, type );
+
+	}
+
+	getDataFromId( id, target = {} ) {
+
+		if ( id < 0 || id >= this.count ) {
+
+			throw new Error( `BatchTable: id value "${ id }" out of bounds for "${ this.count }" features number.` );
+
+		}
+
+		for ( const key of this.getKeys() ) {
+
+			if ( key !== 'extensions' ) {
+
+				target[ key ] = super.getData( key, this.count )[ id ];
+
+			}
+
+		}
+
+		for ( const extensionName in this.extensions ) {
+
+			const extension = this.extensions[ extensionName ];
+
+			if ( extension.getDataFromId instanceof Function ) {
+
+				target[ extensionName ] = target[ extensionName ] || {};
+				extension.getDataFromId( id, target[ extensionName ] );
+
+			}
+
+		}
+
+		return target;
+
+	}
+
+	getPropertyArray( key ) {
+
+		return super.getData( key, this.count );
+
+	}
+
+
+}

package/src/tileRenderer/utilities/BatchTableHierarchyExtension.js

@@ -0,0 +1,127 @@
+import { parseBinArray } from './FeatureTable.js';
+
+export class BatchTableHierarchyExtension {
+
+	constructor( batchTable ) {
+
+		this.batchTable = batchTable;
+
+		const extensionHeader = batchTable.header.extensions[ '3DTILES_batch_table_hierarchy' ];
+
+		this.classes = extensionHeader.classes;
+		for ( const classDef of this.classes ) {
+
+			const instances = classDef.instances;
+			for ( const property in instances ) {
+
+				classDef.instances[ property ] = this._parseProperty( instances[ property ], classDef.length, property );
+
+			}
+
+		}
+
+		this.instancesLength = extensionHeader.instancesLength;
+
+		this.classIds = this._parseProperty( extensionHeader.classIds, this.instancesLength, 'classIds' );
+
+		if ( extensionHeader.parentCounts ) {
+
+			this.parentCounts = this._parseProperty( extensionHeader.parentCounts, this.instancesLength, 'parentCounts' );
+
+		} else {
+
+			this.parentCounts = new Array( this.instancesLength ).fill( 1 );
+
+		}
+
+		if ( extensionHeader.parentIds ) {
+
+			const parentIdsLength = this.parentCounts.reduce( ( a, b ) => a + b, 0 );
+			this.parentIds = this._parseProperty( extensionHeader.parentIds, parentIdsLength, 'parentIds' );
+
+		} else {
+
+			this.parentIds = null;
+
+		}
+
+		this.instancesIds = [];
+		const classCounter = {};
+		for ( const classId of this.classIds ) {
+
+			classCounter[ classId ] = classCounter[ classId ] ?? 0;
+			this.instancesIds.push( classCounter[ classId ] );
+			classCounter[ classId ] ++;
+
+		}
+
+	}
+
+	_parseProperty( property, propertyLength, propertyName ) {
+
+		if ( Array.isArray( property ) ) {
+
+			return property;
+
+		} else {
+
+			const { buffer, binOffset } = this.batchTable;
+
+			const byteOffset = property.byteOffset;
+			const componentType = property.componentType || 'UNSIGNED_SHORT';
+
+			const arrayStart = binOffset + byteOffset;
+
+			return parseBinArray( buffer, arrayStart, propertyLength, 'SCALAR', componentType, propertyName );
+
+		}
+
+	}
+
+	getDataFromId( id, target = {} ) {
+
+		// Get properties inherited from parents
+
+		const parentCount = this.parentCounts[ id ];
+
+		if ( this.parentIds && parentCount > 0 ) {
+
+			let parentIdsOffset = 0;
+			for ( let i = 0; i < id; i ++ ) {
+
+				parentIdsOffset += this.parentCounts[ i ];
+
+			}
+
+			for ( let i = 0; i < parentCount; i ++ ) {
+
+				const parentId = this.parentIds[ parentIdsOffset + i ];
+				if ( parentId !== id ) {
+
+					this.getDataFromId( parentId, target );
+
+				}
+
+			}
+
+		}
+
+		// Get properties proper to this instance
+
+		const classId = this.classIds[ id ];
+		const instances = this.classes[ classId ].instances;
+		const className = this.classes[ classId ].name;
+		const instanceId = this.instancesIds[ id ];
+
+		for ( const key in instances ) {
+
+			target[ className ] = target[ className ] || {};
+			target[ className ][ key ] = instances[ key ][ instanceId ];
+
+		}
+
+		return target;
+
+	}
+
+}

package/src/tileRenderer/utilities/FeatureTable.d.ts

@@ -0,0 +1,30 @@
+interface FeatureTableHeader {
+
+	extensions?: Object;
+	extras?: any;
+
+}
+
+export class FeatureTable {
+
+	header: FeatureTableHeader;
+
+	constructor(
+		buffer : ArrayBuffer,
+		start : Number,
+		headerLength : Number,
+		binLength : Number
+	);
+
+	getKeys() : Array< String >;
+
+	getData(
+		key : String,
+		count : Number,
+		defaultComponentType? : String | null,
+		defaultType? : String | null
+	) : Number | String | ArrayBufferView;
+
+	getBuffer( byteOffset : Number, byteLength : Number ) : ArrayBuffer;
+
+}