itowns 2.44.3-next.40 → 2.44.3-next.41

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

@@ -1,97 +0,0 @@
-/**
- * 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

@@ -1,110 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,99 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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;