itowns 2.44.3-next.4 → 2.44.3-next.40

package/lib/Core/Geographic/GeoidGrid.js

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
+import * as CRS from "./Crs.js";
 import Coordinates from "./Coordinates.js";
-import CRS from "./Crs.js";
 const coord = new Coordinates('EPSG:4326');
 const indexes = new THREE.Vector2();
 function biLinearInterpolation(indexes, getData) {

package/lib/Core/MainLoop.js

@@ -42,7 +42,6 @@ function updateElements(context, geometryLayer, elements) {
         for (const attachedLayer of geometryLayer.attachedLayers) {
           if (attachedLayer.ready) {
             attachedLayer.update(context, attachedLayer, sub.element, sub.parent);
-            attachedLayer.cache.flush();
           }
         }
       } else if (sub.elements) {
@@ -56,7 +55,6 @@ function updateElements(context, geometryLayer, elements) {
           for (const attachedLayer of geometryLayer.attachedLayers) {
             if (attachedLayer.ready) {
               attachedLayer.update(context, attachedLayer, sub.elements[i], sub.parent);
-              attachedLayer.cache.flush();
             }
           }
         }
@@ -140,7 +138,7 @@ class MainLoop extends EventDispatcher {
         }
 
         // Clear the cache of expired resources
-        geometryLayer.cache.flush();
+
         view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_LAYER_UPDATE, dt, this.#updateLoopRestarted, geometryLayer);
       }
     }

package/lib/Core/Math/Ellipsoid.js

@@ -1,9 +1,26 @@
 import * as THREE from 'three';
 import proj4 from 'proj4';
 import Coordinates from "../Geographic/Coordinates.js";
+
+/**
+ * Length of the semi-axes of the WGS84 ellipsoid.
+ * @internal
+ */
 export const ellipsoidSizes = new THREE.Vector3(proj4.WGS84.a, proj4.WGS84.a, proj4.WGS84.b);
 const normal = new THREE.Vector3();
 class Ellipsoid {
+  /**
+   * Length of the semi-axes of the ellipsoid.
+   */
+
+  /**
+   * Eccentricity of the ellipsoid.
+   */
+
+  /**
+   * @param size - Length of the semi-axes of the ellipsoid. Defaults to those
+   * defined by the WGS84 ellipsoid.
+   */
   constructor() {
     let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ellipsoidSizes;
     this.size = new THREE.Vector3();
@@ -12,10 +29,28 @@ class Ellipsoid {
     this.eccentricity = 0;
     this.setSize(size);
   }
+
+  /**
+   * Computes the normal vector to an ellipsoid at the given cartesian
+   * coordinate `(x, y, z)`.
+   *
+   * @param cartesian - The given cartesian coordinate.
+   * @param target - An object to store this vector to. If this is not
+   * specified, a new vector will be created.
+   */
   geodeticSurfaceNormal(cartesian) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
     return cartesian.toVector3(target).multiply(this._invRadiiSquared).normalize();
   }
+
+  /**
+   * Computes the normal vector to an ellipsoid at the given geographic
+   * coordinate `(longitude, latitude, altitude)`.
+   *
+   * @param coordCarto - The given geographic coordinate.
+   * @param target - An object to store this vector to. If this is not
+   * specified, a new vector will be created.
+   */
   geodeticSurfaceNormalCartographic(coordCarto) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
     const longitude = THREE.MathUtils.degToRad(coordCarto.longitude);
@@ -23,13 +58,22 @@ class Ellipsoid {
     const cosLatitude = Math.cos(latitude);
     return target.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude));
   }
+
+  /**
+   * Sets the length of the semi-axes of this ellipsoid from a 3-dimensional
+   * vector-like object. The object shall have both `x`, `y` and `z`
+   * properties.
+   *
+   * @param size - The source vector.
+   */
   setSize(size) {
     this.size.set(size.x, size.y, size.z);
     this._radiiSquared.multiplyVectors(size, size);
-    this._invRadiiSquared.x = size.x == 0 ? 0 : 1 / this._radiiSquared.x;
-    this._invRadiiSquared.y = size.y == 0 ? 0 : 1 / this._radiiSquared.y;
-    this._invRadiiSquared.z = size.z == 0 ? 0 : 1 / this._radiiSquared.z;
+    this._invRadiiSquared.x = size.x === 0 ? 0 : 1 / this._radiiSquared.x;
+    this._invRadiiSquared.y = size.y === 0 ? 0 : 1 / this._radiiSquared.y;
+    this._invRadiiSquared.z = size.z === 0 ? 0 : 1 / this._radiiSquared.z;
     this.eccentricity = Math.sqrt(this._radiiSquared.x - this._radiiSquared.z) / this.size.x;
+    return this;
   }
   cartographicToCartesian(coordCarto) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
@@ -42,18 +86,18 @@ class Ellipsoid {
   }
 
   /**
-   * Convert cartesian coordinates to geographic according to the current ellipsoid of revolution.
-   * @param {Object} position - The coordinate to convert
-   * @param {number} position.x
-   * @param {number} position.y
-   * @param {number} position.z
-   * @param {Coordinate} [target] coordinate to copy result
-   * @returns {Coordinate} an object describing the coordinates on the reference ellipsoid, angles are in degree
+   * Convert cartesian coordinates to geographic according to the current
+   * ellipsoid of revolution.
+   * @param position - The coordinate to convert
+   * @param target - coordinate to copy result
+   * @returns an object describing the coordinates on the reference ellipsoid,
+   * angles are in degree
    */
   cartesianToCartographic(position) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Coordinates('EPSG:4326', 0, 0, 0);
     // for details, see for example http://www.linz.govt.nz/data/geodetic-system/coordinate-conversion/geodetic-datum-conversions/equations-used-datum
-    // TODO the following is only valable for oblate ellipsoid of revolution. do we want to support triaxial ellipsoid?
+    // TODO the following is only valable for oblate ellipsoid of
+    // revolution. do we want to support triaxial ellipsoid?
     const R = Math.sqrt(position.x * position.x + position.y * position.y + position.z * position.z);
     const a = this.size.x; // x
     const b = this.size.z; // z
@@ -92,9 +136,9 @@ class Ellipsoid {
     const t1 = (-b + d) / (2 * a);
     const t2 = (-b - d) / (2 * a);
     if (t1 <= EPSILON && t2 <= EPSILON) {
+      // both intersections are behind the ray origin
       return false;
-    } // both intersections are behind the ray origin
-    // var back = (t1 <= EPSILON || t2 <= EPSILON); // If only one intersection (t>0) then we are inside the ellipsoid and the intersection is at the back of the ellipsoid
+    }
     let t = 0;
     if (t1 <= EPSILON) {
       t = t2;
@@ -111,19 +155,16 @@ class Ellipsoid {
     inter.addVectors(ray.origin, dir.clone().setLength(t));
     return inter;
   }
-  computeDistance(coordCarto1, coordCarto2) {
-    console.warn('computeDistance is renamed to geodesicDistance');
-    this.geodesicDistance(coordCarto1, coordCarto2);
-  }
 
   /**
    * Calculate the geodesic distance, between coordCarto1 and coordCarto2.
-   * It's most short distance on ellipsoid surface between coordCarto1 and coordCarto2.
+   * It's most short distance on ellipsoid surface between coordCarto1 and
+   * coordCarto2.
    * It's called orthodromy.
    *
-   * @param      {Coordinates}  coordCarto1  The coordinate carto 1
-   * @param      {Coordinates}  coordCarto2  The coordinate carto 2
-   * @return     {number}  The orthodromic distance between the two given coordinates.
+   * @param coordCarto1 - The coordinate carto 1
+   * @param coordCarto2 - The coordinate carto 2
+   * @returns The orthodromic distance between the two given coordinates.
    */
   geodesicDistance(coordCarto1, coordCarto2) {
     // The formula uses the distance on approximated sphere,

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

@@ -1,9 +1,3 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-
 import * as THREE from 'three';
 import GeometryLayer from "../../../Layer/GeometryLayer.js";
 import Coordinates from "../../Geographic/Coordinates.js";
@@ -31,6 +25,10 @@ const colorSky = new THREE.Color();
 const spaceColor = new THREE.Color(0x030508);
 const limitAlti = 600000;
 const mfogDistance = ellipsoidSizes.x * 160.0;
+
+/**
+ * @extends GeometryLayer
+ */
 class Atmosphere extends GeometryLayer {
   /**
   * It's layer to simulate Globe atmosphere.
@@ -40,8 +38,6 @@ class Atmosphere extends GeometryLayer {
   * * [Atmosphere Shader From Space (Atmospheric scattering)](http://stainlessbeer.weebly.com/planets-9-atmospheric-scattering.html)
   * * [Accurate Atmospheric Scattering (NVIDIA GPU Gems 2)](https://developer.nvidia.com/gpugems/gpugems2/part-ii-shading-lighting-and-shadows/chapter-16-accurate-atmospheric-scattering).
   *
-  * @extends GeometryLayer
-  *
   * @param {string} id - The id of the layer Atmosphere.
   * @param {Object} [options] - options layer.
   * @param {number} [options.Kr] - `Kr` is the rayleigh scattering constant.

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).setFromExtent({
+        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;
+}