t3d-3dtiles 0.1.0

package/src/utils/CameraList.js

@@ -0,0 +1,131 @@
+import { Vector2, Vector3, Matrix4 } from 't3d';
+import { FastFrustum } from '../math/FastFrustum.js';
+
+export class CameraList {
+
+	constructor() {
+		this._cameras = [];
+		this._resolution = new Vector2();
+		this._infos = [];
+	}
+
+	add(camera) {
+		const cameras = this._cameras;
+
+		if (cameras.indexOf(camera) === -1) {
+			cameras.push(camera);
+			return true;
+		}
+
+		return false;
+	}
+
+	remove(camera) {
+		const cameras = this._cameras;
+		const index = cameras.indexOf(camera);
+
+		if (index !== -1) {
+			cameras.splice(index, 1);
+			return true;
+		}
+
+		return false;
+	}
+
+	setResolution(width, height) {
+		this._resolution.set(width, height);
+	}
+
+	updateInfos(originMatrix) {
+		const cameras = this._cameras;
+		const cameraCount = cameras.length;
+		const infos = this._infos;
+		const resolution = this._resolution;
+
+		if (cameraCount === 0) {
+			console.warn('CameraList.updateInfos(): No camera added.');
+			return;
+		}
+
+		// automatically scale the array of infos to match the cameras
+
+		while (infos.length > cameras.length) {
+			infos.pop();
+		}
+
+		while (infos.length < cameras.length) {
+			infos.push({
+				frustum: new FastFrustum(), // in origin space
+				isOrthographic: false,
+				sseDenominator: -1, // used if isOrthographic is false
+				position: new Vector3(), // in origin space
+				invScale: -1,
+				pixelSize: 0 // used if isOrthographic is true
+			});
+		}
+
+		// get inverse scale of origin matrix
+
+		_mat4_1.copy(originMatrix).inverse();
+
+		const invScaleX = _vec3_1.setFromMatrixColumn(_mat4_1, 0).getLength();
+		const invScaleY = _vec3_1.setFromMatrixColumn(_mat4_1, 1).getLength();
+		const invScaleZ = _vec3_1.setFromMatrixColumn(_mat4_1, 2).getLength();
+
+		if (Math.abs(Math.max(invScaleX - invScaleY, invScaleX - invScaleZ)) > 1e-6) {
+			console.warn('CameraList.updateInfos(): Non uniform scale used for tile which may cause issues when calculating screen space error.');
+		}
+
+		const invScale = invScaleX;
+		const invOriginMatrix = _mat4_1;
+
+		// update the camera infos
+
+		for (let i = 0, l = infos.length; i < l; i++) {
+			const camera = cameras[i];
+			const info = infos[i];
+
+			const cameraResolutionX = resolution.x * (camera.rect.z - camera.rect.x);
+			const cameraResolutionY = resolution.y * (camera.rect.w - camera.rect.y);
+
+			if (cameraResolutionX === 0 || cameraResolutionY === 0) {
+				console.warn('CameraList.updateInfos(): Resolution for camera error calculation is not set.');
+			}
+
+			// Read the calculated projection matrix directly to support custom Camera implementations
+			const projection = camera.projectionMatrix.elements;
+
+			// The last element of the projection matrix is 1 for orthographic, 0 for perspective
+			info.isOrthographic = projection[15] === 1;
+
+			if (info.isOrthographic) {
+				// the view width and height are used to populate matrix elements 0 and 5.
+				const w = 2 / projection[0];
+				const h = 2 / projection[5];
+				info.pixelSize = Math.max(h / cameraResolutionY, w / cameraResolutionX);
+			} else {
+				// the vertical FOV is used to populate matrix element 5.
+				info.sseDenominator = (2 / projection[5]) / cameraResolutionY;
+			}
+
+			info.invScale = invScale;
+
+			// get frustum in origin space
+			_mat4_2.copy(originMatrix).premultiply(camera.projectionViewMatrix);
+			info.frustum.setFromMatrix(_mat4_2);
+			info.frustum.updateCache();
+
+			// get camera position in origin space
+			info.position.setFromMatrixPosition(camera.worldMatrix).applyMatrix4(invOriginMatrix);
+		}
+	}
+
+	getInfos() {
+		return this._infos;
+	}
+
+}
+
+const _mat4_1 = new Matrix4();
+const _mat4_2 = new Matrix4();
+const _vec3_1 = new Vector3();

package/src/utils/FeatureTable.js

@@ -0,0 +1,107 @@
+
+import { GLTFUtils } from '../libs/glTF/GLTFUtils.js';
+
+export class FeatureTable {
+
+	constructor(buffer, start, headerLength, binLength) {
+		this.buffer = buffer;
+		this.binOffset = start + headerLength;
+		this.binLength = binLength;
+
+		let header = null;
+		if (headerLength !== 0) {
+			const headerData = new Uint8Array(buffer, start, headerLength);
+			header = JSON.parse(GLTFUtils.decodeText(headerData));
+		} else {
+			header = {};
+		}
+		this.header = header;
+	}
+
+	getKeys() {
+		return Object.keys(this.header);
+	}
+
+	getData(key, count, defaultComponentType = null, defaultType = null) {
+		const header = this.header;
+
+		if (!(key in header)) {
+			return null;
+		}
+
+		const feature = header[key];
+		if (!(feature instanceof Object)) {
+			return feature;
+		} else if (Array.isArray(feature)) {
+			return feature;
+		} else {
+			const { buffer, binOffset, binLength } = this;
+			const byteOffset = feature.byteOffset || 0;
+			const featureType = feature.type || defaultType;
+			const featureComponentType = feature.componentType || defaultComponentType;
+
+			if ('type' in feature && defaultType && feature.type !== defaultType) {
+				throw new Error('FeatureTable: Specified type does not match expected type.');
+			}
+
+			let stride;
+			switch (featureType) {
+				case 'SCALAR':
+					stride = 1;
+					break;
+				case 'VEC2':
+					stride = 2;
+					break;
+				case 'VEC3':
+					stride = 3;
+					break;
+				case 'VEC4':
+					stride = 4;
+					break;
+				default:
+					throw new Error(`FeatureTable: Feature type not provided for "${key}".`);
+			}
+
+			let data;
+			const arrayStart = binOffset + byteOffset;
+			const arrayLength = count * stride;
+
+			switch (featureComponentType) {
+				case 'BYTE':
+					data = new Int8Array(buffer, arrayStart, arrayLength);
+					break;
+				case 'UNSIGNED_BYTE':
+					data = new Uint8Array(buffer, arrayStart, arrayLength);
+					break;
+				case 'SHORT':
+					data = new Int16Array(buffer, arrayStart, arrayLength);
+					break;
+				case 'UNSIGNED_SHORT':
+					data = new Uint16Array(buffer, arrayStart, arrayLength);
+					break;
+				case 'INT':
+					data = new Int32Array(buffer, arrayStart, arrayLength);
+					break;
+				case 'UNSIGNED_INT':
+					data = new Uint32Array(buffer, arrayStart, arrayLength);
+					break;
+				case 'FLOAT':
+					data = new Float32Array(buffer, arrayStart, arrayLength);
+					break;
+				case 'DOUBLE':
+					data = new Float64Array(buffer, arrayStart, arrayLength);
+					break;
+				default:
+					throw new Error(`FeatureTable: Feature component type not provided for "${key}".`);
+			}
+
+			const dataEnd = arrayStart + arrayLength * data.BYTES_PER_ELEMENT;
+			if (dataEnd > binOffset + binLength) {
+				throw new Error('FeatureTable: Feature data read outside binary body length.');
+			}
+
+			return data;
+		}
+	}
+
+}

package/src/utils/IntersectionUtils.js

@@ -0,0 +1,136 @@
+import { Matrix4, Ray, Vector3 } from 't3d';
+
+export const raycastTraverse = (tile, tiles3D, ray, intersects, localRay = null) => {
+	const { activeTiles } = tiles3D;
+	const boundingVolume = tile.cached.boundingVolume;
+
+	// reuse the ray when traversing the tree
+	if (localRay === null) {
+		localRay = _ray_1;
+		_mat4_1.copy(tiles3D.worldMatrix).inverse();
+		localRay.copy(ray).applyMatrix4(_mat4_1);
+	}
+
+	if (!tile.__used || !boundingVolume.intersectsRay(localRay)) {
+		return;
+	}
+
+	if (activeTiles.has(tile)) {
+		_intersectTileScene(tile, ray, intersects);
+	}
+
+	const children = tile.children;
+	for (let i = 0, l = children.length; i < l; i++) {
+		raycastTraverse(children[i], tiles3D, ray, intersects, localRay);
+	}
+};
+
+// Returns the closest hit when traversing the tree
+export const raycastTraverseFirstHit = (tile, tiles3D, ray, localRay = null) => {
+	const { activeTiles } = tiles3D;
+
+	// reuse the ray when traversing the tree
+	if (localRay === null) {
+		localRay = _ray_1;
+		_mat4_1.copy(tiles3D.worldMatrix).inverse();
+		localRay.copy(ray).applyMatrix4(_mat4_1);
+	}
+
+	// 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;
+		}
+
+		const boundingVolume = child.cached.boundingVolume;
+
+		if (boundingVolume.intersectRay(localRay, _vec3_1)) {
+			_vec3_1.applyMatrix4(tiles3D.worldMatrix);
+			array.push({
+				distance: _vec3_1.distanceToSquared(ray.origin),
+				tile: child
+			});
+		}
+	}
+
+	// sort them by ascending distance
+	array.sort(distanceSort);
+
+	let bestHit = null;
+	let bestHitDistSq = Infinity;
+
+	// If the root is active make sure we've checked it
+	if (activeTiles.has(tile)) {
+		_intersectTileScene(tile, ray, _hitArray);
+
+		if (_hitArray.length > 0) {
+			if (_hitArray.length > 1) {
+				_hitArray.sort(distanceSort);
+			}
+
+			const hit = _hitArray[0];
+			_hitArray.length = 0;
+
+			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 distanceSquared = data.distance;
+		const tile = data.tile;
+
+		if (distanceSquared > bestHitDistSq) {
+			break;
+		}
+
+		const hit = raycastTraverseFirstHit(tile, tiles3D, ray, localRay);
+
+		if (hit) {
+			const hitDistSq = hit.distance * hit.distance;
+			if (hitDistSq < bestHitDistSq) {
+				bestHit = hit;
+				bestHitDistSq = hitDistSq;
+			}
+		}
+	}
+
+	return bestHit;
+};
+
+export const distanceSort = (a, b) => {
+	return a.distance - b.distance;
+};
+
+const _intersectTileScene = (tile, ray, intersects) => {
+	const scene = tile.cached.scene;
+
+	const lengthBefore = intersects.length;
+
+	scene.traverse(c => {
+		// We set the default raycast function to empty so t3d.js doesn't automatically cast against it
+		Object.getPrototypeOf(c).raycast.call(c, ray, intersects);
+	});
+
+	const lengthAfter = intersects.length;
+
+	// add the tile to intersects
+	if (lengthAfter > lengthBefore) {
+		for (let i = lengthBefore; i < lengthAfter; i++) {
+			intersects[i].tile = tile;
+		}
+	}
+};
+
+const _mat4_1 = new Matrix4();
+const _ray_1 = new Ray();
+const _vec3_1 = new Vector3();
+
+const _hitArray = [];

package/src/utils/LRUCache.js

@@ -0,0 +1,159 @@
+
+export class LRUCache {
+
+	constructor({ maxSize = 800, minSize = 600, unloadPercent = 0.05, unloadPriorityCallback = defaultPriorityCallback }) {
+		// options
+		this.maxSize = maxSize;
+		this.minSize = minSize;
+		this.unloadPercent = unloadPercent;
+
+		// "itemSet" doubles as both the list of the full set of items currently
+		// stored in the cache (keys) as well as a map to the time the item was last
+		// used so it can be sorted appropriately.
+		this.itemSet = new Map();
+		this.itemList = [];
+		this.usedSet = new Set();
+		this.callbacks = new Map();
+
+		this.scheduled = false;
+
+		this.unloadPriorityCallback = unloadPriorityCallback;
+	}
+
+	isFull() {
+		return this.itemSet.size >= this.maxSize;
+	}
+
+	add(item, removeCb) {
+		const itemSet = this.itemSet;
+		if (itemSet.has(item)) {
+			return false;
+		}
+
+		if (this.isFull()) {
+			return false;
+		}
+
+		const usedSet = this.usedSet;
+		const itemList = this.itemList;
+		const callbacks = this.callbacks;
+		itemList.push(item);
+		usedSet.add(item);
+		itemSet.set(item, Date.now());
+		callbacks.set(item, removeCb);
+
+		return true;
+	}
+
+	remove(item) {
+		const usedSet = this.usedSet;
+		const itemSet = this.itemSet;
+		const itemList = this.itemList;
+		const callbacks = this.callbacks;
+
+		if (itemSet.has(item)) {
+			callbacks.get(item)(item);
+
+			const index = itemList.indexOf(item);
+			itemList.splice(index, 1);
+			usedSet.delete(item);
+			itemSet.delete(item);
+			callbacks.delete(item);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	markUsed(item) {
+		const itemSet = this.itemSet;
+		const usedSet = this.usedSet;
+		if (!itemSet.has(item) || usedSet.has(item)) {
+			return false;
+		}
+
+		itemSet.set(item, Date.now());
+		usedSet.add(item);
+
+		return true;
+	}
+
+	markAllUnused() {
+		this.usedSet.clear();
+	}
+
+	unloadToMinSize() {
+		const unloadPercent = this.unloadPercent;
+		const targetSize = this.minSize;
+		const itemList = this.itemList;
+		const itemSet = this.itemSet;
+		const usedSet = this.usedSet;
+		const callbacks = this.callbacks;
+		const unused = itemList.length - usedSet.size;
+		const excess = itemList.length - targetSize;
+		const unloadPriorityCallback = this.unloadPriorityCallback;
+
+		if (excess <= 0 || unused <= 0) {
+			return false;
+		}
+
+		// used items should be at the end of the array
+		itemList.sort((a, b) => {
+			const usedA = usedSet.has(a);
+			const usedB = usedSet.has(b);
+			if (usedA && usedB) {
+				// If they're both used then don't bother moving them
+				return 0;
+			} else if (!usedA && !usedB) {
+				// Use the sort function otherwise
+				// higher priority should be further to the left
+				return unloadPriorityCallback(itemSet, b) - unloadPriorityCallback(itemSet, a);
+			} else {
+				// If one is used and the other is not move the used one towards the end of the array
+				return usedA ? 1 : -1;
+			}
+		});
+
+		// address corner cases where the minSize might be zero or smaller than maxSize - minSize,
+		// which would result in a very small or no items being unloaded.
+		const unusedExcess = Math.min(excess, unused);
+		const maxUnload = Math.max(targetSize * unloadPercent, unusedExcess * unloadPercent);
+		let nodesToUnload = Math.min(maxUnload, unused);
+		nodesToUnload = Math.ceil(nodesToUnload);
+
+		const removedItems = itemList.splice(0, nodesToUnload);
+		for (let i = 0, l = removedItems.length; i < l; i++) {
+			const item = removedItems[i];
+			callbacks.get(item)(item);
+			itemSet.delete(item);
+			callbacks.delete(item);
+		}
+
+		return true;
+	}
+
+	scheduleUnload(markAllUnused = true) {
+		if (this.scheduled) {
+			return false;
+		}
+
+		this.scheduled = true;
+		enqueueMicrotask(() => {
+			this.scheduled = false;
+			this.unloadToMinSize();
+			if (markAllUnused) {
+				this.markAllUnused();
+			}
+		});
+	}
+
+}
+
+const defaultPriorityCallback = (map, key) => {
+	return map.get(key);
+};
+
+const enqueueMicrotask = callback => {
+	Promise.resolve().then(callback);
+};

package/src/utils/ModelLoader.js

@@ -0,0 +1,150 @@
+
+import { Matrix4, Vector3 } from 't3d';
+import { B3DMLoader } from '../loaders/B3DMLoader.js';
+import { I3DMLoader } from '../loaders/I3DMLoader.js';
+import { PNTSLoader } from '../loaders/PNTSLoader.js';
+import { CMPTLoader } from '../loaders/CMPTLoader.js';
+import { TileGLTFLoader } from '../loaders/TileGLTFLoader.js';
+
+export class ModelLoader {
+
+	constructor(manager) {
+		const b3dmLoader = new B3DMLoader(manager);
+		const i3dmLoader = new I3DMLoader(manager);
+		const pntsLoader = new PNTSLoader(manager);
+		const cmptLoader = new CMPTLoader(manager);
+		const gltfLoader = new TileGLTFLoader(manager);
+
+		this._loaders = new Map([
+			['b3dm', b3dmLoader],
+			['i3dm', i3dmLoader],
+			['pnts', pntsLoader],
+			['cmpt', cmptLoader],
+			['gltf', gltfLoader],
+			['glb', gltfLoader]
+		]);
+	}
+
+	setDRACOLoader(dracoLoader) {
+		this._loaders.get('b3dm').setDRACOLoader(dracoLoader);
+		this._loaders.get('i3dm').setDRACOLoader(dracoLoader);
+		this._loaders.get('cmpt').setDRACOLoader(dracoLoader);
+		this._loaders.get('gltf').setDRACOLoader(dracoLoader);
+	}
+
+	setKTX2Loader(ktx2Loader) {
+		this._loaders.get('b3dm').setKTX2Loader(ktx2Loader);
+		this._loaders.get('i3dm').setKTX2Loader(ktx2Loader);
+		this._loaders.get('cmpt').setKTX2Loader(ktx2Loader);
+		this._loaders.get('gltf').setKTX2Loader(ktx2Loader);
+	}
+
+	loadTileContent(buffer, tile, extension, tiles3D) {
+		tile._loadIndex = tile._loadIndex || 0;
+		tile._loadIndex++;
+
+		const uri = tile.content.uri;
+		const uriSplits = uri.split(/[\\\/]/g); // eslint-disable-line no-useless-escape
+		uriSplits.pop();
+		const workingPath = uriSplits.join('/');
+		const fetchOptions = tiles3D.fetchOptions;
+
+		const loadIndex = tile._loadIndex;
+		let promise = null;
+
+		const upAxis = tiles3D.rootTileSet.asset && tiles3D.rootTileSet.asset.gltfUpAxis || 'y';
+		const cached = tile.cached;
+		const cachedTransform = cached.transform;
+
+		switch (upAxis.toLowerCase()) {
+			case 'x':
+				mat4_1.makeRotationAxis(Y_AXIS, -Math.PI / 2);
+				break;
+			case 'y':
+				mat4_1.makeRotationAxis(X_AXIS, Math.PI / 2);
+				break;
+			case 'z':
+				mat4_1.identity();
+				break;
+		}
+
+		const loader = this._loaders.get(extension);
+
+		if (loader) {
+			const config = {
+				fetchOptions,
+				path: workingPath,
+				buffer
+			};
+
+			if (extension === 'b3dm' || extension === 'i3dm' || extension === 'cmpt') {
+				config.adjustmentTransform = mat4_1.clone();
+			}
+
+			promise = loader.load(uri, config);
+		} else {
+			console.warn(`TilesRenderer: Content type "${extension}" not supported.`);
+			promise = Promise.resolve(null);
+		}
+
+		return promise.then(resource => {
+			const scene = resource.root;
+
+			if (tile._loadIndex !== loadIndex || !scene) {
+				return;
+			}
+
+			// ensure the matrix is up to date in case the scene has a transform applied
+			scene.updateMatrix();
+
+			// apply the local up-axis correction rotation
+			// GLTFLoader seems to never set a transformation on the root scene object so
+			// any transformations applied to it can be assumed to be applied after load
+			// (such as applying RTC_CENTER) meaning they should happen _after_ the z-up
+			// rotation fix which is why "multiply" happens here.
+			if (extension === 'glb' || extension === 'gltf') {
+				scene.matrix.multiply(mat4_1);
+			}
+
+			scene.matrix.premultiply(cachedTransform);
+			scene.matrix.decompose(scene.position, scene.quaternion, scene.scale);
+
+			cached.scene = scene;
+			cached.featureTable = resource.featureTable;
+			cached.batchTable = resource.batchTable;
+
+			const materials = [];
+			const geometry = [];
+			const textures = [];
+			scene.traverse(c => {
+				if (c.geometry) {
+					geometry.push(c.geometry);
+				}
+
+				if (c.material) {
+					const material = c.material;
+					materials.push(c.material);
+
+					for (const key in material) {
+						const value = material[key];
+						if (value && value.isTexture) {
+							textures.push(value);
+						}
+					}
+				}
+			});
+
+			cached.materials = materials;
+			cached.geometry = geometry;
+			cached.textures = textures;
+
+			return scene;
+		});
+	}
+
+}
+
+const mat4_1 = new Matrix4();
+
+const X_AXIS = new Vector3(1, 0, 0);
+const Y_AXIS = new Vector3(0, 1, 0);