@loaders.gl/tiles 5.0.0-alpha.12 → 5.0.0-alpha.13

package/src/tileset-3d/helpers/transform-utils.ts

@@ -1,109 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {Ellipsoid} from '@math.gl/geospatial';
-import {Matrix4, Vector3} from '@math.gl/core';
-import {assert} from '@loaders.gl/loader-utils';
-
-import {Tile3D} from '../common/tile-3d';
-
-export function calculateTransformProps(tileHeader: Tile3D, tile: Tile3D['content']) {
-  assert(tileHeader);
-  assert(tile);
-
-  const {rtcCenter, gltfUpAxis} = tile;
-  const {
-    computedTransform,
-    boundingVolume: {center}
-  } = tileHeader;
-
-  let modelMatrix = new Matrix4(computedTransform);
-
-  // Translate if appropriate
-  if (rtcCenter) {
-    modelMatrix.translate(rtcCenter);
-  }
-
-  // glTF models need to be rotated from Y to Z up
-  // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
-  switch (gltfUpAxis) {
-    case 'Z':
-      break;
-    case 'Y':
-      const rotationY = new Matrix4().rotateX(Math.PI / 2);
-      modelMatrix = modelMatrix.multiplyRight(rotationY);
-      break;
-    case 'X':
-      const rotationX = new Matrix4().rotateY(-Math.PI / 2);
-      modelMatrix = modelMatrix.multiplyRight(rotationX);
-      break;
-    default:
-      break;
-  }
-
-  // Scale/offset positions if normalized integers
-  if (tile.isQuantized) {
-    modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);
-  }
-
-  // Option 1: Cartesian matrix and origin
-  const cartesianOrigin = new Vector3(center);
-
-  tile.cartesianModelMatrix = modelMatrix;
-  tile.cartesianOrigin = cartesianOrigin;
-
-  // Option 2: Cartographic matrix and origin
-  const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(
-    cartesianOrigin,
-    new Vector3()
-  );
-  const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
-  const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
-
-  tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
-  tile.cartographicOrigin = cartographicOrigin;
-
-  // Absorb glTF root node matrix into model matrices for Float32 precision.
-  // The glTF root node matrix (applied as sceneModelMatrix in the shader) may contain
-  // ECEF-scale translations (~millions of meters). When both cartographicModelMatrix
-  // and sceneModelMatrix are applied in the Float32 GPU shader, catastrophic cancellation
-  // occurs causing visible seams between adjacent tiles. By combining them here in Float64,
-  // the result has small ENU-scale values that preserve precision.
-  const rootNode = _getRootNode(tile);
-  if (rootNode) {
-    tile.cartesianModelMatrix = new Matrix4(modelMatrix).multiplyRight(rootNode.matrix);
-    tile.cartographicModelMatrix.multiplyRight(rootNode.matrix);
-    rootNode.matrix = Matrix4.IDENTITY;
-  }
-
-  // Deprecated, drop
-  if (!tile.coordinateSystem) {
-    tile.modelMatrix = tile.cartographicModelMatrix;
-  }
-}
-
-const TRANSLATION_LIMIT_SQUARED = 10e5 ** 2; // 100km
-
-/**
- * Returns the glTF root node if it has a matrix with earth-scale translations (> 100km).
- * These large translations cause Float32 precision issues when applied in the GPU shader.
- */
-function _getRootNode(tile: Tile3D['content']): {matrix: number[]} | null {
-  const gltf = tile.gltf;
-  if (!gltf) {
-    return null;
-  }
-
-  const sceneIndex = typeof gltf.scene === 'number' ? gltf.scene : 0;
-  const scene = gltf.scenes?.[sceneIndex];
-  const rootNode = scene?.nodes?.[0];
-  if (!rootNode?.matrix) return null;
-
-  // Extract translation and compare magnitude (meters) to limit
-  const m = rootNode.matrix;
-  const translationMagnitude = m[12] * m[12] + m[13] * m[13] + m[14] * m[14];
-  if (translationMagnitude <= TRANSLATION_LIMIT_SQUARED) return null;
-
-  return rootNode;
-}

package/src/tileset-3d/helpers/zoom.ts

@@ -1,120 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {Vector3} from '@math.gl/core';
-import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
-import {Ellipsoid} from '@math.gl/geospatial';
-import {BoundingRectangle} from '../../types';
-
-const WGS84_RADIUS_X = 6378137.0;
-const WGS84_RADIUS_Y = 6378137.0;
-const WGS84_RADIUS_Z = 6356752.3142451793;
-
-const scratchVector = new Vector3();
-
-/**
- * Calculate appropriate zoom value for a particular boundingVolume
- * @param boundingVolume - the instance of bounding volume
- * @param cartorgraphicCenter - cartographic center of the bounding volume
- * @returns {number} - zoom value
- */
-export function getZoomFromBoundingVolume(
-  boundingVolume: BoundingSphere | OrientedBoundingBox | BoundingRectangle,
-  cartorgraphicCenter: Vector3
-) {
-  if (boundingVolume instanceof OrientedBoundingBox) {
-    // OrientedBoundingBox
-    const {halfAxes} = boundingVolume;
-    const obbSize = getObbSize(halfAxes);
-    // Use WGS84_RADIUS_Z to allign with BoundingSphere algorithm
-    // Add the tile elevation value for correct zooming to elevated tiles
-    return Math.log2(WGS84_RADIUS_Z / (obbSize + cartorgraphicCenter[2]));
-  } else if (boundingVolume instanceof BoundingSphere) {
-    // BoundingSphere
-    const {radius} = boundingVolume;
-    // Add the tile elevation value for correct zooming to elevated tiles
-    return Math.log2(WGS84_RADIUS_Z / (radius + cartorgraphicCenter[2]));
-  } else if (boundingVolume.width && boundingVolume.height) {
-    // BoundingRectangle
-    const {width, height} = boundingVolume;
-    const zoomX = Math.log2(WGS84_RADIUS_X / width);
-    const zoomY = Math.log2(WGS84_RADIUS_Y / height);
-
-    return (zoomX + zoomY) / 2;
-  }
-
-  return 1;
-}
-
-/**
- * Calculate initial zoom for the tileset from 3D `fullExtent` defined in
- * the tileset metadata
- * @param fullExtent - 3D extent of the tileset
- * @param fullExtent.xmin - minimal longitude in decimal degrees
- * @param fullExtent.xmax - maximal longitude in decimal degrees
- * @param fullExtent.ymin - minimal latitude in decimal degrees
- * @param fullExtent.ymax - maximal latitude in decimal degrees
- * @param fullExtent.zmin - minimal elevation in meters
- * @param fullExtent.zmax - maximal elevation in meters
- * @param cartorgraphicCenter - tileset center in cartographic coordinate system
- * @param cartesianCenter - tileset center in cartesian coordinate system
- * @returns - initial zoom for the tileset
- */
-export function getZoomFromFullExtent(
-  fullExtent: {
-    xmin: number;
-    xmax: number;
-    ymin: number;
-    ymax: number;
-    zmin: number;
-    zmax: number;
-  },
-  cartorgraphicCenter: Vector3,
-  cartesianCenter: Vector3
-) {
-  Ellipsoid.WGS84.cartographicToCartesian(
-    [fullExtent.xmax, fullExtent.ymax, fullExtent.zmax],
-    scratchVector
-  );
-  const extentSize = Math.sqrt(
-    Math.pow(scratchVector[0] - cartesianCenter[0], 2) +
-      Math.pow(scratchVector[1] - cartesianCenter[1], 2) +
-      Math.pow(scratchVector[2] - cartesianCenter[2], 2)
-  );
-  return Math.log2(WGS84_RADIUS_Z / (extentSize + cartorgraphicCenter[2]));
-}
-
-/**
- * Calculate initial zoom for the tileset from 2D `extent` defined in
- * the tileset metadata
- * @param extent - 2D extent of the tileset. It is array of 4 elements [xmin, ymin, xmax, ymax]
- * @param extent[0] - minimal longitude in decimal degrees
- * @param extent[1] - minimal latitude in decimal degrees
- * @param extent[2] - maximal longitude in decimal degrees
- * @param extent[3] - maximal latitude in decimal degrees
- * @param cartorgraphicCenter - tileset center in cartographic coordinate system
- * @param cartesianCenter - tileset center in cartesian coordinate system
- * @returns - initial zoom for the tileset
- */
-export function getZoomFromExtent(
-  extent: [number, number, number, number],
-  cartorgraphicCenter: Vector3,
-  cartesianCenter: Vector3
-) {
-  const [xmin, ymin, xmax, ymax] = extent;
-  return getZoomFromFullExtent(
-    {xmin, xmax, ymin, ymax, zmin: 0, zmax: 0},
-    cartorgraphicCenter,
-    cartesianCenter
-  );
-}
-
-function getObbSize(halfAxes) {
-  halfAxes.getColumn(0, scratchVector);
-  const axeY = halfAxes.getColumn(1);
-  const axeZ = halfAxes.getColumn(2);
-  const farthestVertex = scratchVector.add(axeY).add(axeZ);
-  const size = farthestVertex.len();
-  return size;
-}

package/src/types.ts

@@ -1,54 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {Vector3} from '@math.gl/core';
-import type {Plane} from '@math.gl/culling';
-
-export type BoundingRectangle = {
-  width: number;
-  height: number;
-};
-
-/** Deck.gl Viewport instance type.
- * We can't import it from Deck.gl to avoid circular reference */
-export type Viewport = {
-  id: string;
-  cameraPosition: number[] | Vector3;
-  height: number;
-  width: number;
-  zoom: number;
-  /** Perspective vertical field of view in degrees, when exposed by the viewport. */
-  fovy?: number;
-  /** Whether this viewport uses an orthographic projection. */
-  orthographic?: boolean;
-  /**
-   * World-space meters represented by one logical/CSS pixel at the viewport's current scale.
-   * Orthographic 3D Tiles traversal requires a positive, finite value to calculate SSE.
-   */
-  metersPerPixel?: number;
-  /** Optional world-space clipping planes used to cull renderable tile content. */
-  clippingPlanes?: Plane[];
-  distanceScales: {
-    unitsPerMeter: number[];
-    metersPerUnit: number[];
-  };
-  center: number[] | Vector3;
-  unprojectPosition: (position: number[] | Vector3) => [number, number, number];
-  project: (coorinates: number[] | Vector3) => number[];
-};
-
-/**
- * Contain extra fields from WebMercatorViewport and FirstPersonViewport
- */
-export type GeospatialViewport = Viewport & {
-  /** @todo This field is not represented in Deck.gl viewports. Can be removed in the next version */
-  cameraDirection: [number, number, number];
-  /** @todo This field is not represented in Deck.gl viewports. Can be removed in the next version */
-  cameraUp: [number, number, number];
-  /** Camera target offset in meters from longitude/latitude, including elevation. */
-  position?: number[];
-  longitude: number;
-  latitude: number;
-  bearing: number;
-};

package/src/utils/doubly-linked-list-node.ts

@@ -1,22 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-/**
- * Doubly linked list node
- * @private
- */
-export class DoublyLinkedListNode {
-  item;
-  previous;
-  next;
-
-  constructor(item, previous, next) {
-    this.item = item;
-    this.previous = previous;
-    this.next = next;
-  }
-}

package/src/utils/doubly-linked-list.ts

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-import {DoublyLinkedListNode} from './doubly-linked-list-node';
-
-/**
- * Doubly linked list
- * @private
- */
-export class DoublyLinkedList {
-  head: DoublyLinkedListNode | null = null;
-  tail: DoublyLinkedListNode | null = null;
-  _length = 0;
-
-  get length() {
-    return this._length;
-  }
-
-  /**
-   * Adds the item to the end of the list
-   * @param {*} [item]
-   * @return {DoublyLinkedListNode}
-   */
-  add(item) {
-    const node = new DoublyLinkedListNode(item, this.tail, null);
-
-    if (this.tail) {
-      this.tail.next = node;
-      this.tail = node;
-    } else {
-      this.head = node;
-      this.tail = node;
-    }
-
-    ++this._length;
-
-    return node;
-  }
-
-  /**
-   * Removes the given node from the list
-   * @param {DoublyLinkedListNode} node
-   */
-  remove(node) {
-    if (!node) {
-      return;
-    }
-
-    if (node.previous && node.next) {
-      node.previous.next = node.next;
-      node.next.previous = node.previous;
-    } else if (node.previous) {
-      // Remove last node
-      node.previous.next = null;
-      this.tail = node.previous;
-    } else if (node.next) {
-      // Remove first node
-      node.next.previous = null;
-      this.head = node.next;
-    } else {
-      // Remove last node in the linked list
-      this.head = null;
-      this.tail = null;
-    }
-
-    node.next = null;
-    node.previous = null;
-
-    --this._length;
-  }
-
-  /**
-   * Moves nextNode after node
-   * @param {DoublyLinkedListNode} node
-   * @param {DoublyLinkedListNode} nextNode
-   */
-  splice(node, nextNode) {
-    if (node === nextNode) {
-      return;
-    }
-
-    // Remove nextNode, then insert after node
-    this.remove(nextNode);
-    this._insert(node, nextNode);
-  }
-
-  _insert(node, nextNode) {
-    const oldNodeNext = node.next;
-    node.next = nextNode;
-
-    // nextNode is the new tail
-    if (this.tail === node) {
-      this.tail = nextNode;
-    } else {
-      oldNodeNext.previous = nextNode;
-    }
-
-    nextNode.next = oldNodeNext;
-    nextNode.previous = node;
-
-    ++this._length;
-  }
-}

package/src/utils/managed-array.ts

@@ -1,174 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-import {assert} from '@loaders.gl/loader-utils';
-
-/**
- * A wrapper around arrays so that the internal length of the array can be manually managed.
- *
- * @alias ManagedArray
- * @constructor
- * @private
- *
- * @param {Number} [length=0] The initial length of the array.
- */
-export class ManagedArray {
-  _map = new Map();
-  _array: any[];
-  _length: number;
-
-  constructor(length = 0) {
-    this._array = new Array(length);
-    this._length = length;
-  }
-
-  /**
-   * Gets or sets the length of the array.
-   * If the set length is greater than the length of the internal array, the internal array is resized.
-   *
-   * @memberof ManagedArray.prototype
-   * @type Number
-   */
-  get length() {
-    return this._length;
-  }
-
-  set length(length) {
-    this._length = length;
-    if (length > this._array.length) {
-      this._array.length = length;
-    }
-  }
-
-  /**
-   * Gets the internal array.
-   *
-   * @memberof ManagedArray.prototype
-   * @type Array
-   * @readonly
-   */
-  get values() {
-    return this._array;
-  }
-
-  /**
-   * Gets the element at an index.
-   *
-   * @param {Number} index The index to get.
-   */
-  get(index) {
-    assert(index < this._array.length);
-    return this._array[index];
-  }
-
-  /**
-   * Sets the element at an index. Resizes the array if index is greater than the length of the array.
-   *
-   * @param {Number} index The index to set.
-   * @param {*} element The element to set at index.
-   */
-  set(index, element) {
-    assert(index >= 0);
-
-    if (index >= this.length) {
-      this.length = index + 1;
-    }
-
-    if (this._map.has(this._array[index])) {
-      this._map.delete(this._array[index]);
-    }
-
-    this._array[index] = element;
-    this._map.set(element, index);
-  }
-
-  delete(element) {
-    const index = this._map.get(element);
-    if (index >= 0) {
-      this._array.splice(index, 1);
-      this._map.delete(element);
-      this.length--;
-    }
-  }
-
-  /**
-   * Returns the last element in the array without modifying the array.
-   *
-   * @returns {*} The last element in the array.
-   */
-  peek() {
-    return this._array[this._length - 1];
-  }
-
-  /**
-   * Push an element into the array.
-   *
-   * @param {*} element The element to push.
-   */
-  push(element) {
-    if (!this._map.has(element)) {
-      const index = this.length++;
-      this._array[index] = element;
-      this._map.set(element, index);
-    }
-  }
-
-  /**
-   * Pop an element from the array.
-   *
-   * @returns {*} The last element in the array.
-   */
-  pop() {
-    const element = this._array[--this.length];
-    this._map.delete(element);
-    return element;
-  }
-
-  /**
-   * Resize the internal array if length > _array.length.
-   *
-   * @param {Number} length The length.
-   */
-  reserve(length) {
-    assert(length >= 0);
-
-    if (length > this._array.length) {
-      this._array.length = length;
-    }
-  }
-
-  /**
-   * Resize the array.
-   *
-   * @param {Number} length The length.
-   */
-  resize(length) {
-    assert(length >= 0);
-
-    this.length = length;
-  }
-
-  /**
-   * Trim the internal array to the specified length. Defaults to the current length.
-   *
-   * @param {Number} [length] The length.
-   */
-  trim(length) {
-    if (length === null || length === undefined) {
-      length = this.length;
-    }
-    this._array.length = length;
-  }
-
-  reset() {
-    this._array = [];
-    this._map = new Map();
-    this._length = 0;
-  }
-
-  find(target) {
-    return this._map.has(target);
-  }
-}