easy-three-utils 0.0.1

package/src/tileRenderer/base/traverseFunctions.js

@@ -0,0 +1,468 @@
+import { LOADED, FAILED } from './constants.js';
+
+function isDownloadFinished(value) {
+
+	return value === LOADED || value === FAILED;
+
+}
+
+// Checks whether this tile was last used on the given frame.
+function isUsedThisFrame(tile, frameCount) {
+
+	return tile.__lastFrameVisited === frameCount && tile.__used;
+
+}
+
+// Resets the frame frame information for the given tile
+function resetFrameState(tile, renderer) {
+
+	if (tile.__lastFrameVisited !== renderer.frameCount) {
+
+		tile.__lastFrameVisited = renderer.frameCount;
+		tile.__used = false;
+		tile.__inFrustum = false;
+		tile.__isLeaf = false;
+		tile.__visible = false;
+		tile.__active = false;
+		tile.__error = Infinity;
+		tile.__distanceFromCamera = Infinity;
+		tile.__childrenWereVisible = false;
+		tile.__allChildrenLoaded = false;
+
+		// update tile frustum and error state
+		tile.__inFrustum = renderer.tileInView(tile);
+		renderer.calculateError(tile);
+
+	}
+
+}
+
+// Recursively mark tiles used down to the next tile with content
+function recursivelyMarkUsed(tile, renderer) {
+
+	renderer.ensureChildrenArePreprocessed(tile);
+
+	resetFrameState(tile, renderer);
+	markUsed(tile, renderer);
+
+	if (!tile.__hasRenderableContent) {
+
+		const children = tile.children;
+		for (let i = 0, l = children.length; i < l; i++) {
+
+			recursivelyMarkUsed(children[i], renderer);
+
+		}
+
+	}
+
+}
+
+// Recursively traverses to the next tiles with unloaded renderable content to load them
+function recursivelyLoadNextRenderableTiles(tile, renderer) {
+
+	renderer.ensureChildrenArePreprocessed(tile);
+
+	// Try to load any external tile set children if the external tile set has loaded.
+	const doTraverse =
+		isUsedThisFrame(tile, renderer.frameCount) &&
+		!tile.__hasRenderableContent && (
+			!tile.__hasContent ||
+			isDownloadFinished(tile.__loadingState)
+		);
+
+	if (doTraverse) {
+
+		const children = tile.children;
+		for (let i = 0, l = children.length; i < l; i++) {
+
+			// don't increment depth to rendered parent here because we should treat
+			// the next layer of rendered children as just a single depth away for the
+			// sake of sorting.
+			const child = children[i];
+			recursivelyLoadNextRenderableTiles(child, renderer);
+
+		}
+
+	} else if (isUsedThisFrame(tile, renderer.frameCount) && !renderer.lruCache.isFull()) {
+		renderer.queueTileForDownload(tile);
+
+	}
+
+}
+
+// Mark a tile as being used by current view
+function markUsed(tile, renderer) {
+
+	if (tile.__used) {
+
+		return;
+
+	}
+
+	tile.__used = true;
+	renderer.lruCache.markUsed(tile);
+	renderer.stats.used++;
+
+	if (tile.__inFrustum === true) {
+
+		renderer.stats.inFrustum++;
+
+	}
+
+}
+
+// Returns whether the tile can be traversed to the next layer of children by checking the tile metrics
+function canTraverse(tile, renderer) {
+
+	// If we've met the error requirements then don't load further
+	if (tile.__error <= renderer.errorTarget) {
+
+		return false;
+
+	}
+
+	// Early out if we've reached the maximum allowed depth.
+	if (renderer.maxDepth > 0 && tile.__depth + 1 >= renderer.maxDepth) {
+
+		return false;
+
+	}
+
+	return true;
+
+}
+
+// Helper function for recursively traversing a tile set. If `beforeCb` returns `true` then the
+// traversal will end early.
+export function traverseSet(tile, beforeCb = null, afterCb = null, parent = null, depth = 0) {
+
+	if (beforeCb && beforeCb(tile, parent, depth)) {
+
+		if (afterCb) {
+
+			afterCb(tile, parent, depth);
+
+		}
+
+		return;
+
+	}
+
+	const children = tile.children;
+	for (let i = 0, l = children.length; i < l; i++) {
+
+		traverseSet(children[i], beforeCb, afterCb, tile, depth + 1);
+
+	}
+
+	if (afterCb) {
+
+		afterCb(tile, parent, depth);
+
+	}
+
+}
+
+// Determine which tiles are used by the renderer given the current camera configuration
+export function markUsedTiles(tile, renderer) {
+
+	// determine frustum set is run first so we can ensure the preprocessing of all the necessary
+	// child tiles has happened here.
+	renderer.ensureChildrenArePreprocessed(tile);
+
+	resetFrameState(tile, renderer);
+
+	if (!tile.__inFrustum) {
+
+		return;
+
+	}
+
+	if (!canTraverse(tile, renderer)) {
+
+		markUsed(tile, renderer);
+		return;
+
+	}
+
+	// Traverse children and see if any children are in view.
+	let anyChildrenUsed = false;
+	let anyChildrenInFrustum = false;
+	const children = tile.children;
+	for (let i = 0, l = children.length; i < l; i++) {
+
+		const c = children[i];
+		markUsedTiles(c, renderer);
+		anyChildrenUsed = anyChildrenUsed || isUsedThisFrame(c, renderer.frameCount);
+		anyChildrenInFrustum = anyChildrenInFrustum || c.__inFrustum;
+
+	}
+
+	// Disabled for now because this will cause otherwise unused children to be added to the lru cache
+	// if none of the children are in the frustum then this tile shouldn't be displayed
+	if (tile.refine === 'REPLACE' && !anyChildrenInFrustum && children.length !== 0 && !tile.__hasUnrenderableContent) {
+
+		// TODO: we're not checking tiles with unrenderable content here since external tile sets might look like they're in the frustum,
+		// load the children, then the children indicate that it's not visible, causing it to be unloaded. Then it will be loaded again.
+		// The impact when including external tile set roots in the check is more significant but can't be used unless we keep external tile
+		// sets around even when they're not needed. See issue #741.
+
+		// TODO: what if we mark the tile as not in the frustum but we _do_ mark it as used? Then we can stop frustum traversal and at least
+		// prevent tiles from rendering unless they're needed.
+		tile.__inFrustum = false;
+		return;
+
+	}
+
+	// wait until after the above condition to mark the traversed tile as used or not
+	markUsed(tile, renderer);
+
+	// If this is a tile that needs children loaded to refine then recursively load child
+	// tiles until error is met
+	if (anyChildrenUsed && tile.refine === 'REPLACE') {
+
+		for (let i = 0, l = children.length; i < l; i++) {
+
+			const c = children[i];
+			recursivelyMarkUsed(c, renderer);
+
+		}
+
+	}
+
+}
+
+// Traverse and mark the tiles that are at the leaf nodes of the "used" tree.
+export function markUsedSetLeaves(tile, renderer) {
+
+	const frameCount = renderer.frameCount;
+	if (!isUsedThisFrame(tile, frameCount)) {
+
+		return;
+
+	}
+
+	// This tile is a leaf if none of the children had been used.
+	const children = tile.children;
+	let anyChildrenUsed = false;
+	for (let i = 0, l = children.length; i < l; i++) {
+
+		const c = children[i];
+		anyChildrenUsed = anyChildrenUsed || isUsedThisFrame(c, frameCount);
+
+	}
+
+	if (!anyChildrenUsed) {
+
+		tile.__isLeaf = true;
+
+	} else {
+
+		let childrenWereVisible = false;
+		let allChildrenLoaded = true;
+		for (let i = 0, l = children.length; i < l; i++) {
+
+			const c = children[i];
+			markUsedSetLeaves(c, renderer);
+			childrenWereVisible = childrenWereVisible || c.__wasSetVisible || c.__childrenWereVisible;
+
+			if (isUsedThisFrame(c, frameCount)) {
+
+				// consider a child to be loaded if
+				// - the children's children have been loaded
+				// - the tile content has loaded
+				// - the tile is completely empty - ie has no children and no content
+				// - the child tile set has tried to load but failed
+				const childLoaded =
+					c.__allChildrenLoaded ||
+					(c.__hasRenderableContent && isDownloadFinished(c.__loadingState)) ||
+					(!c.__hasContent && c.children.length === 0) ||
+					(c.__hasUnrenderableContent && c.__loadingState === FAILED);
+				allChildrenLoaded = allChildrenLoaded && childLoaded;
+
+			}
+
+		}
+
+		tile.__childrenWereVisible = childrenWereVisible;
+		tile.__allChildrenLoaded = allChildrenLoaded;
+
+	}
+
+}
+
+// TODO: revisit implementation
+// Skip past tiles we consider unrenderable because they are outside the error threshold.
+export function markVisibleTiles(tile, renderer) {
+
+	const stats = renderer.stats;
+
+	if (!isUsedThisFrame(tile, renderer.frameCount)) {
+
+		return;
+
+	}
+	// Request the tile contents or mark it as visible if we've found a leaf.
+	const lruCache = renderer.lruCache;
+
+	if (tile.__isLeaf) {
+
+		if (tile.__loadingState === LOADED) {
+
+			if (tile.__inFrustum) {
+
+				tile.__visible = true;
+				stats.visible++;
+
+			}
+			tile.__active = true;
+			stats.active++;
+
+
+
+		} else if (!lruCache.isFull() && tile.__hasContent) {
+			renderer.queueTileForDownload(tile);
+		}
+
+		return;
+
+	}
+
+	const children = tile.children;
+	const hasContent = tile.__hasContent;
+	const loadedContent = isDownloadFinished(tile.__loadingState) && hasContent;
+	const errorRequirement = (renderer.errorTarget + 1) * renderer.errorThreshold;
+	const meetsSSE = tile.__error <= errorRequirement;
+	const childrenWereVisible = tile.__childrenWereVisible;
+
+	// NOTE: We can "trickle" root tiles in by enabling these lines.
+	// Don't wait for all children tiles to load if this tile set has empty tiles at the root
+	// const emptyRootTile = tile.__depthFromRenderedParent === 0;
+	// const allChildrenLoaded = tile.__allChildrenLoaded || emptyRootTile;
+
+	// If we've met the SSE requirements and we can load content then fire a fetch.
+	const allChildrenLoaded = tile.__allChildrenLoaded;
+	const includeTile = meetsSSE || tile.refine === 'ADD';
+	// console.log(includeTile , !loadedContent , !lruCache.isFull() , hasContent);
+
+	if (includeTile && !loadedContent && !lruCache.isFull() && hasContent) {
+		
+		renderer.queueTileForDownload(tile);
+
+	}
+
+	// Only mark this tile as visible if it meets the screen space error requirements, has loaded content, not
+	// all children have loaded yet, and if no children were visible last frame. We want to keep children visible
+	// that _were_ visible to avoid a pop in level of detail as the camera moves around and parent / sibling tiles
+	// load in.
+
+	// Skip the tile entirely if there's no content to load
+	if (
+		(meetsSSE && !allChildrenLoaded && !childrenWereVisible && loadedContent)
+		|| (tile.refine === 'ADD' && loadedContent)
+	) {
+
+		if (tile.__inFrustum) {
+
+			tile.__visible = true;
+			stats.visible++;
+
+		}
+		tile.__active = true;
+		stats.active++;
+
+	}
+
+	// If we're additive then don't stop the traversal here because it doesn't matter whether the children load in
+	// at the same rate.
+
+	if (tile.refine === 'REPLACE' && meetsSSE && !allChildrenLoaded) {
+
+		// load the child content if we've found that we've been loaded so we can move down to the next tile
+		// layer when the data has loaded.
+		for (let i = 0, l = children.length; i < l; i++) {
+
+			const c = children[i];
+			if (isUsedThisFrame(c, renderer.frameCount)) {
+
+				recursivelyLoadNextRenderableTiles(c, renderer);
+
+			}
+
+		}
+
+	} else {
+
+		for (let i = 0, l = children.length; i < l; i++) {
+
+			markVisibleTiles(children[i], renderer);
+
+		}
+
+	}
+
+}
+
+// Final traverse to toggle tile visibility.
+export function toggleTiles(tile, renderer) {
+
+	const isUsed = isUsedThisFrame(tile, renderer.frameCount);
+	if (isUsed || tile.__usedLastFrame) {
+
+		let setActive = false;
+		let setVisible = false;
+		if (isUsed) {
+
+			// enable visibility if active due to shadows
+			setActive = tile.__active;
+			if (renderer.displayActiveTiles) {
+
+				setVisible = tile.__active || tile.__visible;
+
+			} else {
+
+				setVisible = tile.__visible;
+
+			}
+
+		} else {
+
+			// if the tile was used last frame but not this one then there's potential for the tile
+			// to not have been visited during the traversal, meaning it hasn't been reset and has
+			// stale values. This ensures the values are not stale.
+			resetFrameState(tile, renderer);
+
+		}
+
+		// If the active or visible state changed then call the functions.
+		if (tile.__hasRenderableContent && tile.__loadingState === LOADED) {
+
+			if (tile.__wasSetActive !== setActive) {
+
+				renderer.setTileActive(tile, setActive);
+
+			}
+
+			if (tile.__wasSetVisible !== setVisible) {
+
+				renderer.setTileVisible(tile, setVisible);
+
+			}
+
+		}
+		tile.__wasSetActive = setActive;
+		tile.__wasSetVisible = setVisible;
+		tile.__usedLastFrame = isUsed;
+
+		const children = tile.children;
+		for (let i = 0, l = children.length; i < l; i++) {
+
+			const c = children[i];
+			toggleTiles(c, renderer);
+
+		}
+
+	}
+
+}

package/src/tileRenderer/gltf.js

@@ -0,0 +1,144 @@
+import { GLTFExtensionLoader } from '..';
+import {
+	Scene,
+	DirectionalLight,
+	AmbientLight,
+	WebGLRenderer,
+	PerspectiveCamera,
+	PCFSoftShadowMap,
+} from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import { LoadingManager } from 'three';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+
+let camera, controls, scene, renderer;
+let dirLight;
+
+init();
+animate();
+
+function init() {
+
+	scene = new Scene();
+
+	// primary camera view
+	renderer = new WebGLRenderer({ antialias: true });
+	renderer.setPixelRatio(window.devicePixelRatio);
+	renderer.setSize(window.innerWidth, window.innerHeight);
+	renderer.setClearColor(0x151c1f);
+	renderer.shadowMap.enabled = true;
+	renderer.shadowMap.type = PCFSoftShadowMap;
+
+	document.body.appendChild(renderer.domElement);
+
+	camera = new PerspectiveCamera(60, window.innerWidth / window.innerHeight, 1, 4000);
+	camera.position.set(3, 10, 20);
+
+	// controls
+	controls = new OrbitControls(camera, renderer.domElement);
+	controls.screenSpacePanning = false;
+	controls.minDistance = 1;
+	controls.maxDistance = 2000;
+
+	// lights
+	dirLight = new DirectionalLight(0xffffff, 1.25);
+	dirLight.position.set(1, 2, 3).multiplyScalar(40);
+	dirLight.castShadow = true;
+	dirLight.shadow.bias = - 0.01;
+	dirLight.shadow.mapSize.setScalar(2048);
+
+	const shadowCam = dirLight.shadow.camera;
+	shadowCam.left = - 200;
+	shadowCam.bottom = - 200;
+	shadowCam.right = 200;
+	shadowCam.top = 200;
+	shadowCam.updateProjectionMatrix();
+	scene.add(dirLight);
+
+	const ambLight = new AmbientLight(0xffffff, 0.05);
+	scene.add(ambLight);
+
+	// basic gltf test files
+	let insertPosition = 0;
+	const gltfModelTests = [
+		'https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/master/2.0/CesiumMilkTruck/glTF-Binary/CesiumMilkTruck.glb',
+		'https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/master/2.0/CesiumMilkTruck/glTF-Embedded/CesiumMilkTruck.gltf',
+		'https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/master/2.0/CesiumMilkTruck/glTF/CesiumMilkTruck.gltf',
+	];
+
+	for (const url of gltfModelTests) {
+
+		const loader = new GLTFExtensionLoader();
+		loader.workingPath = loader.workingPathForURL(url);
+		loader.loadAsync(url)
+			.then(res => {
+
+				res.scene.position.set(insertPosition += 5, 0, 0);
+				controls.target.set(insertPosition / 2, 0, 0);
+				controls.update();
+				console.log('default loader:', { gltf: res, url });
+				scene.add(res.scene);
+
+			});
+
+	}
+
+	// gltf with extensions
+	const delegatedLoaderTests = [
+		'https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/master/2.0/CesiumMilkTruck/glTF-Draco/CesiumMilkTruck.gltf',
+		'https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/master/2.0/Box/glTF-Binary/Box.glb',
+	];
+
+	const manager = new LoadingManager();
+	const gltfLoader = new GLTFLoader(manager);
+	const dracoLoader = new DRACOLoader(manager);
+	dracoLoader.setDecoderPath('https://unpkg.com/three@0.153.0/examples/jsm/libs/draco/gltf/');
+	gltfLoader.setDRACOLoader(dracoLoader);
+	manager.addHandler(/\.gltf$/, gltfLoader);
+	manager.addHandler(/\.glb$/, gltfLoader);
+
+	for (const url of delegatedLoaderTests) {
+
+		const loader = new GLTFExtensionLoader(manager);
+		loader.workingPath = loader.workingPathForURL(url);
+		loader.loadAsync(url)
+			.then(res => {
+
+				res.scene.position.set(insertPosition += 5, 0, 0);
+				controls.target.set(insertPosition / 2, 0, 0);
+				controls.update();
+				console.log('custom loader:', { gltf: res, url });
+				scene.add(res.scene);
+
+			});
+
+	}
+
+	onWindowResize();
+	window.addEventListener('resize', onWindowResize, false);
+
+}
+
+function onWindowResize() {
+
+	camera.aspect = window.innerWidth / window.innerHeight;
+	renderer.setPixelRatio(window.devicePixelRatio);
+	renderer.setSize(window.innerWidth, window.innerHeight);
+	camera.updateProjectionMatrix();
+
+}
+
+function animate() {
+
+	requestAnimationFrame(animate);
+
+	render();
+
+}
+
+function render() {
+
+	renderer.render(scene, camera);
+
+}

package/src/tileRenderer/index.d.ts

@@ -0,0 +1,41 @@
+// three.js
+export { DebugTilesRenderer } from './three/DebugTilesRenderer';
+export { TilesRenderer } from './three/TilesRenderer';
+export { TilesGroup } from './three/TilesGroup';
+export { B3DMLoader, B3DMScene } from './three/loaders/B3DMLoader';
+export { I3DMLoader, I3DMScene } from './three/loaders/I3DMLoader';
+export { PNTSLoader, PNTSScene } from './three/loaders/PNTSLoader';
+export { CMPTLoader } from './three/loaders/CMPTLoader';
+export { GLTFCesiumRTCExtension } from './three/loaders/gltf/GLTFCesiumRTCExtension';
+export { GLTFExtensionLoader } from './three/loaders/GLTFExtensionLoader';
+export { Ellipsoid } from './three/math/Ellipsoid';
+export { EllipsoidRegion } from './three/math/EllipsoidRegion';
+export * as GeoUtils from './three/math/GeoUtils';
+export * from './three/math/GeoConstants';
+export * from './three/renderers/GoogleTilesRenderer';
+export * from './three/renderers/CesiumIonTilesRenderer';
+
+// three.js plugins
+export { CesiumIonAuthPlugin } from './three/plugins/CesiumIonAuthPlugin';
+export { GoogleCloudAuthPlugin } from './three/plugins/GoogleCloudAuthPlugin';
+export * from './three/plugins/DebugTilesPlugin';
+
+// common plugins
+export { ImplicitTilingPlugin } from './base/plugins/ImplicitTilingPlugin';
+
+// common
+export { TilesRendererBase } from './base/TilesRendererBase';
+export { Tile } from './base/Tile';
+export { TileBase } from './base/TileBase';
+export { Tileset } from './base/Tileset';
+export { B3DMLoaderBase } from './base/loaders/B3DMLoaderBase';
+export { I3DMLoaderBase } from './base/loaders/I3DMLoaderBase';
+export { PNTSLoaderBase } from './base/loaders/PNTSLoaderBase';
+export { CMPTLoaderBase } from './base/loaders/CMPTLoaderBase';
+export { LoaderBase } from './base/loaders/LoaderBase';
+export * from './base/constants';
+
+export { LRUCache } from './utilities/LRUCache';
+export { PriorityQueue } from './utilities/PriorityQueue';
+export { BatchTable } from './utilities/BatchTable';
+export { FeatureTable } from './utilities/FeatureTable';

package/src/tileRenderer/index.js

@@ -0,0 +1,44 @@
+// three.js
+export { DebugTilesRenderer } from './three/DebugTilesRenderer.js';
+export { TilesRenderer } from './three/TilesRenderer.js';
+export { B3DMLoader } from './three/loaders/B3DMLoader.js';
+export { PNTSLoader } from './three/loaders/PNTSLoader.js';
+export { I3DMLoader } from './three/loaders/I3DMLoader.js';
+export { CMPTLoader } from './three/loaders/CMPTLoader.js';
+export { GLTFCesiumRTCExtension } from './three/loaders/gltf/GLTFCesiumRTCExtension.js';
+export { GLTFStructuralMetadataExtension } from './three/loaders/gltf/GLTFStructuralMetadataExtension.js';
+export { GLTFMeshFeaturesExtension } from './three/loaders/gltf/GLTFMeshFeaturesExtension.js';
+export { GLTFExtensionLoader } from './three/loaders/GLTFExtensionLoader.js';
+
+export * from './three/math/Ellipsoid.js';
+export * from './three/math/EllipsoidRegion.js';
+export * as GeoUtils from './three/math/GeoUtils.js';
+export * from './three/math/GeoConstants.js';
+export * from './three/renderers/GoogleTilesRenderer.js';
+export * from './three/renderers/CesiumIonTilesRenderer.js';
+
+// three.js controls
+export { GlobeControls } from './three/controls/GlobeControls.js';
+export { EnvironmentControls } from './three/controls/EnvironmentControls.js';
+export { CameraTransitionManager } from './three/controls/CameraTransitionManager.js';
+
+// three.js plugins
+export { CesiumIonAuthPlugin } from './three/plugins/CesiumIonAuthPlugin.js';
+export { GoogleCloudAuthPlugin } from './three/plugins/GoogleCloudAuthPlugin.js';
+export * from './three/plugins/DebugTilesPlugin.js';
+
+// common plugins
+export { ImplicitTilingPlugin } from './base/plugins/ImplicitTilingPlugin.js';
+
+// common
+export { TilesRendererBase } from './base/TilesRendererBase.js';
+export { LoaderBase } from './base/loaders/LoaderBase.js';
+export { B3DMLoaderBase } from './base/loaders/B3DMLoaderBase.js';
+export { I3DMLoaderBase } from './base/loaders/I3DMLoaderBase.js';
+export { PNTSLoaderBase } from './base/loaders/PNTSLoaderBase.js';
+export { CMPTLoaderBase } from './base/loaders/CMPTLoaderBase.js';
+export * from './base/constants.js';
+
+export { LRUCache } from './utilities/LRUCache.js';
+export { PriorityQueue } from './utilities/PriorityQueue.js';
+