itowns 2.44.3-next.3 → 2.44.3-next.31

package/lib/Core/Prefab/Globe/GlobeLayer.js

@@ -1,9 +1,8 @@
 import * as THREE from 'three';
 import TiledGeometryLayer from "../../../Layer/TiledGeometryLayer.js";
 import { ellipsoidSizes } from "../../Math/Ellipsoid.js";
-import { globalExtentTMS, schemeTiles } from "../../Geographic/Extent.js";
-import BuilderEllipsoidTile from "./BuilderEllipsoidTile.js";
-import CRS from "../../Geographic/Crs.js";
+import { globalExtentTMS, schemeTiles } from "../../Tile/TileGrid.js";
+import { GlobeTileBuilder } from "./GlobeTileBuilder.js";
 
 // matrix to convert sphere to ellipsoid
 const worldToScaledEllipsoid = new THREE.Matrix4();
@@ -18,18 +17,18 @@ const scaledHorizonCullingPoint = new THREE.Vector3();
  * @property {boolean} isGlobeLayer - Used to checkout whether this layer is a
  * GlobeLayer. Default is true. You should not change this, as it is used
  * internally for optimisation.
+ *
+ * @extends TiledGeometryLayer
  */
 class GlobeLayer extends TiledGeometryLayer {
   /**
    * A {@link TiledGeometryLayer} to use with a {@link GlobeView}. It has
    * specific method for updating and subdivising its grid.
    *
-   * @extends TiledGeometryLayer
-   *
    * @param {string} id - The id of the layer, that should be unique. It is
    * not mandatory, but an error will be emitted if this layer is added a
    * {@link View} that already has a layer going by that id.
-   * @param {THREE.Object3d} [object3d=THREE.Group] - The object3d used to
+   * @param {THREE.Object3D} [object3d=THREE.Group] - The object3d used to
    * contain the geometry of the TiledGeometryLayer. It is usually a
    * `THREE.Group`, but it can be anything inheriting from a `THREE.Object3d`.
    * @param {Object} [config] - Optional configuration, all elements in it
@@ -48,22 +47,30 @@ class GlobeLayer extends TiledGeometryLayer {
    */
   constructor(id, object3d) {
     let config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const {
+      minSubdivisionLevel = 2,
+      maxSubdivisionLevel = 19,
+      ...tiledConfig
+    } = config;
+
     // Configure tiles
-    const scheme = schemeTiles.get(CRS.tms_4326);
+    const scheme = schemeTiles.get('EPSG:4326');
     const schemeTile = globalExtentTMS.get('EPSG:4326').subdivisionByScheme(scheme);
 
     // Supported tile matrix set for color/elevation layer
-    config.tileMatrixSets = [CRS.tms_4326, CRS.tms_3857];
-    const uvCount = config.tileMatrixSets.length;
-    const builder = new BuilderEllipsoidTile({
-      crs: 'EPSG:4978',
+    const tileMatrixSets = ['EPSG:4326', 'EPSG:3857'];
+    const uvCount = tileMatrixSets.length;
+    const builder = new GlobeTileBuilder({
       uvCount
     });
-    super(id, object3d || new THREE.Group(), schemeTile, builder, config);
+    super(id, object3d || new THREE.Group(), schemeTile, builder, {
+      tileMatrixSets,
+      ...tiledConfig
+    });
     this.isGlobeLayer = true;
     this.options.defaultPickingRadius = 5;
-    this.minSubdivisionLevel = this.minSubdivisionLevel == undefined ? 2 : this.minSubdivisionLevel;
-    this.maxSubdivisionLevel = this.maxSubdivisionLevel == undefined ? 19 : this.maxSubdivisionLevel;
+    this.minSubdivisionLevel = minSubdivisionLevel;
+    this.maxSubdivisionLevel = maxSubdivisionLevel;
     this.extent = this.schemeTile[0].clone();
     for (let i = 1; i < this.schemeTile.length; i++) {
       this.extent.union(this.schemeTile[i]);
@@ -97,7 +104,7 @@ class GlobeLayer extends TiledGeometryLayer {
   }
   subdivision(context, layer, node) {
     if (node.level == 5) {
-      const row = node.getExtentsByProjection(CRS.tms_4326)[0].row;
+      const row = node.getExtentsByProjection('EPSG:4326')[0].row;
       if (row == 31 || row == 0) {
         // doesn't subdivise the pole
         return false;

package/lib/Core/Prefab/Globe/GlobeTileBuilder.js

@@ -0,0 +1,111 @@
+import * as THREE from 'three';
+import Coordinates from "../../Geographic/Coordinates.js";
+import Extent from "../../Geographic/Extent.js";
+const PI_OV_FOUR = Math.PI / 4;
+const INV_TWO_PI = 1.0 / (Math.PI * 2);
+const axisZ = new THREE.Vector3(0, 0, 1);
+const axisY = new THREE.Vector3(0, 1, 0);
+const quatToAlignLongitude = new THREE.Quaternion();
+const quatToAlignLatitude = new THREE.Quaternion();
+const quatNormalToZ = new THREE.Quaternion();
+
+/** Transforms a WGS84 latitude into a usable texture offset. */
+function WGS84ToOneSubY(latitude) {
+  return 1.0 - (0.5 - Math.log(Math.tan(PI_OV_FOUR + THREE.MathUtils.degToRad(latitude) * 0.5)) * INV_TWO_PI);
+}
+
+/** Specialized parameters for the [GlobeTileBuilder]. */
+
+/**
+ * TileBuilder implementation for the purpose of generating globe (or more
+ * precisely ellipsoidal) tile arrangements.
+ */
+export class GlobeTileBuilder {
+  static _crs = 'EPSG:4978';
+  static _computeExtraOffset(params) {
+    const t = WGS84ToOneSubY(params.coordinates.latitude) * params.nbRow;
+    return (!isFinite(t) ? 0 : t) - params.deltaUV1;
+  }
+
+  /**
+   * Buffer holding information about the tile/vertex currently being
+   * processed.
+   */
+
+  get crs() {
+    return GlobeTileBuilder._crs;
+  }
+  constructor(options) {
+    this._transform = {
+      coords: [new Coordinates('EPSG:4326', 0, 0), new Coordinates('EPSG:4326', 0, 0)],
+      position: new THREE.Vector3(),
+      dimension: new THREE.Vector2()
+    };
+
+    // UV: Normalized coordinates (from degree) on the entire tile
+    // EPSG:4326
+    // Offset: Float row coordinate from Pseudo mercator coordinates
+    // EPSG:3857
+    if (options.uvCount > 1) {
+      this.computeExtraOffset = GlobeTileBuilder._computeExtraOffset;
+    }
+  }
+  prepare(params) {
+    const nbRow = 2 ** (params.level + 1.0);
+    let st1 = WGS84ToOneSubY(params.extent.south);
+    if (!isFinite(st1)) {
+      st1 = 0;
+    }
+    const start = st1 % (1.0 / nbRow);
+    const newParams = {
+      nbRow,
+      deltaUV1: (st1 - start) * nbRow,
+      // transformation to align tile's normal to z axis
+      quatNormalToZ: quatNormalToZ.setFromAxisAngle(axisY, -(Math.PI * 0.5 - THREE.MathUtils.degToRad(params.extent.center().latitude))),
+      // let's avoid building too much temp objects
+      coordinates: new Coordinates(this.crs)
+    };
+    params.extent.planarDimensions(this._transform.dimension);
+    return {
+      ...params,
+      ...newParams
+    };
+  }
+  center(extent) {
+    return extent.center(this._transform.coords[0]).as(this.crs, this._transform.coords[1]).toVector3();
+  }
+  vertexPosition(coordinates) {
+    return this._transform.coords[0].setFromValues(coordinates.x, coordinates.y).as(this.crs, this._transform.coords[1]).toVector3(this._transform.position);
+  }
+  vertexNormal() {
+    return this._transform.coords[1].geodesicNormal;
+  }
+  uProject(u, extent) {
+    return extent.west + u * this._transform.dimension.x;
+  }
+  vProject(v, extent) {
+    return extent.south + v * this._transform.dimension.y;
+  }
+  computeShareableExtent(extent) {
+    // NOTE: It should be possible to take advantage of equatorial plane
+    // symmetry, for which we'd have to reverse the tile's UVs.
+    // This would halve the memory requirement when viewing a full globe,
+    // but that case is not that relevant for iTowns' usual use cases and
+    // the globe mesh memory usage is already inconsequential.
+    const sizeLongitude = Math.abs(extent.west - extent.east) / 2;
+    const shareableExtent = new Extent(extent.crs, -sizeLongitude, sizeLongitude, extent.south, extent.north);
+
+    // Compute rotation to transform the tile to position on the ellispoid.
+    // This transformation takes the parents' transformation into account.
+    const rotLon = THREE.MathUtils.degToRad(extent.west - shareableExtent.west);
+    const rotLat = THREE.MathUtils.degToRad(90 - extent.center(this._transform.coords[0]).latitude);
+    quatToAlignLongitude.setFromAxisAngle(axisZ, rotLon);
+    quatToAlignLatitude.setFromAxisAngle(axisY, rotLat);
+    quatToAlignLongitude.multiply(quatToAlignLatitude);
+    return {
+      shareableExtent,
+      quaternion: quatToAlignLongitude.clone(),
+      position: this.center(extent)
+    };
+  }
+}

package/lib/Core/Prefab/GlobeView.js

@@ -5,7 +5,6 @@ import Coordinates from "../Geographic/Coordinates.js";
 import GlobeLayer from "./Globe/GlobeLayer.js";
 import Atmosphere from "./Globe/Atmosphere.js";
 import CameraUtils from "../../Utils/CameraUtils.js";
-import CRS from "../Geographic/Crs.js";
 import { ellipsoidSizes } from "../Math/Ellipsoid.js";
 
 /**
@@ -90,10 +89,6 @@ class GlobeView extends View {
     this.camera3D.far = ellipsoidSizes.x * 10;
     const tileLayer = new GlobeLayer('globe', options.object3d, options);
     this.mainLoop.gfxEngine.label2dRenderer.infoTileLayer = tileLayer.info;
-    const sun = new THREE.DirectionalLight();
-    sun.position.set(-0.5, 0, 1);
-    sun.updateMatrixWorld(true);
-    this.scene.add(sun);
     this.addLayer(tileLayer);
     this.tileLayer = tileLayer;
     if (!placement.isExtent) {
@@ -133,11 +128,11 @@ class GlobeView extends View {
       return Promise.reject(new Error('Add Layer type object'));
     }
     if (layer.isColorLayer) {
-      if (!this.tileLayer.tileMatrixSets.includes(CRS.formatToTms(layer.source.crs))) {
+      if (!this.tileLayer.tileMatrixSets.includes(layer.source.crs)) {
         return layer._reject(`Only ${this.tileLayer.tileMatrixSets} tileMatrixSet are currently supported for color layers`);
       }
     } else if (layer.isElevationLayer) {
-      if (CRS.formatToTms(layer.source.crs) !== this.tileLayer.tileMatrixSets[0]) {
+      if (layer.source.crs !== this.tileLayer.tileMatrixSets[0]) {
         return layer._reject(`Only ${this.tileLayer.tileMatrixSets[0]} tileMatrixSet is currently supported for elevation layers`);
       }
     }

package/lib/Core/Prefab/Planar/PlanarLayer.js

@@ -1,21 +1,19 @@
 import * as THREE from 'three';
 import TiledGeometryLayer from "../../../Layer/TiledGeometryLayer.js";
-import { globalExtentTMS } from "../../Geographic/Extent.js";
-import CRS from "../../Geographic/Crs.js";
-import PlanarTileBuilder from "./PlanarTileBuilder.js";
+import { globalExtentTMS } from "../../Tile/TileGrid.js";
+import { PlanarTileBuilder } from "./PlanarTileBuilder.js";
 
 /**
  * @property {boolean} isPlanarLayer - Used to checkout whether this layer is a
  * PlanarLayer. Default is true. You should not change this, as it is used
  * internally for optimisation.
+ * @extends TiledGeometryLayer
  */
 class PlanarLayer extends TiledGeometryLayer {
   /**
    * A {@link TiledGeometryLayer} to use with a {@link PlanarView}. It has
    * specific method for updating and subdivising its grid.
    *
-   * @extends TiledGeometryLayer
-   *
    * @param {string} id - The id of the layer, that should be unique. It is
    * not mandatory, but an error will be emitted if this layer is added a
    * {@link View} that already has a layer going by that id.
@@ -35,19 +33,27 @@ class PlanarLayer extends TiledGeometryLayer {
    */
   constructor(id, extent, object3d) {
     let config = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const tms = CRS.formatToTms(extent.crs);
+    const {
+      minSubdivisionLevel = 0,
+      maxSubdivisionLevel = 5,
+      ...tiledConfig
+    } = config;
+    const tileMatrixSets = [extent.crs];
     if (!globalExtentTMS.get(extent.crs)) {
       // Add new global extent for this new crs projection.
       globalExtentTMS.set(extent.crs, extent);
     }
-    config.tileMatrixSets = [tms];
-    super(id, object3d || new THREE.Group(), [extent], new PlanarTileBuilder({
+    const builder = new PlanarTileBuilder({
       crs: extent.crs
-    }), config);
+    });
+    super(id, object3d || new THREE.Group(), [extent], builder, {
+      tileMatrixSets,
+      ...tiledConfig
+    });
     this.isPlanarLayer = true;
     this.extent = extent;
-    this.minSubdivisionLevel = this.minSubdivisionLevel == undefined ? 0 : this.minSubdivisionLevel;
-    this.maxSubdivisionLevel = this.maxSubdivisionLevel == undefined ? 5 : this.maxSubdivisionLevel;
+    this.minSubdivisionLevel = minSubdivisionLevel;
+    this.maxSubdivisionLevel = maxSubdivisionLevel;
   }
 }
 export default PlanarLayer;

package/lib/Core/Prefab/Planar/PlanarTileBuilder.js

@@ -3,70 +3,70 @@ import Coordinates from "../../Geographic/Coordinates.js";
 import Extent from "../../Geographic/Extent.js";
 const quaternion = new THREE.Quaternion();
 const center = new THREE.Vector3();
-class PlanarTileBuilder {
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    /* istanbul ignore next */
+
+/** Specialized parameters for the [PlanarTileBuilder]. */
+
+/**
+ * TileBuilder implementation for the purpose of generating planar
+ * tile arrangements.
+ */
+export class PlanarTileBuilder {
+  constructor(options) {
     if (options.projection) {
-      console.warn('PlanarTileBuilder projection parameter is deprecated, use crs instead.');
-      options.crs = options.crs || options.projection;
-    }
-    if (options.crs) {
-      this.crs = options.crs;
-    } else {
-      throw new Error('options.crs is mandatory for PlanarTileBuilder');
+      console.warn('PlanarTileBuilder projection parameter is deprecated,' + ' use crs instead.');
+      options.crs ??= options.projection;
     }
-    this.tmp = {
+    this._crs = options.crs;
+    this._transform = {
       coords: new Coordinates('EPSG:4326', 0, 0),
       position: new THREE.Vector3(),
       normal: new THREE.Vector3(0, 0, 1)
     };
-    this.uvCount = options.uvCount || 1;
+    this._uvCount = options.uvCount ?? 1;
+  }
+  get uvCount() {
+    return this._uvCount;
+  }
+  get crs() {
+    return this._crs;
   }
-  // prepare params
-  // init projected object -> params.projected
   prepare(params) {
-    params.nbRow = 2 ** (params.zoom + 1.0);
-    params.projected = new THREE.Vector3();
+    const newParams = params;
+    newParams.nbRow = 2 ** (params.level + 1.0);
+    newParams.coordinates = new Coordinates(this.crs);
+    return newParams;
   }
-
-  // get center tile in cartesian 3D
   center(extent) {
-    extent.center(this.tmp.coords);
-    center.set(this.tmp.coords.x, this.tmp.coords.y, 0);
+    extent.center(this._transform.coords);
+    center.set(this._transform.coords.x, this._transform.coords.y, 0);
     return center;
   }
-
-  // get position 3D cartesian
-  vertexPosition(params) {
-    this.tmp.position.set(params.projected.x, params.projected.y, 0);
-    return this.tmp.position;
+  vertexPosition(coordinates) {
+    this._transform.position.set(coordinates.x, coordinates.y, 0);
+    return this._transform.position;
   }
-
-  // get normal for last vertex
   vertexNormal() {
-    return this.tmp.normal;
+    return this._transform.normal;
   }
-
-  // coord u tile to projected
-  uProjecte(u, params) {
-    params.projected.x = params.extent.west + u * (params.extent.east - params.extent.west);
+  uProject(u, extent) {
+    return extent.west + u * (extent.east - extent.west);
   }
-
-  // coord v tile to projected
-  vProjecte(v, params) {
-    params.projected.y = params.extent.south + v * (params.extent.north - params.extent.south);
+  vProject(v, extent) {
+    return extent.south + v * (extent.north - extent.south);
   }
-  computeSharableExtent(extent) {
-    // compute sharable extent to pool the geometries
+  computeShareableExtent(extent) {
+    // compute shareable extent to pool the geometries
     // the geometry in common extent is identical to the existing input
     // with a translation
-    const sharableExtent = new Extent(extent.crs, 0, Math.abs(extent.west - extent.east), 0, Math.abs(extent.north - extent.south));
     return {
-      sharableExtent,
+      shareableExtent: new Extent(extent.crs, {
+        west: 0,
+        east: Math.abs(extent.west - extent.east),
+        south: 0,
+        north: Math.abs(extent.north - extent.south)
+      }),
       quaternion,
       position: this.center(extent).clone()
     };
   }
-}
-export default PlanarTileBuilder;
+}

package/lib/Core/Prefab/TileBuilder.js

@@ -1,17 +1,23 @@
 import * as THREE from 'three';
-import TileGeometry from "../TileGeometry.js";
+import { TileGeometry } from "../TileGeometry.js";
 import Cache from "../Scheduler/Cache.js";
-import computeBuffers from "./computeBufferTileGeometry.js";
+import { computeBuffers } from "./computeBufferTileGeometry.js";
 import OBB from "../../Renderer/OBB.js";
 const cacheBuffer = new Map();
 const cacheTile = new Cache();
-export default function newTileGeometry(builder, params) {
+
+/**
+ * Reference to a tile's extent with rigid transformations.
+ * Enables reuse of geometry, saving a bit of memory.
+ */
+
+export function newTileGeometry(builder, params) {
   const {
-    sharableExtent,
+    shareableExtent,
     quaternion,
     position
-  } = builder.computeSharableExtent(params.extent);
-  const south = sharableExtent.south.toFixed(6);
+  } = builder.computeShareableExtent(params.extent);
+  const south = shareableExtent.south.toFixed(6);
   const bufferKey = `${builder.crs}_${params.disableSkirt ? 0 : 1}_${params.segments}`;
   let promiseGeometry = cacheTile.get(south, params.level, bufferKey);
 
@@ -22,49 +28,38 @@ export default function newTileGeometry(builder, params) {
       resolve = r;
     });
     cacheTile.set(promiseGeometry, south, params.level, bufferKey);
-    params.extent = sharableExtent;
+    params.extent = shareableExtent;
     params.center = builder.center(params.extent).clone();
-    // Read previously cached values (index and uv.wgs84 only depend on the # of triangles)
+    // Read previously cached values (index and uv.wgs84 only
+    // depend on the # of triangles)
     let cachedBuffers = cacheBuffer.get(bufferKey);
     params.buildIndexAndUv_0 = !cachedBuffers;
-    params.builder = builder;
     let buffers;
     try {
-      buffers = computeBuffers(params);
+      buffers = computeBuffers(builder, params);
     } catch (e) {
       return Promise.reject(e);
     }
     if (!cachedBuffers) {
       cachedBuffers = {};
+      // We know the fields will exist due to the condition
+      // matching with the one for buildIndexAndUv_0.
+      // TODO: Make this brain-based check compiler-based.
       cachedBuffers.index = new THREE.BufferAttribute(buffers.index, 1);
       cachedBuffers.uv = new THREE.BufferAttribute(buffers.uvs[0], 2);
 
       // Update cacheBuffer
       cacheBuffer.set(bufferKey, cachedBuffers);
     }
-    buffers.index = cachedBuffers.index;
-    buffers.uvs[0] = cachedBuffers.uv;
-    buffers.position = new THREE.BufferAttribute(buffers.position, 3);
-    buffers.normal = new THREE.BufferAttribute(buffers.normal, 3);
-    if (params.builder.uvCount > 1) {
-      buffers.uvs[1] = new THREE.BufferAttribute(buffers.uvs[1], 1);
-    }
-    const geometry = new TileGeometry(params, buffers);
-    geometry.OBB = new OBB(geometry.boundingBox.min, geometry.boundingBox.max);
-    geometry._count = 0;
-    geometry.dispose = () => {
-      geometry._count--;
-      if (geometry._count <= 0) {
-        // To avoid remove index buffer and attribute buffer uv
-        //  error un-bound buffer in webgl with VAO rendering.
-        // Could be removed if the attribute buffer deleting is
-        //  taken into account in the buffer binding state (in THREE.WebGLBindingStates code).
-        geometry.index = null;
-        delete geometry.attributes.uv;
-        THREE.BufferGeometry.prototype.dispose.call(geometry);
-        cacheTile.delete(south, params.level, bufferKey);
-      }
+    const gpuBuffers = {
+      index: cachedBuffers.index,
+      uvs: [cachedBuffers.uv, ...(buffers.uvs[1] !== undefined ? [new THREE.BufferAttribute(buffers.uvs[1], 1)] : [])],
+      position: new THREE.BufferAttribute(buffers.position, 3),
+      normal: new THREE.BufferAttribute(buffers.normal, 3)
     };
+    const geometry = new TileGeometry(builder, params, gpuBuffers);
+    geometry.OBB = new OBB(geometry.boundingBox.min, geometry.boundingBox.max);
+    geometry.initRefCount(cacheTile, [south, params.level, bufferKey]);
     resolve(geometry);
     return Promise.resolve({
       geometry,