itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/Parser/iGLTFLoader.js

@@ -0,0 +1,168 @@
+import * as THREE from 'three';
+import LegacyGLTFLoader from "./deprecated/LegacyGLTFLoader.js";
+import { GLTFLoader } from "../ThreeExtended/loaders/GLTFLoader.js";
+class iGLTFLoader extends THREE.Loader {
+  /**
+   * Parses [glTF](https://www.khronos.org/gltf/) 1.0 and 2.0 files.
+   *
+   * Under the hood, glTF 2.0 files are parsed with THREE.GLTFLoader and GLTF 1.0 are parsed with the previous THREE
+   * GltfLoader (for 1.0 glTF) that has been kept and maintained in iTowns.
+   *
+   * Beware that gltf convention is y-up while itowns is z-up. You can apply a PI/2 rotation around the X axis to the
+   * loaded model to transform from y-up to z-up. Note that you can also use Coordinates.geodesicNormal to get the normal
+   * to a position on the globe (i.e. in GlobeView) to correctly orient a model on a GlobeView.
+   *
+   * @param {THREE.LoadingManager} [manager] - The loadingManager for the loader to use. Default is THREE.DefaultLoadingManager.
+   */
+  constructor(manager) {
+    super(manager);
+    this.legacyGLTFLoader = new LegacyGLTFLoader();
+    this.glTFLoader = new GLTFLoader();
+  }
+
+  /**
+   * Loads a gltf model from url and call the callback function with the parsed response content.
+   * Adapted from threejs.
+   * @param {String} url - the path/URL of the .gltf or .glb file.
+   * @param {Function} onLoad - A function to be called after the loading is successfully completed. The function
+   * receives the loaded JSON response returned from {@link parse}.
+   * @param {Function} onProgress
+   * @param {Function} onError
+   */
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    let resourcePath;
+    if (this.resourcePath !== '') {
+      resourcePath = this.resourcePath;
+    } else if (this.path !== '') {
+      // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
+      // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
+      // resourcePath = 'https://my-cnd-server.com/assets/models/'
+      // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
+      // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
+      const relativeUrl = THREE.LoaderUtils.extractUrlBase(url);
+      resourcePath = THREE.LoaderUtils.resolveURL(relativeUrl, this.path);
+    } else {
+      resourcePath = THREE.LoaderUtils.extractUrlBase(url);
+    }
+
+    // Tells the LoadingManager to track an extra item, which resolves after
+    // the model is fully loaded. This means the count of items loaded will
+    // be incorrect, but ensures manager.onLoad() does not fire early.
+    this.manager.itemStart(url);
+    const _onError = e => {
+      if (onError) {
+        onError(e);
+      } else {
+        console.error(e);
+      }
+      scope.manager.itemError(url);
+      scope.manager.itemEnd(url);
+    };
+    const loader = new THREE.FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType('arraybuffer');
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(url, data => {
+      try {
+        scope.parse(data, resourcePath, gltf => {
+          onLoad(gltf);
+          scope.manager.itemEnd(url);
+        }, _onError);
+      } catch (e) {
+        _onError(e);
+      }
+    }, onProgress, _onError);
+  }
+
+  /**
+   * Sets the draco loader instance for this gltf parser. Enable loading files with
+   * [Draco](https://google.github.io/draco/) geometry extension. See Threejs
+   * [DracoLoader](https://threejs.org/docs/index.html#examples/en/loaders/DRACOLoader) for more information.
+   * Only works for GLTF 2.0 files.
+   * @param {THREE.DracoLoader} dracoLoader - the threejs DracoLoader instance.
+   */
+  setDRACOLoader(dracoLoader) {
+    this.glTFLoader.setDRACOLoader(dracoLoader);
+  }
+
+  /**
+   * Sets the KTX2 loader instance for this gltf parser. Enable loading files with
+   * [KTX2](https://www.khronos.org/ktx/) texture extension. See Threejs
+   * [KTX2Loader](https://threejs.org/docs/index.html?q=KTX2#examples/en/loaders/KTX2Loader) for more information.
+   * Only works for GLTF 2.0 files.
+   * @param {THREE.KTX2Loader} ktx2Loader - the threejs KTX2Loader instance.
+   */
+  setKTX2Loader(ktx2Loader) {
+    this.glTFLoader.setKTX2Loader(ktx2Loader);
+  }
+
+  /**
+   * Sets the Mesh Optimizer decoder instance for this gltf parser. Enable loading files with
+   * [MeshOptimizer](https://meshoptimizer.org/) geometry extension.
+   * Only works for GLTF 2.0 files.
+   * @param {Object} meshoptDecoder - the threejs meshopt decoder instance.
+   */
+  setMeshoptDecoder(meshoptDecoder) {
+    this.glTFLoader.setMeshoptDecoder(meshoptDecoder);
+  }
+
+  /**
+   * Registers a callback to load specific unknown or not standard GLTF extensions.
+   * See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more
+   * information.
+   * @param {Function} callback - the callback function
+   */
+  register(callback) {
+    this.glTFLoader.register(callback);
+  }
+
+  /**
+   * Unregisters a load callback.
+   * See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more
+   * information.
+   * @param {Function} callback - the callback function
+   */
+  unregister(callback) {
+    this.glTFLoader.unregister(callback);
+  }
+
+  /** Parse a glTF-based ArrayBuffer, JSON string or object and fire onLoad callback when complete.
+   * Calls Threejs [GLTFLoader.parse](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader.parse) for
+   * glTF 2.0 files and LegacyGLTFLoader.parse for gtTF 1.0 files.
+   * @param {ArrayBuffer|String|Object} buffer - the glTF asset to parse, as an ArrayBuffer, JSON string or object.
+   * @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.
+   * @param {Function} onLoad — A function to be called when parse completes. The argument to the onLoad function will
+   * be an Object that contains loaded parts: .scene, .scenes, .cameras, .animations, and .asset.
+   * @param {Function} [onError] — A function to be called if an error occurs during parsing. The function receives error as an argument.
+   */
+  parse(buffer, path, onLoad, onError) {
+    if (!buffer || !path) {
+      onError('[iGLTFLoader]: Buffer and path are mandatory to parse a glTF.');
+      return;
+    }
+    const headerView = new DataView(buffer, 0, 20);
+    const version = headerView.getUint32(4, true);
+    if (version === 1) {
+      this.legacyGLTFLoader.parse(buffer, path, onLoad, onError);
+    } else {
+      this.glTFLoader.parse(buffer, path, onLoad, onError);
+    }
+  }
+
+  /**
+   * Async promise-based parsing of a glTF-based ArrayBuffer, JSON string or object.
+   * @param {ArrayBuffer|String|Object} data - the glTF asset to parse, as an ArrayBuffer, JSON string or object.
+   * @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.
+   * @returns {Promise<Object>} A promise that resolves an Object that contains loaded parts:
+   * .scene, .scenes, .cameras, .animations, and .asset, when parsing is done.
+   */
+  parseAsync(data, path) {
+    const scope = this;
+    return new Promise((resolve, reject) => {
+      scope.parse(data, path, resolve, reject);
+    });
+  }
+}
+export default iGLTFLoader;

package/lib/Process/3dTilesProcessing.js

@@ -0,0 +1,304 @@
+import * as THREE from 'three';
+import ObjectRemovalHelper from "./ObjectRemovalHelper.js";
+import { C3DTilesBoundingVolumeTypes } from "../Core/3DTiles/C3DTilesEnums.js";
+import { C3DTILES_LAYER_EVENTS } from "../Layer/C3DTilesLayer.js";
+
+/** @module 3dTilesProcessing
+*/
+
+function requestNewTile(view, scheduler, geometryLayer, metadata, parent, redraw) {
+  const command = {
+    /* mandatory */
+    view,
+    requester: parent,
+    layer: geometryLayer,
+    priority: parent ? 1.0 / (parent.distance + 1) : 100,
+    /* specific params */
+    metadata,
+    redraw
+  };
+  geometryLayer.dispatchEvent({
+    type: C3DTILES_LAYER_EVENTS.ON_TILE_REQUESTED,
+    metadata
+  });
+  return scheduler.execute(command);
+}
+function getChildTiles(tile) {
+  // only keep children that have the same layer and a valid tileId
+  return tile.children.filter(n => n.layer == tile.layer && n.tileId);
+}
+function subdivideNode(context, layer, node, cullingTest) {
+  if (node.additiveRefinement) {
+    // Additive refinement can only fetch visible children.
+    _subdivideNodeAdditive(context, layer, node, cullingTest);
+  } else {
+    // Substractive refinement on the other hand requires to replace
+    // node with all of its children
+    _subdivideNodeSubstractive(context, layer, node);
+  }
+}
+const tmpMatrix = new THREE.Matrix4();
+function _subdivideNodeAdditive(context, layer, node, cullingTest) {
+  for (const child of layer.tileset.tiles[node.tileId].children) {
+    // child being downloaded => skip
+    if (child.promise || child.loaded) {
+      continue;
+    }
+
+    // 'child' is only metadata (it's *not* a THREE.Object3D). 'cullingTest' needs
+    // a matrixWorld, so we compute it: it's node's matrixWorld x child's transform
+    let overrideMatrixWorld = node.matrixWorld;
+    if (child.transform) {
+      overrideMatrixWorld = tmpMatrix.multiplyMatrices(node.matrixWorld, child.transform);
+    }
+    const isVisible = cullingTest ? !cullingTest(layer, context.camera, child, overrideMatrixWorld) : true;
+
+    // child is not visible => skip
+    if (!isVisible) {
+      continue;
+    }
+    child.promise = requestNewTile(context.view, context.scheduler, layer, child, node, true).then(tile => {
+      node.add(tile);
+      tile.updateMatrixWorld();
+      layer.onTileContentLoaded(tile);
+      context.view.notifyChange(child);
+      child.loaded = true;
+      delete child.promise;
+    });
+  }
+}
+function _subdivideNodeSubstractive(context, layer, node) {
+  if (!node.pendingSubdivision && getChildTiles(node).length == 0) {
+    const childrenTiles = layer.tileset.tiles[node.tileId].children;
+    if (childrenTiles === undefined || childrenTiles.length === 0) {
+      return;
+    }
+    node.pendingSubdivision = true;
+    const promises = [];
+    for (let i = 0; i < childrenTiles.length; i++) {
+      promises.push(requestNewTile(context.view, context.scheduler, layer, childrenTiles[i], node, false).then(tile => {
+        childrenTiles[i].loaded = true;
+        node.add(tile);
+        tile.updateMatrixWorld();
+        // TODO: remove because cannot happen?
+        if (node.additiveRefinement) {
+          context.view.notifyChange(node);
+        }
+        layer.tileset.tiles[tile.tileId].loaded = true;
+        layer.onTileContentLoaded(tile);
+      }));
+    }
+    Promise.all(promises).then(() => {
+      node.pendingSubdivision = false;
+      context.view.notifyChange(node);
+    });
+  }
+}
+
+/**
+ * Check if the node is visible in the camera.
+ *
+ * @param      {C3DTilesLayer} layer       node 3D tiles layer
+ * @param      {Camera}   camera           camera
+ * @param      {THREE.Object3D}   node             The 3d tile node to check.
+ * @param      {THREE.Matrix4}   tileMatrixWorld  The node matrix world
+ * @return     {boolean}  return true if the node is visible
+ */
+export function $3dTilesCulling(layer, camera, node, tileMatrixWorld) {
+  // For viewer Request Volume
+  // https://github.com/AnalyticalGraphicsInc/3d-tiles-samples/tree/master/tilesets/TilesetWithRequestVolume
+  if (node.viewerRequestVolume && node.viewerRequestVolume.viewerRequestVolumeCulling(camera, tileMatrixWorld)) {
+    return true;
+  }
+
+  // For bounding volume
+  return !!(node.boundingVolume && node.boundingVolume.boundingVolumeCulling(camera, tileMatrixWorld));
+}
+
+// Cleanup all 3dtiles|three.js starting from a given node n.
+// n's children can be of 2 types:
+//   - have a 'content' attribute -> it's a tileset and must
+//     be cleaned with cleanup3dTileset()
+//   - doesn't have 'content' -> it's a raw Object3D object,
+//     and must be cleaned with _cleanupObject3D()
+function cleanup3dTileset(layer, n) {
+  let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  // If this layer is not using additive refinement, we can only
+  // clean a tile if all its neighbours are cleaned as well because
+  // a tile can only be in 2 states:
+  //   - displayed and no children displayed
+  //   - hidden and all of its children displayed
+  // So here we implement a conservative measure: if T is cleanable
+  // we actually only clean its children tiles.
+  const canCleanCompletely = n.additiveRefinement || depth > 0;
+  for (let i = 0; i < n.children.length; i++) {
+    // skip non-tiles elements
+    if (!n.children[i].content) {
+      if (canCleanCompletely) {
+        ObjectRemovalHelper.removeChildrenAndCleanupRecursively(n.children[i].layer, n.children[i]);
+      }
+    } else {
+      cleanup3dTileset(layer, n.children[i], depth + 1);
+    }
+  }
+  if (canCleanCompletely) {
+    if (n.dispose) {
+      n.dispose();
+    }
+    delete n.content;
+    layer.tileset.tiles[n.tileId].loaded = false;
+    n.remove(...n.children);
+
+    // and finally remove from parent
+    if (depth == 0 && n.parent) {
+      n.parent.remove(n);
+    }
+  } else {
+    const tiles = getChildTiles(n);
+    n.remove(...tiles);
+  }
+}
+
+// this is a layer
+export function pre3dTilesUpdate(context) {
+  if (!this.visible) {
+    return [];
+  }
+  this.scale = context.camera._preSSE;
+
+  // Elements removed are added in the layer._cleanableTiles list.
+  // Since we simply push in this array, the first item is always
+  // the oldest one.
+  const now = Date.now();
+  if (this._cleanableTiles.length && now - this._cleanableTiles[0].cleanableSince > this.cleanupDelay) {
+    // Make sure we don't clean root tile
+    this.root.cleanableSince = undefined;
+    let i = 0;
+    for (; i < this._cleanableTiles.length; i++) {
+      const elt = this._cleanableTiles[i];
+      if (now - elt.cleanableSince > this.cleanupDelay) {
+        cleanup3dTileset(this, elt);
+      } else {
+        // later entries are younger
+        break;
+      }
+    }
+    // remove deleted elements from _cleanableTiles
+    this._cleanableTiles.splice(0, i);
+  }
+  return [this.root];
+}
+const boundingVolumeBox = new THREE.Box3();
+const boundingVolumeSphere = new THREE.Sphere();
+export function computeNodeSSE(camera, node) {
+  node.distance = 0;
+  if (node.boundingVolume.initialVolumeType === C3DTilesBoundingVolumeTypes.box) {
+    boundingVolumeBox.copy(node.boundingVolume.volume);
+    boundingVolumeBox.applyMatrix4(node.matrixWorld);
+    node.distance = boundingVolumeBox.distanceToPoint(camera.camera3D.position);
+  } else if (node.boundingVolume.initialVolumeType === C3DTilesBoundingVolumeTypes.sphere || node.boundingVolume.initialVolumeType === C3DTilesBoundingVolumeTypes.region) {
+    boundingVolumeSphere.copy(node.boundingVolume.volume);
+    boundingVolumeSphere.applyMatrix4(node.matrixWorld);
+    // TODO: see https://github.com/iTowns/itowns/issues/800
+    node.distance = Math.max(0.0, boundingVolumeSphere.distanceToPoint(camera.camera3D.position));
+  } else {
+    return Infinity;
+  }
+  if (node.distance === 0) {
+    // This test is needed in case geometricError = distance = 0
+    return Infinity;
+  }
+  return camera._preSSE * (node.geometricError / node.distance);
+}
+export function init3dTilesLayer(view, scheduler, layer, rootTile) {
+  return requestNewTile(view, scheduler, layer, rootTile, undefined, true).then(tile => {
+    layer.object3d.add(tile);
+    tile.updateMatrixWorld();
+    layer.tileset.tiles[tile.tileId].loaded = true;
+    layer.root = tile;
+    layer.onTileContentLoaded(tile);
+  });
+}
+function setDisplayed(node, display) {
+  // The geometry of the tile is not in node, but in node.content
+  // To change the display state, we change node.content.visible instead of
+  // node.material.visible
+  if (node.content) {
+    node.content.visible = display;
+  }
+}
+function markForDeletion(layer, elt) {
+  if (!elt.cleanableSince) {
+    elt.cleanableSince = Date.now();
+    layer._cleanableTiles.push(elt);
+  }
+}
+
+/**
+ * This funcion builds the method to update 3d tiles node.
+ *
+ * The returned method checks the 3d tile visibility with `cullingTest` function.
+ * It subdivises visible node if `subdivisionTest` return `true`.
+ *
+ * @param      {Function}  [cullingTest=$3dTilesCulling]                 The culling test method.
+ * @param      {Function}  [subdivisionTest=$3dTilesSubdivisionControl]  The subdivision test method.
+ * @return     {Function}    { description_of_the_return_value }
+ */
+export function process3dTilesNode() {
+  let cullingTest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : $3dTilesCulling;
+  let subdivisionTest = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : $3dTilesSubdivisionControl;
+  return function (context, layer, node) {
+    // early exit if parent's subdivision is in progress
+    if (node.parent.pendingSubdivision && !node.parent.additiveRefinement) {
+      node.visible = false;
+      return undefined;
+    }
+
+    // do proper culling
+    const isVisible = cullingTest ? !cullingTest(layer, context.camera, node, node.matrixWorld) : true;
+    node.visible = isVisible;
+    if (isVisible) {
+      if (node.cleanableSince) {
+        layer._cleanableTiles.splice(layer._cleanableTiles.indexOf(node), 1);
+        node.cleanableSince = undefined;
+      }
+      let returnValue;
+      if (node.pendingSubdivision || subdivisionTest(context, layer, node)) {
+        subdivideNode(context, layer, node, cullingTest);
+        // display iff children aren't ready
+        setDisplayed(node, node.pendingSubdivision || node.additiveRefinement);
+        returnValue = getChildTiles(node);
+      } else {
+        setDisplayed(node, true);
+        for (const n of getChildTiles(node)) {
+          n.visible = false;
+          markForDeletion(layer, n);
+        }
+      }
+      return returnValue;
+    }
+    markForDeletion(layer, node);
+  };
+}
+
+/**
+ *
+ *
+ * the method returns true if the `node` should be subivised.
+ *
+ * @param      {object}   context  The current context
+ * @param      {Camera}   context.camera  The current camera
+ * @param      {C3DTilesLayer}   layer  The 3d tile layer
+ * @param      {THREE.Object3D}  node  The 3d tile node
+ * @return     {boolean}
+ */
+export function $3dTilesSubdivisionControl(context, layer, node) {
+  if (layer.tileset.tiles[node.tileId].children === undefined) {
+    return false;
+  }
+  if (layer.tileset.tiles[node.tileId].isTileset) {
+    return true;
+  }
+  const sse = computeNodeSSE(context.camera, node);
+  return sse > layer.sseThreshold;
+}

package/lib/Process/FeatureProcessing.js

@@ -0,0 +1,76 @@
+import LayerUpdateState from "../Layer/LayerUpdateState.js";
+import ObjectRemovalHelper from "./ObjectRemovalHelper.js";
+import handlingError from "./handlerNodeError.js";
+import { Coordinates } from '@itowns/geographic';
+import { geoidLayerIsVisible } from "../Layer/GeoidLayer.js";
+const coord = new Coordinates('EPSG:4326', 0, 0, 0);
+export default {
+  update(context, layer, node) {
+    if (!node.parent && node.children.length) {
+      // if node has been removed dispose three.js resource
+      ObjectRemovalHelper.removeChildrenAndCleanupRecursively(layer, node);
+      return;
+    }
+    if (!node.visible) {
+      return;
+    }
+    if (node.layerUpdateState[layer.id] === undefined) {
+      node.layerUpdateState[layer.id] = new LayerUpdateState();
+    } else if (!node.layerUpdateState[layer.id].canTryUpdate()) {
+      // toggle visibility features
+      node.link[layer.id]?.forEach(f => {
+        f.layer.object3d.add(f);
+        f.meshes.position.z = geoidLayerIsVisible(layer.parent) ? node.geoidHeight : 0;
+        f.meshes.updateMatrixWorld();
+      });
+      return;
+    }
+    const extentsDestination = node.getExtentsByProjection(layer.source.crs) || [node.extent];
+    const zoomDest = extentsDestination[0].zoom;
+
+    // check if it's tile level is equal to display level layer.
+    // TO DO updata at all level asked
+    // if ((zoomDest < layer.zoom.min && zoomDest > layer.zoom.max) ||
+    if (zoomDest != layer.zoom.min ||
+    // check if there's data in extent tile.
+    !this.source.extentInsideLimit(node.extent, zoomDest) ||
+    // In FileSource case, check if the feature center is in extent tile.
+    layer.source.isFileSource && !node.extent.isPointInside(layer.source.extent.center(coord))) {
+      // if not, there's not data to add at this tile.
+      node.layerUpdateState[layer.id].noMoreUpdatePossible();
+      return;
+    }
+    node.layerUpdateState[layer.id].newTry();
+    const command = {
+      layer,
+      extentsSource: extentsDestination,
+      view: context.view,
+      requester: node
+    };
+    return context.scheduler.execute(command).then(featureMeshes => {
+      node.layerUpdateState[layer.id].noMoreUpdatePossible();
+      featureMeshes.forEach(featureMesh => {
+        if (featureMesh) {
+          node.link[layer.id] = node.link[layer.id] || [];
+          featureMesh.as(context.view.referenceCrs);
+          featureMesh.meshes.position.z = geoidLayerIsVisible(layer.parent) ? node.geoidHeight : 0;
+          featureMesh.updateMatrixWorld();
+          if (layer.onMeshCreated) {
+            layer.onMeshCreated(featureMesh, context);
+          }
+          if (!node.parent) {
+            // TODO: Clean cache needs a refactory, because it isn't really efficient and used
+            ObjectRemovalHelper.removeChildrenAndCleanupRecursively(layer, featureMesh);
+          } else {
+            layer.object3d.add(featureMesh);
+            node.link[layer.id].push(featureMesh);
+          }
+          featureMesh.layer = layer;
+        } else {
+          // TODO: verify if it's possible the featureMesh is undefined.
+          node.layerUpdateState[layer.id].failure(1, true);
+        }
+      });
+    }, err => handlingError(err, node, layer, node.level, context.view));
+  }
+};