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

package/lib/Process/LayeredMaterialNodeProcessing.js

@@ -0,0 +1,229 @@
+import { chooseNextLevelToFetch } from "../Layer/LayerUpdateStrategy.js";
+import LayerUpdateState from "../Layer/LayerUpdateState.js";
+import handlingError from "./handlerNodeError.js";
+function materialCommandQueuePriorityFunction(material) {
+  // We know that 'node' is visible because commands can only be
+  // issued for visible nodes.
+  // TODO: need priorization of displayed nodes
+  // Then prefer displayed node over non-displayed one
+  return material.visible ? 100 : 10;
+}
+function refinementCommandCancellationFn(cmd) {
+  if (!cmd.requester.parent || !cmd.requester.material) {
+    return true;
+  }
+  // Cancel the command if the tile already has a better texture.
+  // This is only needed for elevation layers, because we may have several
+  // concurrent layers but we can only use one texture.
+  if (cmd.layer.isElevationLayer && cmd.requester.material.getElevationLayer() && cmd.targetLevel <= cmd.requester.material.getElevationLayer().level) {
+    return true;
+  }
+
+  // Cancel the command if the layer was removed between command scheduling and command execution
+  if (!cmd.requester.layerUpdateState[cmd.layer.id] || !cmd.layer.source._featuresCaches[cmd.layer.crs]) {
+    return true;
+  }
+  return !cmd.requester.material.visible;
+}
+function buildCommand(view, layer, extentsSource, extentsDestination, requester) {
+  return {
+    view,
+    layer,
+    extentsSource,
+    extentsDestination,
+    requester,
+    priority: materialCommandQueuePriorityFunction(requester.material),
+    earlyDropFunction: refinementCommandCancellationFn,
+    partialLoading: true
+  };
+}
+function computePitchs(textures, extentsDestination) {
+  return extentsDestination.map((ext, i) => ext.offsetToParent(textures[i].extent));
+}
+export function updateLayeredMaterialNodeImagery(context, layer, node, parent) {
+  const material = node.material;
+  if (!parent || !material) {
+    return;
+  }
+  const extentsDestination = node.getExtentsByProjection(layer.crs);
+  const zoom = extentsDestination[0].zoom;
+  if (zoom > layer.zoom.max || zoom < layer.zoom.min) {
+    return;
+  }
+  let nodeLayer = material.getLayer(layer.id);
+
+  // Initialisation
+  if (node.layerUpdateState[layer.id] === undefined) {
+    node.layerUpdateState[layer.id] = new LayerUpdateState();
+    if (!layer.source.extentInsideLimit(node.extent, zoom)) {
+      // we also need to check that tile's parent doesn't have a texture for this layer,
+      // because even if this tile is outside of the layer, it could inherit it's
+      // parent texture
+      if (!(!layer.noTextureParentOutsideLimit && parent.material && parent.material.getLayer && parent.material.getLayer(layer.id))) {
+        node.layerUpdateState[layer.id].noMoreUpdatePossible();
+        return;
+      } // ok, we're going to inherit our parent's texture
+    }
+    if (!nodeLayer) {
+      // Create new raster node
+      nodeLayer = layer.setupRasterNode(node);
+
+      // Init the node by parent
+      const parentLayer = parent.material?.getLayer(layer.id);
+      nodeLayer.initFromParent(parentLayer, extentsDestination);
+    }
+
+    // Proposed new process, two separate processes:
+    //      * FIRST PASS: initNodeXXXFromParent and get out of the function
+    //      * SECOND PASS: Fetch best texture
+
+    // The two-step allows you to filter out unnecessary requests
+    // Indeed in the second pass, their state (not visible or not displayed) can block them to fetch
+    if (nodeLayer.level >= layer.source.zoom.min) {
+      context.view.notifyChange(node, false);
+      return;
+    }
+  }
+
+  // Node is hidden, no need to update it
+  if (!material.visible) {
+    return;
+  }
+
+  // An update is pending / or impossible -> abort
+  if (!layer.visible || !node.layerUpdateState[layer.id].canTryUpdate()) {
+    return;
+  }
+  if (nodeLayer.level >= extentsDestination[0].zoom) {
+    // default decision method
+    node.layerUpdateState[layer.id].noMoreUpdatePossible();
+    return;
+  }
+
+  // is fetching data from this layer disabled?
+  if (layer.frozen) {
+    return;
+  }
+  const failureParams = node.layerUpdateState[layer.id].failureParams;
+  const destinationLevel = extentsDestination[0].zoom || node.level;
+  const targetLevel = chooseNextLevelToFetch(layer.updateStrategy.type, node, destinationLevel, nodeLayer.level, layer, failureParams);
+  if (!layer.source.isVectorSource && targetLevel <= nodeLayer.level || targetLevel > destinationLevel) {
+    if (failureParams.lowestLevelError != Infinity) {
+      // this is the highest level found in case of error.
+      node.layerUpdateState[layer.id].noMoreUpdatePossible();
+    }
+    return;
+  } else if (!layer.source.extentInsideLimit(node.extent, targetLevel)) {
+    node.layerUpdateState[layer.id].noData({
+      targetLevel
+    });
+    context.view.notifyChange(node, false);
+    return;
+  }
+  const extentsSource = extentsDestination.map(e => e.tiledExtentParent(targetLevel));
+  node.layerUpdateState[layer.id].newTry();
+  const command = buildCommand(context.view, layer, extentsSource, extentsDestination, node);
+  return context.scheduler.execute(command).then(results => {
+    // Does nothing if the layer has been removed while command was being or waiting to be executed
+    if (!node.layerUpdateState[layer.id]) {
+      return;
+    }
+    const textures = results.map((texture, index) => texture != null ? texture : {
+      isTexture: false,
+      extent: extentsDestination[index]
+    });
+    // TODO: Handle error : result is undefined in provider. throw error
+    const pitchs = computePitchs(textures, extentsDestination);
+    nodeLayer.setTextures(textures, pitchs);
+    node.layerUpdateState[layer.id].success();
+  }, err => handlingError(err, node, layer, targetLevel, context.view));
+}
+export function updateLayeredMaterialNodeElevation(context, layer, node, parent) {
+  const material = node.material;
+  if (!parent || !material) {
+    return;
+  }
+
+  // TODO: we need either
+  //  - compound or exclusive layers
+  //  - support for multiple elevation layers
+
+  // Elevation is currently handled differently from color layers.
+  // This is caused by a LayeredMaterial limitation: only 1 elevation texture
+  // can be used (where a tile can have N textures x M layers)
+  const extentsDestination = node.getExtentsByProjection(layer.crs);
+  const zoom = extentsDestination[0].zoom;
+  if (zoom > layer.zoom.max || zoom < layer.zoom.min) {
+    return;
+  }
+  // Init elevation layer, and inherit from parent if possible
+  let nodeLayer = material.getElevationLayer();
+  if (!nodeLayer) {
+    nodeLayer = layer.setupRasterNode(node);
+  }
+  if (node.layerUpdateState[layer.id] === undefined) {
+    node.layerUpdateState[layer.id] = new LayerUpdateState();
+    const parentLayer = parent.material?.getLayer(layer.id);
+    nodeLayer.initFromParent(parentLayer, extentsDestination);
+    if (nodeLayer.level >= layer.source.zoom.min) {
+      context.view.notifyChange(node, false);
+      return;
+    }
+  }
+
+  // Possible conditions to *not* update the elevation texture
+  if (layer.frozen || !material.visible || !node.layerUpdateState[layer.id].canTryUpdate()) {
+    return;
+  }
+  const failureParams = node.layerUpdateState[layer.id].failureParams;
+  const targetLevel = chooseNextLevelToFetch(layer.updateStrategy.type, node, extentsDestination[0].zoom, nodeLayer.level, layer, failureParams);
+  if (targetLevel <= nodeLayer.level || targetLevel > extentsDestination[0].zoom) {
+    node.layerUpdateState[layer.id].noMoreUpdatePossible();
+    return;
+  } else if (!layer.source.extentInsideLimit(node.extent, targetLevel)) {
+    node.layerUpdateState[layer.id].noData({
+      targetLevel
+    });
+    context.view.notifyChange(node, false);
+    return;
+  }
+  const extentsSource = extentsDestination.map(e => e.tiledExtentParent(targetLevel));
+  node.layerUpdateState[layer.id].newTry();
+  const command = buildCommand(context.view, layer, extentsSource, extentsDestination, node);
+  return context.scheduler.execute(command).then(results => {
+    // Does nothing if the layer has been removed while command was being or waiting to be executed
+    if (!node.layerUpdateState[layer.id]) {
+      return;
+    }
+
+    // Do not apply the new texture if its level is < than the current
+    // one.  This is only needed for elevation layers, because we may
+    // have several concurrent layers but we can only use one texture.
+    if (targetLevel <= nodeLayer.level) {
+      node.layerUpdateState[layer.id].noMoreUpdatePossible();
+      return;
+    }
+    const pitchs = computePitchs(results, extentsDestination);
+    nodeLayer.setTextures(results, pitchs);
+    node.layerUpdateState[layer.id].success();
+  }, err => handlingError(err, node, layer, targetLevel, context.view));
+}
+export function removeLayeredMaterialNodeLayer(layerId) {
+  /**
+   * @param {TileMesh} node - The node to udpate.
+   */
+  return function (node) {
+    if (node.material?.removeLayer) {
+      if (node.material.elevationLayerIds.indexOf(layerId) > -1) {
+        node.setBBoxZ({
+          min: 0,
+          max: 0
+        });
+      }
+      node.material.removeLayer(layerId);
+    }
+    if (node.layerUpdateState && node.layerUpdateState[layerId]) {
+      delete node.layerUpdateState[layerId];
+    }
+  };
+}

package/lib/Process/ObjectRemovalHelper.js

@@ -0,0 +1,97 @@
+function disposeSingleMaterialAndTextures(material) {
+  material.dispose();
+  // dispose textures
+  for (const key of Object.keys(material)) {
+    const val = material[key];
+    if (val && val.isTexture) {
+      val.dispose();
+    }
+  }
+}
+export default {
+  /**
+   * Cleanup obj to release three.js allocated resources
+   * @param {Object3D} obj object to release
+   */
+  cleanup(obj) {
+    obj.layer = null;
+
+    // THREE.Scene dispose function displays a deprecation message
+    if (!obj.isScene && typeof obj.dispose === 'function') {
+      obj.dispose();
+    } else {
+      if (obj.geometry) {
+        obj.geometry.dispose();
+        // the Object Removal Helper causes inconsistencies
+        // when it assigns null to a geometry present in the Cache.
+        // Actually, the cache can provide a mesh whose geometry is null.
+        // see https://github.com/iTowns/itowns/issues/869
+        // obj.geometry = null;
+      }
+      if (obj.material) {
+        if (Array.isArray(obj.material)) {
+          for (const material of obj.material) {
+            disposeSingleMaterialAndTextures(material);
+          }
+        } else {
+          disposeSingleMaterialAndTextures(obj.material);
+        }
+      }
+      obj.dispatchEvent({
+        type: 'dispose'
+      });
+    }
+  },
+  /**
+   * Remove obj's children belonging to a layer.
+   * Neither obj nor its children will be disposed!
+   * @param {Layer} layer The layer that objects must belong to. Other object are ignored
+   * @param {Object3D} obj The Object3D we want to clean
+   * @return {Array} an array of removed Object3D from obj (not including the recursive removals)
+   */
+  removeChildren(layer, obj) {
+    const toRemove = obj.children.filter(c => (c.layer && c.layer.id) === layer.id);
+    obj.remove(...toRemove);
+    return toRemove;
+  },
+  /**
+   * Remove an obj and all its children belonging to a layer and only cleanup the obj (and not its children).
+   * obj will be disposed but its children **won't**!
+   * @param {Layer} layer The layer that objects must belong to. Other object are ignored
+   * @param {Object3D} obj The Object3D we want to clean
+   * @return {Array} an array of removed Object3D from obj (not including the recursive removals)
+   */
+  removeChildrenAndCleanup(layer, obj) {
+    const toRemove = obj.children.filter(c => (c.layer && c.layer.id) === layer.id);
+    obj.remove(...toRemove);
+    if (obj.layer === layer) {
+      this.cleanup(obj);
+    }
+    return toRemove;
+  },
+  /**
+   * Recursively remove an obj and all its children belonging to a layer.
+   * All removed obj will have their geometry/material disposed.
+   * @param {Layer} layer The layer that objects must belong to. Other object are ignored
+   * @param {Object3D} obj The Object3D we want to clean
+   * @return {Array} an array of removed Object3D from obj (not including the recursive removals)
+   */
+  removeChildrenAndCleanupRecursively(layer, obj) {
+    // Objects are filtered by id because the obj hierarchy may also contain labels that have been added as childs
+    // of the objects which have their own removal logic
+    let toRemove = obj.children.filter(c => c.layer && c.layer.id === layer.id);
+    const linked = obj.link && obj.link[layer.id];
+    if (linked?.children.length) {
+      toRemove = toRemove.concat(linked.children);
+      delete obj.link[layer.id];
+    }
+    for (const c of toRemove) {
+      this.removeChildrenAndCleanupRecursively(layer, c);
+    }
+    obj.remove(...toRemove);
+    if (obj.layer && obj.layer.id === layer.id) {
+      this.cleanup(obj);
+    }
+    return toRemove;
+  }
+};

package/lib/Process/handlerNodeError.js

@@ -0,0 +1,23 @@
+// max retry loading before changing the status to definitiveError
+const MAX_RETRY = 4;
+export default function handlingError(err, node, layer, targetLevel, view) {
+  // Cancel error handling if the layer was removed between command scheduling and its execution
+  if (!node.layerUpdateState[layer.id]) {
+    return;
+  }
+  if (err.isCancelledCommandException) {
+    node.layerUpdateState[layer.id].success();
+  } else if (err instanceof SyntaxError) {
+    node.layerUpdateState[layer.id].failure(0, true);
+  } else {
+    const definitiveError = node.layerUpdateState[layer.id].errorCount > MAX_RETRY;
+    node.layerUpdateState[layer.id].failure(Date.now(), definitiveError, {
+      targetLevel
+    });
+    if (!definitiveError) {
+      window.setTimeout(() => {
+        view.notifyChange(node, false);
+      }, node.layerUpdateState[layer.id].secondsUntilNextTry() * 1000);
+    }
+  }
+}

package/lib/Provider/3dTilesProvider.js

@@ -0,0 +1,149 @@
+import * as THREE from 'three';
+import B3dmParser from "../Parser/B3dmParser.js";
+import PntsParser from "../Parser/PntsParser.js";
+import Fetcher from "./Fetcher.js";
+import ReferLayerProperties from "../Layer/ReferencingLayerProperties.js";
+import PointsMaterial from "../Renderer/PointsMaterial.js";
+// A bit weird but temporary until we remove this deprecated provider. Mainly to benefit from the enableDracoLoader and enableKtx2Loader
+// methods.
+import { itownsGLTFLoader } from "../Layer/OGC3DTilesLayer.js";
+const utf8Decoder = new TextDecoder();
+function b3dmToMesh(data, layer, url) {
+  const urlBase = THREE.LoaderUtils.extractUrlBase(url);
+  const options = {
+    gltfUpAxis: layer.tileset.asset.gltfUpAxis,
+    urlBase,
+    overrideMaterials: layer.overrideMaterials,
+    doNotPatchMaterial: layer.doNotPatchMaterial,
+    registeredExtensions: layer.registeredExtensions,
+    layer
+  };
+  return B3dmParser.parse(data, options).then(result => {
+    const batchTable = result.batchTable;
+    // object3d is actually a THREE.Scene
+    const object3d = result.gltf.scene;
+    return {
+      batchTable,
+      object3d
+    };
+  });
+}
+function gltfToMesh(data, layer, url) {
+  const urlBase = THREE.LoaderUtils.extractUrlBase(url);
+  return itownsGLTFLoader.parseAsync(data, urlBase).then(result => ({
+    object3d: result.scene
+  }));
+}
+function pntsParse(data, layer) {
+  return PntsParser.parse(data, layer.registeredExtensions).then(result => {
+    const material = layer.material ? layer.material.clone() : new PointsMaterial({
+      size: 1,
+      mode: layer.pntsMode,
+      shape: layer.pntsShape,
+      classificationScheme: layer.classification,
+      sizeMode: layer.pntsSizeMode,
+      minAttenuatedSize: layer.pntsMinAttenuatedSize,
+      maxAttenuatedSize: layer.pntsMaxAttenuatedSize
+    });
+
+    // refer material properties in the layer so when layers opacity and visibility is updated, the material is
+    // automatically updated
+    ReferLayerProperties(material, layer);
+
+    // creation points with geometry and material
+    const points = new THREE.Points(result.point.geometry, material);
+    if (result.point.offset) {
+      points.position.copy(result.point.offset);
+    }
+    return {
+      object3d: points,
+      batchTable: result.batchTable
+    };
+  });
+}
+export function configureTile(tile, layer, metadata, parent) {
+  tile.frustumCulled = false;
+  tile.layer = layer;
+
+  // parse metadata
+  if (metadata.transform) {
+    tile.applyMatrix4(metadata.transform);
+  }
+  tile.geometricError = metadata.geometricError;
+  tile.tileId = metadata.tileId;
+  if (metadata.refine) {
+    tile.additiveRefinement = metadata.refine.toUpperCase() === 'ADD';
+  } else {
+    tile.additiveRefinement = parent ? parent.additiveRefinement : false;
+  }
+  tile.viewerRequestVolume = metadata.viewerRequestVolume;
+  tile.boundingVolume = metadata.boundingVolume;
+  tile.updateMatrixWorld();
+}
+function executeCommand(command) {
+  const layer = command.layer;
+  const metadata = command.metadata;
+  const tile = new THREE.Object3D();
+  configureTile(tile, layer, metadata, command.requester);
+  // Patch for supporting 3D Tiles pre 1.0 (metadata.content.url) and 1.0
+  // (metadata.content.uri)
+  const path = metadata.content && (metadata.content.url || metadata.content.uri);
+  const setLayer = obj => {
+    obj.userData.metadata = metadata;
+    obj.layer = layer;
+  };
+  if (path) {
+    // Check if we have relative or absolute url (with tileset's lopocs for example)
+    let url = path.startsWith('http') ? path : metadata.baseURL + path;
+    if (layer.source.isC3DTilesGoogleSource) {
+      url = layer.source.getTileUrl(url);
+    }
+    const supportedFormats = {
+      b3dm: b3dmToMesh,
+      pnts: pntsParse,
+      gltf: gltfToMesh
+    };
+    return Fetcher.arrayBuffer(url, layer.source.networkOptions).then(result => {
+      if (result !== undefined) {
+        let func;
+        const magic = utf8Decoder.decode(new Uint8Array(result, 0, 4));
+        if (magic[0] === '{') {
+          result = JSON.parse(utf8Decoder.decode(new Uint8Array(result)));
+          // Another specifics of 3D tiles from Google: tilesets in tilesets are required from the root base
+          // url and not from their parent base url
+          const newPrefix = layer.source.isC3DTilesGoogleSource ? layer.source.baseUrl : url.slice(0, url.lastIndexOf('/') + 1);
+          layer.tileset.extendTileset(result, metadata.tileId, newPrefix, layer.registeredExtensions);
+        } else if (magic == 'b3dm') {
+          func = supportedFormats.b3dm;
+        } else if (magic == 'pnts') {
+          layer.hasPnts = true;
+          func = supportedFormats.pnts;
+        } else if (magic == 'glTF') {
+          func = supportedFormats.gltf;
+        } else {
+          return Promise.reject(`Unsupported magic code ${magic}`);
+        }
+        if (func) {
+          // TODO: request should be delayed if there is a viewerRequestVolume
+          return func(result, layer, url).then(content => {
+            tile.content = content.object3d;
+            if (content.batchTable) {
+              tile.batchTable = content.batchTable;
+            }
+            tile.add(content.object3d);
+            tile.traverse(setLayer);
+            return tile;
+          });
+        }
+      }
+      tile.traverse(setLayer);
+      return tile;
+    });
+  } else {
+    tile.traverse(setLayer);
+    return Promise.resolve(tile);
+  }
+}
+export default {
+  executeCommand
+};

package/lib/Provider/DataSourceProvider.js

@@ -0,0 +1,24 @@
+export default {
+  executeCommand(command) {
+    const layer = command.layer;
+    const src = command.extentsSource;
+    const dst = command.extentsDestination || src;
+    const promises = src.map((from, i) => layer.getData(from, dst[i]));
+
+    // partialLoading sets the return promise as fulfilled if at least one sub-promise is fulfilled
+    // It waits until all promises are resolved
+    if (command.partialLoading) {
+      return Promise.allSettled(promises).then(results => {
+        const anyFulfilledPromise = results.find(promise => promise.status === 'fulfilled');
+        if (!anyFulfilledPromise) {
+          // All promises failed -> reject
+          return Promise.reject(new Error('Failed to load any data'));
+        }
+        return results.map(prom => prom.value ? prom.value : null);
+      });
+    }
+
+    // Without partialLoading, the return promise is rejected as soon as any sub-promise is rejected
+    return Promise.all(promises);
+  }
+};