easy-three-utils 0.0.1

package/src/tileRenderer/three/loaders/GLTFExtensionLoader.js

@@ -0,0 +1,68 @@
+import { DefaultLoadingManager } from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { LoaderBase } from '../../base/loaders/LoaderBase.js';
+import { GLTFCesiumRTCExtension } from './gltf/GLTFCesiumRTCExtension.js';
+
+export class GLTFExtensionLoader extends LoaderBase {
+
+	constructor( manager = DefaultLoadingManager ) {
+
+		super();
+		this.manager = manager;
+
+	}
+
+	parse( buffer ) {
+
+		return new Promise( ( resolve, reject ) => {
+
+			const manager = this.manager;
+			const fetchOptions = this.fetchOptions;
+			let loader = manager.getHandler( 'path.gltf' ) || manager.getHandler( 'path.glb' );
+
+			if ( ! loader ) {
+
+				loader = new GLTFLoader( manager );
+
+				loader.register( () => new GLTFCesiumRTCExtension() );
+
+			}
+
+			if ( fetchOptions.credentials === 'include' && fetchOptions.mode === 'cors' ) {
+
+				loader.setCrossOrigin( 'use-credentials' );
+
+			}
+
+			if ( 'credentials' in fetchOptions ) {
+
+				loader.setWithCredentials( fetchOptions.credentials === 'include' );
+
+			}
+
+			if ( fetchOptions.headers ) {
+
+				loader.setRequestHeader( fetchOptions.headers );
+
+			}
+
+			// assume any pre-registered loader has paths configured as the user desires, but if we're making
+			// a new loader, use the working path during parse to support relative uris on other hosts
+			let resourcePath = loader.resourcePath || loader.path || this.workingPath;
+			if ( ! /[\\/]$/.test( resourcePath ) && resourcePath.length ) {
+
+				resourcePath += '/';
+
+			}
+
+			loader.parse( buffer, resourcePath, model => {
+
+				resolve( model );
+
+			}, reject );
+
+		} );
+
+	}
+
+}

package/src/tileRenderer/three/loaders/I3DMLoader.d.ts

@@ -0,0 +1,26 @@
+import { I3DMBaseResult } from '../../base/loaders/I3DMLoaderBase';
+import { BatchTable } from '../../utilities/BatchTable';
+import { FeatureTable } from '../../utilities/FeatureTable';
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { Group, LoadingManager } from 'three';
+
+interface I3DMScene extends Group {
+
+	batchTable : BatchTable;
+	featureTable : FeatureTable;
+
+}
+
+export interface I3DMResult extends GLTF, I3DMBaseResult {
+
+	scene : I3DMScene;
+
+}
+
+export class I3DMLoader {
+
+	constructor( manager : LoadingManager );
+	load( url : String ) : Promise< I3DMResult >;
+	parse( buffer : ArrayBuffer ) : Promise< I3DMResult >;
+
+}

package/src/tileRenderer/three/loaders/I3DMLoader.js

@@ -0,0 +1,256 @@
+import { I3DMLoaderBase } from '../../base/loaders/I3DMLoaderBase.js';
+import { DefaultLoadingManager, Matrix4, InstancedMesh, Vector3, Quaternion } from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { WGS84_ELLIPSOID } from '../math/GeoConstants.js';
+
+const tempFwd = /* @__PURE__ */ new Vector3();
+const tempUp = /* @__PURE__ */ new Vector3();
+const tempRight = /* @__PURE__ */ new Vector3();
+const tempPos = /* @__PURE__ */ new Vector3();
+const tempQuat = /* @__PURE__ */ new Quaternion();
+const tempSca = /* @__PURE__ */ new Vector3();
+const tempMat = /* @__PURE__ */ new Matrix4();
+const tempMat2 = /* @__PURE__ */ new Matrix4();
+
+const tempGlobePos = /* @__PURE__ */ new Vector3();
+const tempEnuFrame = /* @__PURE__ */ new Matrix4();
+const tempLocalQuat = /* @__PURE__ */ new Quaternion();
+const tempLatLon = {};
+
+export class I3DMLoader extends I3DMLoaderBase {
+
+	constructor( manager = DefaultLoadingManager ) {
+
+		super();
+		this.manager = manager;
+		this.adjustmentTransform = new Matrix4();
+		this.ellipsoid = WGS84_ELLIPSOID.clone();
+
+	}
+
+	resolveExternalURL( url ) {
+
+		return this.manager.resolveURL( super.resolveExternalURL( url ) );
+
+	}
+
+	parse( buffer ) {
+
+		return super
+			.parse( buffer )
+			.then( i3dm => {
+
+				const { featureTable, batchTable } = i3dm;
+				const gltfBuffer = i3dm.glbBytes.slice().buffer;
+				return new Promise( ( resolve, reject ) => {
+
+					const fetchOptions = this.fetchOptions;
+					const manager = this.manager;
+					const loader = manager.getHandler( 'path.gltf' ) || new GLTFLoader( manager );
+
+					if ( fetchOptions.credentials === 'include' && fetchOptions.mode === 'cors' ) {
+
+						loader.setCrossOrigin( 'use-credentials' );
+
+					}
+
+					if ( 'credentials' in fetchOptions ) {
+
+						loader.setWithCredentials( fetchOptions.credentials === 'include' );
+
+					}
+
+					if ( fetchOptions.headers ) {
+
+						loader.setRequestHeader( fetchOptions.headers );
+
+					}
+
+					// GLTFLoader assumes the working path ends in a slash
+					let workingPath = i3dm.gltfWorkingPath ?? this.workingPath;
+					if ( ! /[\\/]$/.test( workingPath ) ) {
+
+						workingPath += '/';
+
+					}
+
+					const adjustmentTransform = this.adjustmentTransform;
+
+					loader.parse( gltfBuffer, workingPath, model => {
+
+						const INSTANCES_LENGTH = featureTable.getData( 'INSTANCES_LENGTH' );
+						const POSITION = featureTable.getData( 'POSITION', INSTANCES_LENGTH, 'FLOAT', 'VEC3' );
+						const NORMAL_UP = featureTable.getData( 'NORMAL_UP', INSTANCES_LENGTH, 'FLOAT', 'VEC3' );
+						const NORMAL_RIGHT = featureTable.getData( 'NORMAL_RIGHT', INSTANCES_LENGTH, 'FLOAT', 'VEC3' );
+						const SCALE_NON_UNIFORM = featureTable.getData( 'SCALE_NON_UNIFORM', INSTANCES_LENGTH, 'FLOAT', 'VEC3' );
+						const SCALE = featureTable.getData( 'SCALE', INSTANCES_LENGTH, 'FLOAT', 'SCALAR' );
+						const RTC_CENTER = featureTable.getData( 'RTC_CENTER' );
+						const EAST_NORTH_UP = featureTable.getData( 'EAST_NORTH_UP' );
+
+						[
+							'QUANTIZED_VOLUME_OFFSET',
+							'QUANTIZED_VOLUME_SCALE',
+							'POSITION_QUANTIZED',
+							'NORMAL_UP_OCT32P',
+							'NORMAL_RIGHT_OCT32P',
+						].forEach( feature => {
+
+							if ( feature in featureTable.header ) {
+
+								console.warn( `I3DMLoader: Unsupported FeatureTable feature "${ feature }" detected.` );
+
+							}
+
+						} );
+
+						// get the average vector center so we can avoid floating point error due to lower
+						// precision transformation calculations on the GPU
+						const averageVector = new Vector3();
+						for ( let i = 0; i < INSTANCES_LENGTH; i ++ ) {
+
+							averageVector.x += POSITION[ i * 3 + 0 ] / INSTANCES_LENGTH;
+							averageVector.y += POSITION[ i * 3 + 1 ] / INSTANCES_LENGTH;
+							averageVector.z += POSITION[ i * 3 + 2 ] / INSTANCES_LENGTH;
+
+						}
+
+						// find all the children and create associated instance meshes
+						const instances = [];
+						const meshes = [];
+						model.scene.updateMatrixWorld();
+
+						model.scene.traverse( child => {
+
+							if ( child.isMesh ) {
+
+								meshes.push( child );
+
+								const { geometry, material } = child;
+								const instancedMesh = new InstancedMesh( geometry, material, INSTANCES_LENGTH );
+								instancedMesh.position.copy( averageVector );
+
+								if ( RTC_CENTER ) {
+
+									instancedMesh.position.x += RTC_CENTER[ 0 ];
+									instancedMesh.position.y += RTC_CENTER[ 1 ];
+									instancedMesh.position.z += RTC_CENTER[ 2 ];
+
+								}
+
+								instances.push( instancedMesh );
+
+							}
+
+						} );
+
+						// generate positions for all instances
+						for ( let i = 0; i < INSTANCES_LENGTH; i ++ ) {
+
+							// position
+							tempPos.set(
+								POSITION[ i * 3 + 0 ] - averageVector.x,
+								POSITION[ i * 3 + 1 ] - averageVector.y,
+								POSITION[ i * 3 + 2 ] - averageVector.z,
+							);
+
+							// rotation
+							tempQuat.identity();
+
+							// account for EAST_NORTH_UP per-instance below
+
+							if ( NORMAL_UP ) {
+
+								tempUp.set(
+									NORMAL_UP[ i * 3 + 0 ],
+									NORMAL_UP[ i * 3 + 1 ],
+									NORMAL_UP[ i * 3 + 2 ],
+								);
+
+								tempRight.set(
+									NORMAL_RIGHT[ i * 3 + 0 ],
+									NORMAL_RIGHT[ i * 3 + 1 ],
+									NORMAL_RIGHT[ i * 3 + 2 ],
+								);
+
+								tempFwd.crossVectors( tempRight, tempUp )
+									.normalize();
+
+								tempMat.makeBasis(
+									tempRight,
+									tempUp,
+									tempFwd,
+								);
+
+								tempQuat.setFromRotationMatrix( tempMat );
+
+							}
+
+							// scale
+							tempSca.set( 1, 1, 1 );
+
+							if ( SCALE_NON_UNIFORM ) {
+
+								tempSca.set(
+									SCALE_NON_UNIFORM[ i * 3 + 0 ],
+									SCALE_NON_UNIFORM[ i * 3 + 1 ],
+									SCALE_NON_UNIFORM[ i * 3 + 2 ],
+								);
+
+							}
+
+							if ( SCALE ) {
+
+								tempSca.multiplyScalar( SCALE[ i ] );
+
+							}
+
+							// multiple in the original meshes world transform
+							for ( let j = 0, l = instances.length; j < l; j ++ ) {
+
+								const instance = instances[ j ];
+								tempLocalQuat.copy( tempQuat );
+
+								// Handle east-north-up frame generation
+								if ( EAST_NORTH_UP ) {
+
+									instance.updateMatrixWorld();
+
+									// transform the instance position to global frame and get the rotation from the associated ENU frame.
+									tempGlobePos.copy( tempPos ).applyMatrix4( instance.matrixWorld );
+									this.ellipsoid.getPositionToCartographic( tempGlobePos, tempLatLon );
+									this.ellipsoid.getEastNorthUpFrame( tempLatLon.lat, tempLatLon.lon, tempEnuFrame );
+									tempLocalQuat.setFromRotationMatrix( tempEnuFrame );
+
+								}
+
+								tempMat.compose( tempPos, tempLocalQuat, tempSca ).multiply( adjustmentTransform );
+
+								const mesh = meshes[ j ];
+								tempMat2.multiplyMatrices( tempMat, mesh.matrixWorld );
+								instance.setMatrixAt( i, tempMat2 );
+
+							}
+
+						}
+
+						// replace all geometry with the instances
+						model.scene.clear();
+						model.scene.add( ...instances );
+
+						model.batchTable = batchTable;
+						model.featureTable = featureTable;
+
+						model.scene.batchTable = batchTable;
+						model.scene.featureTable = featureTable;
+
+						resolve( model );
+
+					}, reject );
+
+				} );
+
+			} );
+
+	}
+
+}

package/src/tileRenderer/three/loaders/PNTSLoader.d.ts

@@ -0,0 +1,25 @@
+import { PNTSBaseResult, PNTSLoaderBase } from '../../base/loaders/PNTSLoaderBase';
+import { BatchTable } from '../../utilities/BatchTable';
+import { FeatureTable } from '../../utilities/FeatureTable';
+import { Points, LoadingManager } from 'three';
+
+interface PNTSScene extends Points {
+
+	batchTable : BatchTable
+	featureTable : FeatureTable;
+
+}
+
+export interface PNTSResult extends PNTSBaseResult {
+
+	scene : PNTSScene;
+
+}
+
+export class PNTSLoader extends PNTSLoaderBase {
+
+	constructor( manager : LoadingManager );
+	load( url : String ) : Promise< PNTSResult >;
+	parse( buffer : ArrayBuffer ) : Promise< PNTSResult >;
+
+}

package/src/tileRenderer/three/loaders/PNTSLoader.js

@@ -0,0 +1,202 @@
+import { PNTSLoaderBase } from '../../base/loaders/PNTSLoaderBase.js';
+import {
+	Points,
+	PointsMaterial,
+	BufferGeometry,
+	BufferAttribute,
+	DefaultLoadingManager,
+	Vector3,
+	Color,
+} from 'three';
+import { rgb565torgb } from '../../utilities/rgb565torgb.js';
+
+const DRACO_ATTRIBUTE_MAP = {
+	RGB: 'color',
+	POSITION: 'position',
+};
+
+export class PNTSLoader extends PNTSLoaderBase {
+
+	constructor( manager = DefaultLoadingManager ) {
+
+		super();
+		this.manager = manager;
+
+	}
+
+	parse( buffer ) {
+
+		return super.parse( buffer ).then( async ( result ) => {
+
+			const { featureTable, batchTable } = result;
+
+			const material = new PointsMaterial();
+			const extensions = featureTable.header.extensions;
+			const translationOffset = new Vector3();
+			let geometry;
+
+			// handle loading the draco data
+			if ( extensions && extensions[ '3DTILES_draco_point_compression' ] ) {
+
+				const { byteOffset, byteLength, properties } = extensions[ '3DTILES_draco_point_compression' ];
+				const dracoLoader = this.manager.getHandler( 'draco.drc' );
+				if ( dracoLoader == null ) {
+
+					throw new Error( 'PNTSLoader: dracoLoader not available.' );
+
+				}
+
+				// map PNTS keys to draco types
+				const attributeIDs = {};
+				for ( const key in properties ) {
+
+					if ( key in DRACO_ATTRIBUTE_MAP && key in properties ) {
+
+						const mappedKey = DRACO_ATTRIBUTE_MAP[ key ];
+						attributeIDs[ mappedKey ] = properties[ key ];
+
+					}
+
+				}
+
+				// decode the geometry
+				const taskConfig = {
+					attributeIDs,
+					attributeTypes: {
+						position: 'Float32Array',
+						color: 'Uint8Array',
+					},
+					useUniqueIDs: true,
+				};
+
+				const buffer = featureTable.getBuffer( byteOffset, byteLength );
+				geometry = await dracoLoader.decodeGeometry( buffer, taskConfig );
+				if ( geometry.attributes.color ) {
+
+					material.vertexColors = true;
+
+				}
+
+			} else {
+
+				// handle non compressed case
+				const POINTS_LENGTH = featureTable.getData( 'POINTS_LENGTH' );
+				const POSITION = featureTable.getData( 'POSITION', POINTS_LENGTH, 'FLOAT', 'VEC3' );
+				const RGB = featureTable.getData( 'RGB', POINTS_LENGTH, 'UNSIGNED_BYTE', 'VEC3' );
+				const RGBA = featureTable.getData( 'RGBA', POINTS_LENGTH, 'UNSIGNED_BYTE', 'VEC4' );
+				const RGB565 = featureTable.getData( 'RGB565', POINTS_LENGTH, 'UNSIGNED_SHORT', 'SCALAR' );
+				const CONSTANT_RGBA = featureTable.getData( 'CONSTANT_RGBA', POINTS_LENGTH, 'UNSIGNED_BYTE', 'VEC4' );
+				const POSITION_QUANTIZED = featureTable.getData( 'POSITION_QUANTIZED', POINTS_LENGTH, 'UNSIGNED_SHORT', 'VEC3' );
+				const QUANTIZED_VOLUME_SCALE = featureTable.getData( 'QUANTIZED_VOLUME_SCALE', POINTS_LENGTH, 'FLOAT', 'VEC3' );
+				const QUANTIZED_VOLUME_OFFSET = featureTable.getData( 'QUANTIZED_VOLUME_OFFSET', POINTS_LENGTH, 'FLOAT', 'VEC3' );
+
+				geometry = new BufferGeometry();
+
+				if ( POSITION_QUANTIZED ) {
+
+					const decodedPositions = new Float32Array( POINTS_LENGTH * 3 );
+					for ( let i = 0; i < POINTS_LENGTH; i ++ ) {
+
+						for ( let j = 0; j < 3; j ++ ) {
+
+							const index = 3 * i + j;
+							decodedPositions[ index ] = ( POSITION_QUANTIZED[ index ] / 65535.0 ) * QUANTIZED_VOLUME_SCALE[ j ];
+
+						}
+
+					}
+					translationOffset.x = QUANTIZED_VOLUME_OFFSET[ 0 ];
+					translationOffset.y = QUANTIZED_VOLUME_OFFSET[ 1 ];
+					translationOffset.z = QUANTIZED_VOLUME_OFFSET[ 2 ];
+					geometry.setAttribute( 'position', new BufferAttribute( decodedPositions, 3, false ) );
+
+				} else {
+
+					geometry.setAttribute( 'position', new BufferAttribute( POSITION, 3, false ) );
+
+				}
+
+				if ( RGBA !== null ) {
+
+					geometry.setAttribute( 'color', new BufferAttribute( RGBA, 4, true ) );
+					material.vertexColors = true;
+					material.transparent = true;
+					material.depthWrite = false;
+
+				} else if ( RGB !== null ) {
+
+					geometry.setAttribute( 'color', new BufferAttribute( RGB, 3, true ) );
+					material.vertexColors = true;
+
+				} else if ( RGB565 !== null ) {
+
+					const color = new Uint8Array( POINTS_LENGTH * 3 );
+					for ( let i = 0; i < POINTS_LENGTH; i ++ ) {
+
+						const rgbColor = rgb565torgb( RGB565[ i ] );
+						for ( let j = 0; j < 3; j ++ ) {
+
+							const index = 3 * i + j;
+							color[ index ] = rgbColor[ j ];
+
+						}
+
+					}
+					geometry.setAttribute( 'color', new BufferAttribute( color, 3, true ) );
+					material.vertexColors = true;
+
+				} else if ( CONSTANT_RGBA !== null ) {
+
+					const color = new Color( CONSTANT_RGBA[ 0 ], CONSTANT_RGBA[ 1 ], CONSTANT_RGBA[ 2 ] );
+					material.color = color;
+					const opacity = CONSTANT_RGBA[ 3 ] / 255;
+					if ( opacity < 1 ) {
+
+						material.opacity = opacity;
+						material.transparent = true;
+						material.depthWrite = false;
+
+					}
+
+				}
+
+			}
+
+			[
+				'BATCH_LENGTH',
+				'NORMAL',
+				'NORMAL_OCT16P',
+			].forEach( ( feature ) => {
+
+				if ( feature in featureTable.header ) {
+
+					console.warn(
+						`PNTSLoader: Unsupported FeatureTable feature "${feature}" detected.`
+					);
+
+				}
+
+			} );
+
+			const object = new Points( geometry, material );
+			object.position.copy( translationOffset );
+			result.scene = object;
+			result.scene.featureTable = featureTable;
+			result.scene.batchTable = batchTable;
+
+			const rtcCenter = featureTable.getData( 'RTC_CENTER' );
+			if ( rtcCenter ) {
+
+				result.scene.position.x += rtcCenter[ 0 ];
+				result.scene.position.y += rtcCenter[ 1 ];
+				result.scene.position.z += rtcCenter[ 2 ];
+
+			}
+
+			return result;
+
+		} );
+
+	}
+
+}

package/src/tileRenderer/three/loaders/gltf/GLTFCesiumRTCExtension.js

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

package/src/tileRenderer/three/loaders/gltf/GLTFMeshFeaturesExtension.js

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

package/src/tileRenderer/three/loaders/gltf/GLTFStructuralMetadataExtension.js

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

package/src/tileRenderer/three/math/Ellipsoid.d.ts

@@ -0,0 +1,31 @@
+import { Vector3, Matrix4 } from 'three';
+
+export enum Frames {}
+export const ENU_FRAME: Frames;
+export const CAMERA_FRAME: Frames;
+export const OBJECT_FRAME: Frames;
+
+export class Ellipsoid {
+
+	radius: Vector3;
+
+	constructor( x: Number, y: Number, z: Number );
+	getCartographicToPosition( lat: Number, lon: Number, height: Number, target: Vector3 ): Vector3;
+	getPositionToCartographic( pos: Vector3, target: Object ): { lat: Number, lon: Number, height: Number };
+	getCartographicToNormal( lat: Number, lon: Number, target: Vector3 ): Vector3;
+	getPositionToNormal( pos: Vector3, target: Vector3 ): Vector3;
+	getPositionToSurfacePoint( pos: Vector3, target: Vector3 ): Vector3;
+
+	getAzElRollFromRotationMatrix(
+		lat: Number, lon: Number, rotationMatrix: Matrix4,
+		target: Object, frame: Frames,
+	): { azimuth: Number, elevation: Number, roll: Number };
+	getRotationMatrixFromAzElRoll(
+		lat: Number, lon: Number, az: Number, el: Number, roll: Number,
+		target: Matrix4, frame: Frames,
+	): Matrix4;
+
+	getEastNorthUpFrame( lat: Number, lon: Number, target: Matrix4 ): Matrix4;
+	getEastNorthUpAxes( lat: Number, lon: Number, vecEast: Vector3, vecNorth: Vector3, vecUp: Vector3, point?: Vector3 );
+
+}