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

package/lib/Core/3DTiles/C3DTExtensions.js

@@ -0,0 +1,97 @@
+/**
+ * Class for managing
+ * [3D Tiles extensions](https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/extensions).
+ * Extensions used in a 3D Tiles tileset must be registered in the iTowns' layer
+ * holding the tileset by the user with the {@link registerExtension}
+ * method. The extension must be registered together with a class holding the
+ * code to interpret the extension.
+ * An example of extension class is {@link C3DTBatchTableHierarchyExtension}.
+ * This extension has only one part situated in the batch table (but other
+ * extensions can have multiple parts, stored in different 3D Tiles classes
+ * such as tileset or bounding volume).
+ * @example
+ * // Create a C3DTExtensions object
+ * const extensions = new itowns.C3DTExtensions();
+ * // Register an extension to it named "3DTILES_batch_table_hierarchy" and
+ * // a class itowns.C3DTBatchTableHierarchyExtension to the batch table part
+ * // (with [itowns.C3DTilesTypes.batchtable]). see {@link C3DTilesTypes}
+ * extensions.registerExtension("3DTILES_batch_table_hierarchy",
+ * { [itowns.C3DTilesTypes.batchtable]: itowns.C3DTBatchTableHierarchyExtension });
+ *
+ * // Create a 3D Tiles layer with registered extensions
+ * var $3dTilesLayerBTHierarchy = new itowns.C3DTilesLayer('3d-tiles-bt-hierarchy', {
+ *      name: 'BTHierarchy',
+ *      source: new itowns.C3DTilesSource({
+ *          url: 'https://raw.githubusercontent.com/AnalyticalGraphicsInc/cesium/master/Apps/SampleData/Cesium3DTiles/Hierarchy/BatchTableHierarchy/tileset.json',
+ *          }),
+ *          registeredExtensions: extensions,
+ *      },
+ * view);
+ */
+
+class C3DTExtensions {
+  /**
+   * Register a 3D Tiles extension: Maps an extension name to the
+   * extensionsManagers (i.e. one class per 3D Tiles class (e.g.
+   * batch table or bounding volume).
+   * @param {string} extensionName - Name of the extension
+   * @param {object} extensionManagers - An object mapping 3D Tiles
+   * classes names (see @link{C3DTilesTypes} to the extension managers
+   * corresponding to this class. These extension managers should be able
+   * to parse the extension fragment (done in the constructor) and should
+   * have a getInfoById method if they are related to the batch table class.
+   * See {@link C3DTBatchTableHierarchyExtension} for an example of
+   * extension class.
+   */
+  registerExtension(extensionName, extensionManagers) {
+    this[extensionName] = extensionManagers;
+  }
+
+  /**
+   * Get an extension manager from its name and C3DTilesType
+   * @param {string} extensionName - name of the extension.
+   * @param {C3DTilesTypes} type - type of 3DTiles class (e.g. batch
+   * table, bounding volume, tileset, etc.)
+   * @returns {object} - the extension manager corresponding to the
+   * extensioNname and type.
+   */
+  getExtension(extensionName, type) {
+    if (this[extensionName] && this[extensionName][type]) {
+      return this[extensionName][type];
+    } else {
+      console.error(`${'No extension manager registered for' + ' extension '} ${extensionName} and for class ${type}`);
+    }
+  }
+
+  /**
+   * Test if an extension is registered
+   * @param {string} extensionName - Name of the extension
+   * @returns {boolean} - true if the extension is registered and false
+   * otherwise.
+   */
+  isExtensionRegistered(extensionName) {
+    return this[extensionName];
+  }
+
+  /**
+   * Parses the extensions from a given JSON (extensionsJSON) by
+   * instanciating the right class from the registered extensions.
+   * @param {object} extensionsJSON - the JSON to parse extensions from.
+   * @param {C3DTilesTypes} type - type of class asking for extensions parsing
+   * has been called. For instance, if {@link C3DTBatchTable} needs to
+   * parse its extensions, it will call parseExtension with the JSON to
+   * parse and C3DTilesTypes.batchtable as type.
+   * @returns {object} - An object with keys being the names of the
+   * extensions and values the instances of the extensions managers.
+   */
+  parseExtensions(extensionsJSON, type) {
+    const parsedExtensions = {};
+    for (const extName in extensionsJSON) {
+      if (Object.prototype.hasOwnProperty.call(extensionsJSON, extName)) {
+        parsedExtensions[extName] = new (this.getExtension(extName, type))(extensionsJSON[extName]);
+      }
+    }
+    return parsedExtensions;
+  }
+}
+export default C3DTExtensions;

package/lib/Core/3DTiles/C3DTFeature.js

@@ -0,0 +1,110 @@
+// eslint-disable-next-line no-unused-vars
+import { Object3D, Box3 } from 'three';
+
+/**
+ * Finds the batch table of an object in a 3D Tiles layer. This is
+ * for instance needed when picking because we pick the geometric
+ * object which is not at the same level in the layer structure as
+ * the batch table.
+ * @param {THREE.Object3D} object - a 3D geometric object
+ * @returns {C3DTBatchTable|null} - the batch table of the object
+ */
+function findBatchTable(object) {
+  if (object.batchTable) {
+    return object.batchTable;
+  }
+  if (object.parent) {
+    return findBatchTable(object.parent);
+  }
+  return null;
+}
+
+/**
+ * C3DTFeature is a feature of a 3DTiles
+ *
+ * @class      C3DTFeature
+ * @param {number} tileId - tileId
+ * @param {number} batchId - batch id
+ * @param {Array<{start:number,count:number}>} groups - groups in geometry.attributes matching batchId
+ * @param {object} [userData] - some userData
+ * @param {Object3D} object3d - object3d in which feature is present
+ * @property {number} tileId - tile id
+ * @property {Object3D} object3d - object3d in which feature is present
+ * @property {number} batchId - batch id
+ * @property {Array<{start:number,count:number}>} groups - groups in geometry.attributes matching batchId
+ * @property {object} [userData] - some userData
+ */
+class C3DTFeature {
+  #info;
+  constructor(tileId, batchId, groups, userData, object3d) {
+    /** @type {Object3D} */
+    this.object3d = object3d;
+
+    /** @type {number} */
+    this.batchId = batchId;
+
+    /** @type {Array<{start:number,count:number}>} */
+    this.groups = groups;
+
+    /** @type {object} */
+    this.userData = userData;
+
+    /** @type {number} */
+    this.tileId = tileId;
+
+    // Lazy-loaded batch table information for this.batchId.
+    this.#info = null;
+  }
+
+  /**
+   * Compute world box3 of this
+   *
+   * @param {Box3} target - target of the result
+   * @returns {Box3}
+   */
+  computeWorldBox3() {
+    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Box3();
+    // reset
+    target.max.x = -Infinity;
+    target.max.y = -Infinity;
+    target.max.z = -Infinity;
+    target.min.x = Infinity;
+    target.min.y = Infinity;
+    target.min.z = Infinity;
+    this.groups.forEach(group => {
+      const positionIndexStart = group.start * this.object3d.geometry.attributes.position.itemSize;
+      const positionIndexCount = (group.start + group.count) * this.object3d.geometry.attributes.position.itemSize;
+      for (let index = positionIndexStart; index < positionIndexCount; index++) {
+        const x = this.object3d.geometry.attributes.position.getX(index);
+        const y = this.object3d.geometry.attributes.position.getY(index);
+        const z = this.object3d.geometry.attributes.position.getZ(index);
+        target.max.x = Math.max(x, target.max.x);
+        target.max.y = Math.max(y, target.max.y);
+        target.max.z = Math.max(z, target.max.z);
+        target.min.x = Math.min(x, target.min.x);
+        target.min.y = Math.min(y, target.min.y);
+        target.min.z = Math.min(z, target.min.z);
+      }
+    });
+    target.applyMatrix4(this.object3d.matrixWorld);
+    return target;
+  }
+
+  /**
+   * Gets the information from the tile batch table for this C3DTFeature batch id.
+   * @returns {object} - batchTable info
+   */
+  getInfo() {
+    if (this.#info) {
+      return this.#info;
+    }
+    const batchTable = findBatchTable(this.object3d);
+    if (!batchTable) {
+      console.warn(`[C3DTFeature]: No batch table found for tile ${this.tileId}.`);
+      return null; // or return undefined;
+    }
+    this.#info = batchTable.getInfoById(this.batchId);
+    return this.#info;
+  }
+}
+export default C3DTFeature;

package/lib/Core/3DTiles/C3DTilesEnums.js

@@ -0,0 +1,20 @@
+/**
+ * Enumeration of implemented 3D Tiles classes. Used in C3DTExtensions to
+ * now which classes ask for extension parsing.
+ *
+ * @enum {Object} C3DTilesTypes
+ *
+ * @property {String} tileset - value: 'tileset'
+ * @property {String} batchtable - value: 'batchtable'
+ * @property {String} boundingVolume - value: 'bounding volume'
+ */
+export const C3DTilesTypes = {
+  tileset: 'tileset',
+  batchtable: 'batchtable',
+  boundingVolume: 'boundingVolume'
+};
+export const C3DTilesBoundingVolumeTypes = {
+  region: 'region',
+  box: 'box',
+  sphere: 'sphere'
+};

package/lib/Core/3DTiles/C3DTileset.js

@@ -0,0 +1,99 @@
+import * as THREE from 'three';
+import C3DTBoundingVolume from "./C3DTBoundingVolume.js";
+import { C3DTilesTypes } from "./C3DTilesEnums.js";
+
+// Inverse transform of a tile, computed from the tile transform and used when parsing the bounding volume of a tile
+// if the bounding volume is a region (https://github.com/CesiumGS/3d-tiles/tree/main/specification#region) which is
+// in global coordinates and other bounding volumes are not. To harmonize, we transform back the bounding volume region
+// to a reference local to the tile.
+const tileMatrixInverse = new THREE.Matrix4();
+
+/**
+ * A 3D Tiles
+ *  [Tileset](https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/tileset.schema.json).
+ * @property {C3DTilesTypes} type - Used by 3D Tiles extensions
+ * (e.g. {@link C3DTBatchTableHierarchyExtension}) to know in which context
+ * (i.e. for which 3D Tiles class) the parsing of the extension should be done.
+ *  @property {object} asset - Generic information about the tileset, see
+ *  [asset specification]https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/asset.schema.json
+ *  @property {object} properties - Properties associated with the tileset, see
+ *  [tileset specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L11)
+ *  @property {number} geometricError - see [tileset
+ *  specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L18)
+ *  @property {string[]} extensionsUsed - see [tileset
+ *  specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L27)
+ *  @property {array} extensionsRequired - see [tileset specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L36)
+ *  @property {object[]} tiles - an array holding all the
+ *  [tiles](https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/tile.schema.json)
+ *  (not their content which is stored in the attribute object3d of the
+ *  layer). This list represents a flattened tileset.
+ *  @property {object} extensions - Extensions of the tileset in the form:
+ * {extensioName1: extensionObject1, extensioName2: extensionObject2, ...}
+ */
+class C3DTileset {
+  constructor(json, baseURL, registeredExtensions) {
+    this.type = C3DTilesTypes.tileset;
+    this.asset = json.asset;
+    this.properties = json.properties;
+    this.geometricError = json.geometricError;
+    this.extensionsUsed = json.extensionsUsed;
+    this.extensionsRequired = json.extensionsRequired;
+    this.tiles = [];
+    this.parseTiles(json.root, baseURL, undefined, registeredExtensions);
+    if (json.extensions) {
+      this.extensions = registeredExtensions.parseExtensions(json.extensions, this.type);
+    }
+  }
+
+  /**
+   * Recursion on the 3DTiles tileset (which is a tree) to parse the tiles
+   * (nodes of the tree).
+   * @param {object} tile - current tile
+   * @param {string} baseURL - url of the source tileset and tiles
+   * @param {object} parent - parent tile (used for computing the transform
+   * matrix from local to global coordinates)
+   * @param {object} registeredExtensions - 3D Tiles extensions registered
+   * in the C3DTilesLayer (see {@link C3DTExtensions}
+   */
+  parseTiles(tile, baseURL, parent, registeredExtensions) {
+    // compute transform (will become Object3D.matrix when the object is
+    // downloaded)
+    tile.transform = tile.transform ? new THREE.Matrix4().fromArray(tile.transform) : undefined;
+
+    // The only reason to store _worldFromLocalTransform is because of
+    // extendTileset where we need the transform chain for one tile.
+    tile._worldFromLocalTransform = tile.transform;
+    if (parent && parent._worldFromLocalTransform) {
+      if (tile.transform) {
+        tile._worldFromLocalTransform = new THREE.Matrix4().multiplyMatrices(parent._worldFromLocalTransform, tile.transform);
+      } else {
+        tile._worldFromLocalTransform = parent._worldFromLocalTransform;
+      }
+    }
+
+    // tileMatrixInverse is only used for volume.region
+    if (tile.viewerRequestVolume && tile.viewerRequestVolume.region || tile.boundingVolume && tile.boundingVolume.region) {
+      if (tile._worldFromLocalTransform) {
+        tileMatrixInverse.copy(tile._worldFromLocalTransform).invert();
+      } else {
+        tileMatrixInverse.identity();
+      }
+    }
+    tile.viewerRequestVolume = tile.viewerRequestVolume ? new C3DTBoundingVolume(tile.viewerRequestVolume, tileMatrixInverse, registeredExtensions) : null;
+    tile.boundingVolume = tile.boundingVolume ? new C3DTBoundingVolume(tile.boundingVolume, tileMatrixInverse, registeredExtensions) : null;
+    this.tiles.push(tile);
+    tile.tileId = this.tiles.length - 1;
+    tile.baseURL = baseURL;
+    if (tile.children) {
+      for (const child of tile.children) {
+        this.parseTiles(child, baseURL, tile, registeredExtensions);
+      }
+    }
+  }
+  extendTileset(tileset, nodeId, baseURL, registeredExtensions) {
+    this.parseTiles(tileset.root, baseURL, this.tiles[nodeId], registeredExtensions);
+    this.tiles[nodeId].children = [tileset.root];
+    this.tiles[nodeId].isTileset = true;
+  }
+}
+export default C3DTileset;

package/lib/Core/3DTiles/utils/BinaryPropertyAccessor.js

@@ -0,0 +1,100 @@
+import { Vector2, Vector3, Vector4 } from 'three';
+
+/**
+ * @enum {Object} componentTypeBytesSize - Size in byte of a component type.
+ */
+const componentTypeBytesSize = {
+  BYTE: 1,
+  UNSIGNED_BYTE: 1,
+  SHORT: 2,
+  UNSIGNED_SHORT: 2,
+  INT: 4,
+  UNSIGNED_INT: 4,
+  FLOAT: 4,
+  DOUBLE: 8
+};
+
+/**
+ * @enum {Object} componentTypeConstructor - TypedArray constructor for each 3D Tiles binary componentType
+ */
+const componentTypeConstructor = {
+  BYTE: Int8Array,
+  UNSIGNED_BYTE: Uint8Array,
+  SHORT: Int16Array,
+  UNSIGNED_SHORT: Uint16Array,
+  INT: Int32Array,
+  UNSIGNED_INT: Uint32Array,
+  FLOAT: Float32Array,
+  DOUBLE: Float64Array
+};
+
+/**
+ * @enum {Object} typeComponentsNumber - Number of components for a given type.
+ */
+const typeComponentsNumber = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4
+};
+
+/**
+ * @enum {Object} typeConstructor - constructor for types (only for vectors since scalar will be converted to a single
+ * value)
+ */
+const typeConstructor = {
+  // SCALAR: no constructor, just create a value (int, float, etc. depending on componentType)
+  VEC2: Vector2,
+  VEC3: Vector3,
+  VEC4: Vector4
+};
+
+/**
+ * Parses a 3D Tiles binary property. Used for batch table and feature table parsing. See the 3D Tiles spec for more
+ * information on how these values are encoded:
+ * [3D Tiles spec](https://github.com/CesiumGS/3d-tiles/blob/main/specification/TileFormats/BatchTable/README.md#binary-body))
+ * @param {ArrayBuffer} buffer The buffer to parse values from.
+ * @param {Number} batchLength number of objects in the batch (= number of elements to parse).
+ * @param {Number} byteOffset the offset in bytes into the buffer.
+ * @param {String} componentType the type of component to parse (one of componentTypeBytesSize keys)
+ * @param {String} type the type of element to parse (one of typeComponentsNumber keys)
+ * @returns {Array} an array of values parsed from the buffer. An array of componentType if type is SCALAR. An array
+ * of Threejs Vector2, Vector3 or Vector4 if type is VEC2, VEC3 or VEC4 respectively.
+ */
+function binaryPropertyAccessor(buffer, batchLength, byteOffset, componentType, type) {
+  if (!buffer) {
+    throw new Error('Buffer is mandatory to parse binary property.');
+  }
+  if (typeof batchLength === 'undefined' || batchLength === null) {
+    throw new Error('batchLength is mandatory to parse binary property.');
+  }
+  if (typeof byteOffset === 'undefined' || byteOffset === null) {
+    throw new Error('byteOffset is mandatory to parse binary property.');
+  }
+  if (!componentTypeBytesSize[componentType]) {
+    throw new Error(`Uknown component type: ${componentType}. Cannot access binary property.`);
+  }
+  if (!typeComponentsNumber[type]) {
+    throw new Error(`Uknown type: ${type}. Cannot access binary property.`);
+  }
+  const typeNb = typeComponentsNumber[type];
+  // Number of elements to parse in the buffer
+
+  const typedArray = new componentTypeConstructor[componentType](buffer, byteOffset, batchLength * typeNb);
+  if (type === 'SCALAR') {
+    return Array.from(typedArray);
+  } else {
+    // return an array of threejs vectors, depending on type (see typeConstructor)
+    const array = [];
+    // iteration step of 2, 3 or 4, depending on the type (VEC2, VEC3 or VEC4)
+    for (let i = 0; i <= typedArray.length - typeNb; i += typeNb) {
+      const vector = new typeConstructor[type]();
+      // Create a vector from an array, starting at the offset i and takes the right number of elements depending
+      // on its type (Vector2, Vector3, Vector 4)
+      vector.fromArray(typedArray, i);
+      array.push(vector);
+    }
+    return array;
+  }
+}
+export default binaryPropertyAccessor;

package/lib/Core/AnimationPlayer.js

@@ -0,0 +1,142 @@
+import * as THREE from 'three';
+const FRAMERATE = 60;
+const FRAME_DURATION = 1000 / FRAMERATE;
+
+// player statut
+const PLAYER_STATE = {
+  // player is stopped
+  STOP: 0,
+  // player plays animation
+  PLAY: 1,
+  // player is at the end of an animation
+  END: 2,
+  // player is paused
+  PAUSE: 3
+};
+
+// Private functions
+// stop timer and re-init parameter
+const resetTimer = function (player) {
+  if (player.id) {
+    clearInterval(player.id);
+    player.id = undefined;
+  }
+  if (player.waitTimer) {
+    clearInterval(player.waitTimer);
+    player.waitTimer = undefined;
+  }
+  player.keyframe = 0;
+};
+
+// finish animation and re-init parameter
+const finishAnimation = function (player) {
+  resetTimer(player);
+  if (player.isEnded()) {
+    player.dispatchEvent({
+      type: 'animation-ended'
+    });
+  }
+  player.dispatchEvent({
+    type: 'animation-stopped'
+  });
+  player.duration = 0;
+};
+
+/**
+ * It can play, pause or stop Animation or AnimationExpression (See below).
+ * AnimationPlayer is needed to use Animation or AnimationExpression
+ * AnimationPlayer emits events :
+ *       - for each animation's frame;
+ *       - when Animation is stopped
+ *       - when Animation is ending
+ */
+class AnimationPlayer extends THREE.EventDispatcher {
+  constructor() {
+    super();
+    this.id = null;
+    this.keyframe = 0;
+    this.duration = 0;
+    this.state = PLAYER_STATE.STOP;
+    this.waitTimer = null;
+    this.callback = () => {};
+  }
+  isPlaying() {
+    return this.state === PLAYER_STATE.PLAY;
+  }
+  isStopped() {
+    return this.state === PLAYER_STATE.STOP;
+  }
+  isEnded() {
+    return this.state === PLAYER_STATE.END;
+  }
+
+  // Public functions
+
+  /**
+   * Set the Player `callback` property. This callback is executed at each animation frame.
+   *
+   * @param {function} callback - The callback to execute at each animation frame.
+   */
+  setCallback(callback) {
+    this.callback = callback;
+  }
+
+  /**
+   * Play one animation.
+   * If another animation is playing, it's stopped and the new animation is played.
+   *
+   * @param {number} duration - The duration to play
+   */
+  play(duration) {
+    this.duration = duration;
+    this.dispatchEvent({
+      type: 'animation-started'
+    });
+    this.state = PLAYER_STATE.PLAY;
+    resetTimer(this);
+    this.id = setInterval(this.frame.bind(this), FRAME_DURATION);
+  }
+
+  /**
+   * Play an animation after a number of frames.
+   *
+   * @param      {number}  duration    The duration to play
+   * @param      {number}  waitingFrame    The waiting time before start animation (time in frame)
+   */
+  playLater(duration, waitingFrame) {
+    const timew = Math.floor(FRAME_DURATION * waitingFrame);
+    window.clearInterval(this.waitTimer);
+    const self = this;
+    this.waitTimer = window.setTimeout(() => {
+      self.play(duration);
+    }, timew);
+  }
+
+  /**
+   * Stop the current animation.
+   *
+   */
+  stop() {
+    this.state = PLAYER_STATE.STOP;
+    finishAnimation(this);
+  }
+
+  /**
+   * Executed for each frame.
+   *
+   * @private
+   */
+  frame() {
+    if (this.keyframe < this.duration) {
+      this.keyframe++;
+      this.dispatchEvent({
+        type: 'animation-frame'
+      });
+      this.callback();
+    } else {
+      this.state = PLAYER_STATE.END;
+      finishAnimation(this);
+    }
+  }
+}
+export default AnimationPlayer;