easy-three-utils 0.0.1

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

@@ -0,0 +1,86 @@
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { GLTFStructuralMetadataExtension } from './gltf/GLTFStructuralMetadataExtension.js';
+import { GLTFMeshFeaturesExtension } from './gltf/GLTFMeshFeaturesExtension.js';
+import { GLTFCesiumRTCExtension } from './gltf/GLTFCesiumRTCExtension.js';
+
+export class GLTFExtensionsPlugin {
+
+	constructor( options ) {
+
+		options = {
+			metadata: true,
+			rtc: true,
+
+			plugins: [],
+
+			dracoLoader: null,
+			ktxLoader: null,
+			autoDispose: true,
+			...options,
+		};
+
+		this.tiles = null;
+
+		this.metadata = options.metadata;
+		this.rtc = options.rtc;
+		this.plugins = options.plugins;
+
+		this.dracoLoader = options.dracoLoader;
+		this.ktxLoader = options.ktxLoader;
+		this._gltfRegex = /\.(gltf|glb)$/g;
+		this._dracoRegex = /\.drc$/g;
+		this._loader = null;
+
+	}
+
+	init( tiles ) {
+
+		const loader = new GLTFLoader( tiles.manager );
+		if ( this.dracoLoader ) {
+
+			loader.setDRACOLoader( this.dracoLoader );
+			tiles.manager.addHandler( this._dracoRegex, this.dracoLoader );
+
+		}
+
+		if ( this.ktxLoader ) {
+
+			loader.setKTX2Loader( this.ktxLoader );
+
+		}
+
+		if ( this.rtc ) {
+
+			loader.register( () => new GLTFCesiumRTCExtension() );
+
+		}
+
+		if ( this.metadata ) {
+
+			loader.register( () => new GLTFStructuralMetadataExtension() );
+			loader.register( () => new GLTFMeshFeaturesExtension() );
+
+		}
+
+		this.plugins.forEach( plugin => loader.register( plugin ) );
+
+		tiles.manager.addHandler( this._gltfRegex, loader );
+		this.tiles = tiles;
+		this._loader = loader;
+
+	}
+
+	dispose() {
+
+		this.tiles.manager.removeHandler( this._gltfRegex );
+		this.tiles.manager.removeHandler( this._dracoRegex );
+		if ( this.autoDispose ) {
+
+			this.ktxLoader.dispose();
+			this.dracoLoader.dispose();
+
+		}
+
+	}
+
+}

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

@@ -0,0 +1,62 @@
+export class GoogleAttributionsManager {
+
+	constructor() {
+
+		this.creditsCount = {};
+
+	}
+
+	_adjustAttributions( line, add ) {
+
+		const creditsCount = this.creditsCount;
+		const tokens = line.split( /;/g );
+		for ( let i = 0, l = tokens.length; i < l; i ++ ) {
+
+			const t = tokens[ i ];
+			if ( ! ( t in creditsCount ) ) {
+
+				creditsCount[ t ] = 0;
+
+			}
+
+			creditsCount[ t ] += add ? 1 : - 1;
+
+			if ( creditsCount[ t ] <= 0 ) {
+
+				delete creditsCount[ t ];
+
+			}
+
+		}
+
+	}
+
+	addAttributions( line ) {
+
+		this._adjustAttributions( line, true );
+
+	}
+
+	removeAttributions( line ) {
+
+		this._adjustAttributions( line, false );
+
+	}
+
+	toString() {
+
+		// attribution guidelines: https://developers.google.com/maps/documentation/tile/create-renderer#display-attributions
+
+		const sortedByCount = Object.entries( this.creditsCount ).sort( ( a, b ) => {
+
+			const countA = a[ 1 ];
+			const countB = b[ 1 ];
+			return countB - countA; // Descending order
+
+		} );
+
+		return sortedByCount.map( pair => pair[ 0 ] ).join( '; ' );
+
+	}
+
+}

package/src/tileRenderer/plugins/three/GoogleCloudAuthPlugin.d.ts

@@ -0,0 +1,5 @@
+export class GoogleCloudAuthPlugin {
+
+	constructor(options: { url: string });
+
+}

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

@@ -0,0 +1,200 @@
+import { traverseSet } from '../../base/traverseFunctions.js';
+import { GoogleAttributionsManager } from './GoogleAttributionsManager.js';
+
+function getSessionToken(root) {
+
+	let sessionToken = null;
+	traverseSet(root, tile => {
+
+		if (tile.content && tile.content.uri) {
+
+			const [, params] = tile.content.uri.split('?');
+			sessionToken = new URLSearchParams(params).get('session');
+			return true;
+
+		}
+
+		return false;
+
+	});
+
+	return sessionToken;
+
+}
+
+export class GoogleCloudAuthPlugin {
+
+	constructor({ url, autoRefreshToken = false, logoUrl = null, useRecommendedSettings = true }) {
+
+		this.name = 'GOOGLE_CLOUD_AUTH_PLUGIN';
+		this.baseUrl = url;
+		this.autoRefreshToken = autoRefreshToken;
+		this.useRecommendedSettings = useRecommendedSettings;
+		this.logoUrl = logoUrl;
+		this.sessionToken = null;
+		this.tiles = null;
+
+		this._onLoadCallback = null;
+		this._visibilityChangeCallback = null;
+		this._tokenRefreshPromise = null;
+		this._attributionsManager = new GoogleAttributionsManager();
+		this._logoAttribution = {
+			value: '',
+			type: 'image',
+			collapsible: false,
+		};
+		this._attribution = {
+			value: '',
+			type: 'string',
+			collapsible: true,
+		};
+
+	}
+
+	init(tiles) {
+
+		if (tiles == null) {
+
+			return;
+
+		}
+
+		// reset the tiles in case this plugin was removed and re-added
+		tiles.resetFailedTiles();
+
+		if (tiles.rootURL == null) {
+
+			tiles.rootURL = this.baseUrl;
+
+		}
+
+		if (this.useRecommendedSettings) {
+
+			// This plugin changes below values to be more efficient for the photorealistic tiles
+			tiles.parseQueue.maxJobs = 10;
+			tiles.downloadQueue.maxJobs = 30;
+			tiles.errorTarget = 40;
+
+		}
+
+		this.tiles = tiles;
+		this._onLoadCallback = ({ tileSet }) => {
+
+			// the first tile set loaded will be the root
+			this.sessionToken = getSessionToken(tileSet.root);
+
+			// clear the callback once the root is loaded
+			tiles.removeEventListener('load-tile-set', this._onLoadCallback);
+
+		};
+
+		this._visibilityChangeCallback = ({ tile, visible }) => {
+
+			const copyright = tile.cached.metadata.asset.copyright || '';
+			if (visible) {
+
+				this._attributionsManager.addAttributions(copyright);
+
+			} else {
+
+				this._attributionsManager.removeAttributions(copyright);
+
+			}
+
+		};
+
+		tiles.addEventListener('load-tile-set', this._onLoadCallback);
+		tiles.addEventListener('tile-visibility-change', this._visibilityChangeCallback);
+
+	}
+
+	getAttributions(target) {
+
+		if (this.tiles.visibleTiles.size > 0) {
+
+			if (this.logoUrl) {
+
+				this._logoAttribution.value = this.logoUrl;
+				target.push(this._logoAttribution);
+
+			}
+
+			this._attribution.value = this._attributionsManager.toString();
+			target.push(this._attribution);
+
+		}
+
+	}
+
+	preprocessURL(uri) {
+
+		uri = new URL(uri);
+		if (/^http/.test(uri.protocol)) {
+
+			// uri.searchParams.append('key', this.apiToken);
+			if (this.sessionToken !== null) {
+
+				uri.searchParams.append('session', this.sessionToken);
+
+			}
+
+		}
+		return uri.toString();
+
+	}
+
+	dispose() {
+
+		const { tiles } = this;
+		tiles.removeEventListener('load-tile-set', this._onLoadCallback);
+		tiles.removeEventListener('tile-visibility-change', this._visibilityChangeCallback);
+
+	}
+
+	async fetchData(uri, options) {
+
+		// wait for the token to refresh if loading
+		if (this._tokenRefreshPromise !== null) {
+
+			await this._tokenRefreshPromise;
+			uri = this.preprocessURL(uri);
+
+		}
+
+		const res = await fetch(uri, options);
+		if (res.status >= 400 && res.status <= 499 && this.autoRefreshToken) {
+
+			await this._refreshToken(options);
+			return fetch(this.preprocessURL(uri), options);
+
+		} else {
+
+			return res;
+
+		}
+
+	}
+
+	_refreshToken(options) {
+
+		if (this._tokenRefreshPromise === null) {
+
+			// refetch the root if the token has expired
+			const rootURL = new URL(this.tiles.rootURL);
+			// rootURL.searchParams.append('key', this.apiToken);
+			this._tokenRefreshPromise = fetch(rootURL, options)
+				.then(res => res.json())
+				.then(res => {
+
+					this.sessionToken = getSessionToken(res.root);
+					this._tokenRefreshPromise = null;
+
+				});
+
+		}
+
+		return this._tokenRefreshPromise;
+
+	}
+
+}

package/src/tileRenderer/plugins/three/ReorientationPlugin.d.ts

@@ -0,0 +1,12 @@
+export class GLTFExtensionsPlugin {
+
+	constructor( options: {
+		up: '+x' | '-x' | '+y' | '-y' | '+z' | '-z',
+		recenter: Boolean,
+
+		lat: Number | null,
+		lon: Number | null,
+		height: Number,
+	} );
+
+}

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

@@ -0,0 +1,136 @@
+import { Sphere, Vector3 } from 'three';
+import { OBJECT_FRAME } from '../../three/math/Ellipsoid.js';
+
+const sphere = /* @__PURE__ */ new Sphere();
+const vec = /* @__PURE__ */ new Vector3();
+export class ReorientationPlugin {
+
+	constructor( options ) {
+
+		options = {
+			up: '+z',
+			recenter: true,
+
+			lat: null,
+			lon: null,
+			height: 0,
+			...options,
+		};
+
+		this.tiles = null;
+
+		this.up = options.up.toLowerCase().replace( /\s+/, '' );
+		this.lat = options.lat;
+		this.lon = options.lon;
+		this.height = options.height;
+		this.recenter = options.recenter;
+		this._callback = null;
+
+	}
+
+	init( tiles ) {
+
+		this.tiles = tiles;
+
+		this._callback = () => {
+
+			const { up, lat, lon, height, recenter } = this;
+
+			if ( lat !== null && lon !== null ) {
+
+				// if the latitude and longitude are provided then remove the position offset
+				this.transformLatLonHeightToOrigin( lat, lon, height );
+
+			} else {
+
+				const { ellipsoid } = tiles;
+				const minRadii = Math.min( ...ellipsoid.radius );
+				tiles.getBoundingSphere( sphere );
+				if ( sphere.center.length() > minRadii * 0.5 ) {
+
+					// otherwise see if this is possibly a tile set on the surface of the globe based on the positioning
+					const cart = {};
+					ellipsoid.getPositionToCartographic( sphere.center, cart );
+					this.transformLatLonHeightToOrigin( cart.lat, cart.lon, cart.height );
+
+				} else {
+
+					// lastly fall back to orienting the up direction to +Y
+					const group = tiles.group;
+					group.rotation.set( 0, 0, 0 );
+					switch ( up ) {
+
+						case 'x': case '+x':
+							group.rotation.z = Math.PI / 2;
+							break;
+						case '-x':
+							group.rotation.z = - Math.PI / 2;
+							break;
+
+						case 'y': case '+y':
+							break;
+						case '-y':
+							group.rotation.z = Math.PI;
+							break;
+
+						case 'z': case '+z':
+							group.rotation.x = - Math.PI / 2;
+							break;
+						case '-z':
+							group.rotation.x = Math.PI / 2;
+							break;
+
+					}
+
+					tiles.group.position
+						.copy( sphere.center )
+						.applyEuler( group.rotation )
+						.multiplyScalar( - 1 );
+
+				}
+
+			}
+
+			if ( ! recenter ) {
+
+				tiles.group.position.setScalar( 0 );
+
+			}
+
+			tiles.removeEventListener( 'load-tile-set', this._callback );
+
+		};
+
+		tiles.addEventListener( 'load-tile-set', this._callback );
+
+	}
+
+	transformLatLonHeightToOrigin( lat, lon, height = 0 ) {
+
+		const { group, ellipsoid } = this.tiles;
+
+		// get ENU orientation (Z facing north and X facing west) and position
+		ellipsoid.getRotationMatrixFromAzElRoll( lat, lon, 0, 0, 0, group.matrix, OBJECT_FRAME );
+		ellipsoid.getCartographicToPosition( lat, lon, height, vec );
+
+		// adjust the group matrix
+		group.matrix
+			.setPosition( vec )
+			.invert()
+			.decompose( group.position, group.quaternion, group.scale );
+		group.updateMatrixWorld();
+
+	}
+
+	dispose() {
+
+		const { group } = this.tiles;
+		group.position.setScalar( 0 );
+		group.quaternion.identity();
+		group.scale.set( 1, 1, 1 );
+
+		this.tiles.addEventListener( 'load-tile-set', this._callback );
+
+	}
+
+}

package/src/tileRenderer/plugins/three/TileCompressionPlugin.d.ts

@@ -0,0 +1,18 @@
+import { TypedArray } from 'three';
+
+export class TileCompressionPlugin {
+
+	constructor( options: {
+		generateNormals: Boolean,
+		disableMipmaps: Boolean,
+		compressIndex: Boolean,
+		compressNormals: Boolean,
+		compressUvs: Boolean,
+		compressPosition: Boolean,
+
+		uvType: TypedArray,
+		normalType: TypedArray,
+		positionType: TypedArray,
+	} );
+
+}