itowns 2.44.3-next.21 → 2.44.3-next.23

package/examples/layers/JSONLayers/GeoidMNT.json

@@ -4,7 +4,9 @@
     "updateStrategy": {
         "type": 0
     },
-    "zmin": -12000,
+    "clampValues": {
+        "min": -12000
+    },
     "source": {
         "url": "https://raw.githubusercontent.com/iTowns/iTowns2-sample-data/master/geoid/geoid/bil/%TILEMATRIX/geoid_%COL_%ROW.bil",
         "format": "image/x-bil;bits=32",

package/examples/source_file_geojson_3d.html

@@ -54,7 +54,6 @@
                     crs: 'EPSG:4326',
                     format: 'application/json',
                 }),
-                transparent: true,
                 opacity: 0.7,
                 zoom: { min: 10 },
                 style: {

package/examples/source_stream_wfs_raster.html

@@ -53,12 +53,6 @@
             itowns.Fetcher.json('./layers/JSONLayers/IGN_MNT_HIGHRES.json').then(addElevationLayerFromConfig);
             itowns.Fetcher.json('./layers/JSONLayers/WORLD_DTM.json').then(addElevationLayerFromConfig);
 
-            function isValidData(data) {
-                if(data.features[0].geometries.length < 1000) {
-                    return data;
-                }
-            }
-
             var wfsBuildingSource = new itowns.WFSSource({
                 url: 'https://data.geopf.fr/wfs/ows?',
                 version: '2.0.0',
@@ -102,7 +96,6 @@
                         width: 2.0,
                     },
                 },
-                isValidData: isValidData,
                 source: wfsBuildingSource,
                 zoom: { max: 20, min: 13 },
             });

package/lib/Converter/Feature2Mesh.js

@@ -4,7 +4,6 @@ import { FEATURE_TYPES } from "../Core/Feature.js";
 import ReferLayerProperties from "../Layer/ReferencingLayerProperties.js";
 import { deprecatedFeature2MeshOptions } from "../Core/Deprecated/Undeprecator.js";
 import Extent from "../Core/Geographic/Extent.js";
-import Crs from "../Core/Geographic/Crs.js";
 import OrientationUtils from "../Utils/OrientationUtils.js";
 import Coordinates from "../Core/Geographic/Coordinates.js";
 import Style, { StyleContext } from "../Core/Style.js";
@@ -54,7 +53,7 @@ class FeatureMesh extends THREE.Group {
       } else {
         // calculate the scale transformation to transform the feature.extent
         // to feature.extent.as(crs)
-        coord.crs = Crs.formatToEPSG(this.#originalCrs);
+        coord.crs = this.#originalCrs;
         // TODO: An extent here could be either a geographic extent (for
         // features from WFS) or a tiled extent (for features from MVT).
         // Unify both behavior.

package/lib/Converter/Feature2Texture.js

@@ -114,7 +114,9 @@ export default {
       coord.crs = extent.crs;
       c.width = sizeTexture;
       c.height = sizeTexture;
-      const ctx = c.getContext('2d');
+      const ctx = c.getContext('2d', {
+        willReadFrequently: true
+      });
       if (backgroundColor) {
         ctx.fillStyle = backgroundColor.getStyle();
         ctx.fillRect(0, 0, sizeTexture, sizeTexture);

package/lib/Converter/convertToTile.js

@@ -6,7 +6,7 @@
 import * as THREE from 'three';
 import TileMesh from "../Core/TileMesh.js";
 import LayeredMaterial from "../Renderer/LayeredMaterial.js";
-import newTileGeometry from "../Core/Prefab/TileBuilder.js";
+import { newTileGeometry } from "../Core/Prefab/TileBuilder.js";
 import ReferLayerProperties from "../Layer/ReferencingLayerProperties.js";
 import { geoidLayerIsVisible } from "../Layer/GeoidLayer.js";
 const dimensions = new THREE.Vector2();
@@ -42,14 +42,14 @@ export default {
     };
     return newTileGeometry(builder, paramsGeometry).then(result => {
       // build tile mesh
-      result.geometry._count++;
+      result.geometry.increaseRefCount();
       const crsCount = layer.tileMatrixSets.length;
       const material = new LayeredMaterial(layer.materialOptions, crsCount);
       ReferLayerProperties(material, layer);
       const tile = new TileMesh(result.geometry, material, layer, extent, level);
       if (parent && parent.isTileMesh) {
         // get parent extent transformation
-        const pTrans = builder.computeSharableExtent(parent.extent);
+        const pTrans = builder.computeShareableExtent(parent.extent);
         // place relative to his parent
         result.position.sub(pTrans.position).applyQuaternion(pTrans.quaternion.invert());
         result.quaternion.premultiply(pTrans.quaternion);

package/lib/Converter/textureConverter.js

@@ -1,7 +1,6 @@
 import * as THREE from 'three';
 import Feature2Texture from "./Feature2Texture.js";
 import Extent from "../Core/Geographic/Extent.js";
-import CRS from "../Core/Geographic/Crs.js";
 const extentTexture = new Extent('EPSG:4326', [0, 0, 0, 0]);
 const textureLayer = (texture, layer) => {
   texture.generateMipmaps = false;
@@ -20,7 +19,7 @@ export default {
     if (data.isFeatureCollection) {
       const backgroundLayer = layer.source.backgroundLayer;
       const backgroundColor = backgroundLayer && backgroundLayer.paint ? new THREE.Color(backgroundLayer.paint['background-color']) : undefined;
-      destinationTile.toExtent(CRS.formatToEPSG(layer.crs), extentTexture);
+      destinationTile.toExtent(layer.crs, extentTexture);
       texture = Feature2Texture.createTextureFromFeature(data, extentTexture, layer.subdivisionThreshold, layer.style, backgroundColor);
       texture.features = data;
       texture.extent = destinationTile;

package/lib/Core/Feature.js

@@ -1,7 +1,6 @@
 import * as THREE from 'three';
 import Extent from "./Geographic/Extent.js";
 import Coordinates from "./Geographic/Coordinates.js";
-import CRS from "./Geographic/Crs.js";
 import Style from "./Style.js";
 function defaultExtent(crs) {
   return new Extent(crs, Infinity, -Infinity, Infinity, -Infinity);
@@ -340,7 +339,7 @@ export class FeatureCollection extends THREE.Object3D {
   constructor(options) {
     super();
     this.isFeatureCollection = true;
-    this.crs = CRS.formatToEPSG(options.accurate || !options.source?.crs ? options.crs : options.source.crs);
+    this.crs = options.accurate || !options.source?.crs ? options.crs : options.source.crs;
     this.features = [];
     this.mergeFeatures = options.mergeFeatures === undefined ? true : options.mergeFeatures;
     this.size = options.structure == '3d' ? 3 : 2;

package/lib/Core/Geographic/Coordinates.js

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import proj4 from 'proj4';
-import CRS from "./Crs.js";
+import * as CRS from "./Crs.js";
 import Ellipsoid from "../Math/Ellipsoid.js";
 proj4.defs('EPSG:4978', '+proj=geocent +datum=WGS84 +units=m +no_defs');
 const ellipsoid = new Ellipsoid();

package/lib/Core/Geographic/Crs.js

@@ -1,5 +1,12 @@
 import proj4 from 'proj4';
 proj4.defs('EPSG:4978', '+proj=geocent +datum=WGS84 +units=m +no_defs');
+
+/**
+ * A projection as a CRS identifier string. This identifier references a
+ * projection definition previously defined with
+ * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections).
+ */
+
 function isString(s) {
   return typeof s === 'string' || s instanceof String;
 }
@@ -8,168 +15,131 @@ function mustBeString(crs) {
     throw new Error(`Crs parameter value must be a string: '${crs}'`);
   }
 }
-function isTms(crs) {
-  return isString(crs) && crs.startsWith('TMS');
-}
-function isEpsg(crs) {
-  return isString(crs) && crs.startsWith('EPSG');
-}
-function formatToTms(crs) {
-  mustBeString(crs);
-  return isTms(crs) ? crs : `TMS:${crs.match(/\d+/)[0]}`;
-}
-function formatToEPSG(crs) {
-  mustBeString(crs);
-  return isEpsg(crs) ? crs : `EPSG:${crs.match(/\d+/)[0]}`;
-}
-const UNIT = {
+
+/**
+ * System units supported for a coordinate system. See
+ * [proj](https://proj4.org/en/9.5/operations/conversions/unitconvert.html#angular-units).
+ * Note that only degree and meters units are supported for now.
+ */
+export const UNIT = {
+  /**
+   * Angular unit in degree.
+   */
   DEGREE: 1,
+  /**
+   * Distance unit in meter.
+   */
   METER: 2
 };
-function is4326(crs) {
+
+/**
+ * Checks that the CRS is EPSG:4326.
+ * @internal
+ *
+ * @param crs - The CRS to test.
+ */
+export function is4326(crs) {
   return crs === 'EPSG:4326';
 }
-function isGeocentric(crs) {
-  mustBeString(crs);
-  const projection = proj4.defs(crs);
-  return !projection ? false : projection.projName == 'geocent';
-}
-function _unitFromProj4Unit(projunit) {
-  if (projunit === 'degrees') {
+function unitFromProj4Unit(proj) {
+  if (proj.units === 'degrees') {
     return UNIT.DEGREE;
-  } else if (projunit === 'm') {
+  } else if (proj.units === 'm') {
+    return UNIT.METER;
+  } else if (proj.units === undefined && proj.to_meter === undefined) {
+    // See https://proj.org/en/9.4/usage/projections.html [17/10/2024]
+    // > The default unit for projected coordinates is the meter.
     return UNIT.METER;
   } else {
     return undefined;
   }
 }
-function toUnit(crs) {
+
+/**
+ * Returns the horizontal coordinates system units associated with this CRS.
+ *
+ * @param crs - The CRS to extract the unit from.
+ * @returns Either `UNIT.METER`, `UNIT.DEGREE` or `undefined`.
+ */
+export function getUnit(crs) {
   mustBeString(crs);
-  switch (crs) {
-    case 'EPSG:4326':
-      return UNIT.DEGREE;
-    case 'EPSG:4978':
-      return UNIT.METER;
-    default:
-      {
-        const p = proj4.defs(formatToEPSG(crs));
-        if (!p) {
-          return undefined;
-        }
-        return _unitFromProj4Unit(p.units);
-      }
+  const p = proj4.defs(crs);
+  if (!p) {
+    return undefined;
   }
+  return unitFromProj4Unit(p);
+}
+
+/**
+ * Asserts that the CRS is using metric units.
+ *
+ * @param crs - The CRS to check.
+ * @throws {@link Error} if the CRS is not valid.
+ */
+export function isMetricUnit(crs) {
+  return getUnit(crs) === UNIT.METER;
+}
+
+/**
+ * Asserts that the CRS is geographic.
+ *
+ * @param crs - The CRS to check.
+ * @throws {@link Error} if the CRS is not valid.
+ */
+export function isGeographic(crs) {
+  return getUnit(crs) === UNIT.DEGREE;
 }
-function toUnitWithError(crs) {
+
+/**
+ * Asserts that the CRS is geocentric.
+ *
+ * @param crs - The CRS to test.
+ * @returns false if the crs isn't defined.
+ */
+export function isGeocentric(crs) {
   mustBeString(crs);
-  const u = toUnit(crs);
-  if (u === undefined) {
-    throw new Error(`No unit found for crs: '${crs}'`);
+  const projection = proj4.defs(crs);
+  return !projection ? false : projection.projName == 'geocent';
+}
+
+/**
+ * Asserts that the CRS is valid, meaning it has been previously defined and
+ * includes an unit.
+ *
+ * @param crs - The CRS to test.
+ * @throws {@link Error} if the crs is not valid.
+ */
+export function isValid(crs) {
+  const proj = proj4.defs(crs);
+  if (!proj) {
+    throw new Error(`Undefined crs '${crs}'. Add it with proj4.defs('${crs}', string)`);
+  }
+  if (!unitFromProj4Unit(proj)) {
+    throw new Error(`No valid unit found for crs '${crs}', found ${proj.units}`);
   }
-  return u;
 }
 
 /**
- * This module provides basic methods to manipulate a CRS (as a string).
+ * Gives a reasonable epsilon for this CRS.
  *
- * @module CRS
+ * @param crs - The CRS to use.
+ * @returns 0.01 if the CRS is EPSG:4326, 0.001 otherwise.
  */
-export default {
-  /**
-   * Units that can be used for a CRS.
-   *
-   * @enum {number}
-   */
-  UNIT,
-  /**
-   * Assert that the CRS is valid one.
-   *
-   * @param {string} crs - The CRS to validate.
-   *
-   * @throws {Error} if the CRS is not valid.
-   */
-  isValid(crs) {
-    toUnitWithError(crs);
-  },
-  /**
-   * Assert that the CRS is geographic.
-   *
-   * @param {string} crs - The CRS to validate.
-   * @return {boolean}
-   * @throws {Error} if the CRS is not valid.
-   */
-  isGeographic(crs) {
-    return toUnitWithError(crs) == UNIT.DEGREE;
-  },
-  /**
-   * Assert that the CRS is using metric units.
-   *
-   * @param {string} crs - The CRS to validate.
-   * @return {boolean}
-   * @throws {Error} if the CRS is not valid.
-   */
-  isMetricUnit(crs) {
-    return toUnit(crs) == UNIT.METER;
-  },
-  /**
-   * Get the unit to use with the CRS.
-   *
-   * @param {string} crs - The CRS to get the unit from.
-   * @return {number} Either `UNIT.METER`, `UNIT.DEGREE` or `undefined`.
-   */
-  toUnit,
-  /**
-   * Is the CRS EPSG:4326 ?
-   *
-   * @param {string} crs - The CRS to test.
-   * @return {boolean}
-   */
-  is4326,
-  /**
-   * Is the CRS geocentric ?
-   * if crs isn't defined the method returns false.
-   *
-   * @param {string} crs - The CRS to test.
-   * @return {boolean}
-   */
-  isGeocentric,
-  /**
-   * Give a reasonnable epsilon to use with this CRS.
-   *
-   * @param {string} crs - The CRS to use.
-   * @return {number} 0.01 if the CRS is EPSG:4326, 0.001 otherwise.
-   */
-  reasonnableEpsilon(crs) {
-    if (is4326(crs)) {
-      return 0.01;
-    } else {
-      return 0.001;
-    }
-  },
-  /**
-   * format crs to European Petroleum Survey Group notation : EPSG:XXXX.
-   *
-   * @param      {string}  crs     The crs to format
-   * @return     {string}  formated crs
-   */
-  formatToEPSG,
-  /**
-   * format crs to tile matrix set notation : TMS:XXXX.
-   *
-   * @param      {string}  crs     The crs to format
-   * @return     {string}  formated crs
-   */
-  formatToTms,
-  isTms,
-  isEpsg,
-  tms_3857: 'TMS:3857',
-  tms_4326: 'TMS:4326',
-  /**
-   * Define a proj4 projection as a string and reference.
-   *
-   * @param {string}  code    code is the projection's SRS code (only used internally by the Proj4js library)
-   * @param {string}  proj4def is the Proj4 definition string for the projection to use
-   * @return {undefined}
-   */
-  defs: (code, proj4def) => proj4.defs(code, proj4def)
-};
+export function reasonableEpsilon(crs) {
+  if (is4326(crs)) {
+    return 0.01;
+  } else {
+    return 0.001;
+  }
+}
+
+/**
+ * Defines a proj4 projection as a named alias.
+ * This function is a specialized wrapper over the
+ * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections)
+ * function.
+ *
+ * @param code - Named alias of the currently defined projection.
+ * @param proj4def - Proj4 or WKT string of the defined projection.
+ */
+export const defs = (code, proj4def) => proj4.defs(code, proj4def);

package/lib/Core/Geographic/Extent.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";
 
 /**
  * Extent is a SIG-area (so 2D)
@@ -43,9 +43,6 @@ class Extent {
     if (CRS.isGeocentric(crs)) {
       throw new Error(`${crs} is a geocentric projection, it doesn't make sense with a geographical extent`);
     }
-    if (CRS.isTms(crs)) {
-      throw new Error(`${crs} is a tiled projection, use Tile instead`);
-    }
     this.isExtent = true;
     this.crs = crs;
     this.west = 0;
@@ -220,7 +217,7 @@ class Extent {
    */
   isInside(extent, epsilon) {
     extent.as(this.crs, _extent);
-    epsilon = epsilon == undefined ? CRS.reasonnableEpsilon(this.crs) : epsilon;
+    epsilon = epsilon ?? CRS.reasonableEpsilon(this.crs);
     return this.east - _extent.east <= epsilon && _extent.west - this.west <= epsilon && this.north - _extent.north <= epsilon && _extent.south - this.south <= epsilon;
   }
 

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/Prefab/Globe/Atmosphere.js

@@ -31,6 +31,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 +44,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

@@ -2,8 +2,7 @@ import * as THREE from 'three';
 import TiledGeometryLayer from "../../../Layer/TiledGeometryLayer.js";
 import { ellipsoidSizes } from "../../Math/Ellipsoid.js";
 import { globalExtentTMS, schemeTiles } from "../../Tile/TileGrid.js";
-import BuilderEllipsoidTile from "./BuilderEllipsoidTile.js";
-import CRS from "../../Geographic/Crs.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)
+    };
+  }
+}