itowns 2.44.3-next.8 → 2.45.0

package/lib/Core/System/Capabilities.js

@@ -1,63 +0,0 @@
-/* babel-plugin-inline-import '../../Renderer/Shader/SampleTestFS.glsl' */
-const SampleTestFS = "uniform sampler2D uni[SAMPLE];\nvoid main() {\n    gl_FragColor += texture2D(uni[SAMPLE-1], vec2(0));\n}";
-/* babel-plugin-inline-import '../../Renderer/Shader/SampleTestVS.glsl' */
-const SampleTestVS = "void main() {\n    gl_Position = vec4( 0.0, 0.0, 0.0, 1.0 );\n}"; // default values
-let logDepthBufferSupported = false;
-let maxTexturesUnits = 8;
-let maxTextureSize = 4096;
-function _WebGLShader(renderer, type, string) {
-  const gl = renderer.getContext();
-  const shader = gl.createShader(type);
-  gl.shaderSource(shader, string);
-  gl.compileShader(shader);
-  return shader;
-}
-function isFirefox() {
-  return navigator && navigator.userAgent && navigator.userAgent.toLowerCase().includes('firefox');
-}
-export default {
-  isLogDepthBufferSupported() {
-    return logDepthBufferSupported;
-  },
-  isFirefox,
-  getMaxTextureUnitsCount() {
-    return maxTexturesUnits;
-  },
-  getMaxTextureSize() {
-    return maxTextureSize;
-  },
-  updateCapabilities(renderer) {
-    const gl = renderer.getContext();
-    maxTexturesUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
-    maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-    const program = gl.createProgram();
-    const glVertexShader = _WebGLShader(renderer, gl.VERTEX_SHADER, SampleTestVS);
-    let fragmentShader = `#define SAMPLE ${maxTexturesUnits}\n`;
-    fragmentShader += SampleTestFS;
-    const glFragmentShader = _WebGLShader(renderer, gl.FRAGMENT_SHADER, fragmentShader);
-    gl.attachShader(program, glVertexShader);
-    gl.attachShader(program, glFragmentShader);
-    gl.linkProgram(program);
-    if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {
-      if (maxTexturesUnits > 16) {
-        const info = gl.getProgramInfoLog(program);
-        // eslint-disable-next-line no-console
-        console.warn(`${info}: using a maximum of 16 texture units instead of the reported value (${maxTexturesUnits})`);
-        if (isFirefox()) {
-          // eslint-disable-next-line no-console
-          console.warn(`It can come from a Mesa/Firefox bug;
-                        the shader compiles to an error when using more than 16 sampler uniforms,
-                        see https://bugzilla.mozilla.org/show_bug.cgi?id=777028`);
-        }
-        maxTexturesUnits = 16;
-      } else {
-        throw new Error(`The GPU capabilities could not be determined accurately.
-                    Impossible to link a shader with the Maximum texture units ${maxTexturesUnits}`);
-      }
-    }
-    gl.deleteProgram(program);
-    gl.deleteShader(glVertexShader);
-    gl.deleteShader(glFragmentShader);
-    logDepthBufferSupported = renderer.capabilities.logarithmicDepthBuffer;
-  }
-};

package/lib/Core/Tile/Tile.js

@@ -1,219 +0,0 @@
-import * as THREE from 'three';
-import Coordinates from "../Geographic/Coordinates.js";
-import CRS from "../Geographic/Crs.js";
-import Extent from "../Geographic/Extent.js";
-import { getInfoTms, getCountTiles } from "./TileGrid.js";
-const _tmsCoord = new THREE.Vector2();
-const _dimensionTile = new THREE.Vector2();
-const r = {
-  row: 0,
-  col: 0,
-  invDiff: 0
-};
-function _rowColfromParent(/** @type {Tile} */tile, /** @type {number} */zoom) {
-  const diffLevel = tile.zoom - zoom;
-  const diff = 2 ** diffLevel;
-  r.invDiff = 1 / diff;
-  r.row = (tile.row - tile.row % diff) * r.invDiff;
-  r.col = (tile.col - tile.col % diff) * r.invDiff;
-  return r;
-}
-const _extent = new Extent('EPSG:4326', [0, 0, 0, 0]);
-const _extent2 = new Extent('EPSG:4326', [0, 0, 0, 0]);
-const _c = new Coordinates('EPSG:4326', 0, 0);
-class Tile {
-  /**
-   * Tile is a geographical bounding rectangle defined by zoom, row and column.
-   *
-   * @param {String} crs projection of limit values.
-   * @param {number} [zoom=0] zoom value
-   * @param {number} [row=0] row value
-   * @param {number} [col=0] column value
-   */
-  constructor(crs) {
-    let zoom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let row = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    let col = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-    this.isTile = true;
-    this.crs = crs;
-    this.zoom = zoom;
-    this.row = row;
-    this.col = col;
-  }
-
-  /**
-   * Clone this tile
-   * @return {Tile} cloned tile
-   */
-  clone() {
-    return new Tile(this.crs, this.zoom, this.row, this.col);
-  }
-
-  /**
-   * Convert tile to the specified extent.
-   * @param {string} crs the projection of destination.
-   * @param {Extent} target copy the destination to target.
-   * @return {Extent}
-   */
-  toExtent(crs, target) {
-    CRS.isValid(crs);
-    target = target || new Extent('EPSG:4326', [0, 0, 0, 0]);
-    const {
-      epsg,
-      globalExtent,
-      globalDimension
-    } = getInfoTms(this.crs);
-    const countTiles = getCountTiles(this.crs, this.zoom);
-    _dimensionTile.set(1, 1).divide(countTiles).multiply(globalDimension);
-    target.west = globalExtent.west + (globalDimension.x - _dimensionTile.x * (countTiles.x - this.col));
-    target.east = target.west + _dimensionTile.x;
-    target.south = globalExtent.south + _dimensionTile.y * (countTiles.y - this.row - 1);
-    target.north = target.south + _dimensionTile.y;
-    target.crs = epsg;
-    target.zoom = this.zoom;
-    return crs == epsg ? target : target.as(crs, target);
-  }
-
-  /**
-   * Return true if `tile` is inside this tile.
-   *
-   * @param {Tile} tile the tile to check
-   *
-   * @return {boolean}
-   */
-  isInside(tile) {
-    if (this.zoom == tile.zoom) {
-      return this.row == tile.row && this.col == tile.col;
-    } else if (this.zoom < tile.zoom) {
-      return false;
-    } else {
-      _rowColfromParent(this, tile.zoom);
-      return r.row == tile.row && r.col == tile.col;
-    }
-  }
-
-  /**
-   * Return the translation and scale to transform this tile to input tile.
-   *
-   * @param {Tile} tile input tile
-   * @param {THREE.Vector4} target copy the result to target.
-   * @return {THREE.Vector4} {x: translation on west-east, y: translation on south-north, z: scale on west-east, w: scale on south-north}
-   */
-  offsetToParent(tile) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector4();
-    if (this.crs != tile.crs) {
-      throw new Error('unsupported mix');
-    }
-    _rowColfromParent(this, tile.zoom);
-    return target.set(this.col * r.invDiff - r.col, this.row * r.invDiff - r.row, r.invDiff, r.invDiff);
-  }
-
-  /**
-   * Return parent tile with input level
-   *
-   * @param {number} levelParent level of parent.
-   * @return {Tile}
-   */
-  tiledExtentParent(levelParent) {
-    if (levelParent && levelParent < this.zoom) {
-      _rowColfromParent(this, levelParent);
-      return new Tile(this.crs, levelParent, r.row, r.col);
-    } else {
-      return this;
-    }
-  }
-
-  /**
-   * Set zoom, row and column values
-   *
-   * @param {number} [zoom=0] zoom value
-   * @param {number} [row=0] row value
-   * @param {number} [col=0] column value
-   *
-   * @return {Tile}
-   */
-  set() {
-    let zoom = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    let row = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let col = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    this.zoom = zoom;
-    this.row = row;
-    this.col = col;
-    return this;
-  }
-
-  /**
-   * Copy to this tile to input tile.
-   * @param {Tile} tile
-   * @return {Tile} copied extent
-   */
-  copy(tile) {
-    this.crs = tile.crs;
-    return this.set(tile.zoom, tile.row, tile.col);
-  }
-
-  /**
-   * Return values of tile in string, separated by the separator input.
-   * @param {string} separator
-   * @return {string}
-   */
-  toString() {
-    let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    return `${this.zoom}${separator}${this.row}${separator}${this.col}`;
-  }
-}
-
-/**
- * @param {Extent} e
- * @param {string} tms
- * @returns {Tile[]}
- */
-export function tiledCovering(e, tms) {
-  if (e.crs == 'EPSG:4326' && tms == CRS.tms_3857) {
-    const WMTS_PM = [];
-    const extent = _extent.copy(e).as(CRS.formatToEPSG(tms), _extent2);
-    const {
-      globalExtent,
-      globalDimension,
-      sTs
-    } = getInfoTms(CRS.formatToEPSG(tms));
-    extent.clampByExtent(globalExtent);
-    extent.planarDimensions(_dimensionTile);
-    const zoom = e.zoom + 1 || Math.floor(Math.log2(Math.round(globalDimension.x / (_dimensionTile.x * sTs.x))));
-    const countTiles = getCountTiles(tms, zoom);
-    const center = extent.center(_c);
-    _tmsCoord.x = center.x - globalExtent.west;
-    _tmsCoord.y = globalExtent.north - extent.north;
-    _tmsCoord.divide(globalDimension).multiply(countTiles).floor();
-
-    // ]N; N+1] => N
-    const maxRow = Math.ceil((globalExtent.north - extent.south) / globalDimension.x * countTiles.y) - 1;
-    for (let r = maxRow; r >= _tmsCoord.y; r--) {
-      WMTS_PM.push(new Tile(tms, zoom, r, _tmsCoord.x));
-    }
-    return WMTS_PM;
-  } else {
-    const target = new Tile(tms, 0, 0, 0);
-    const {
-      globalExtent,
-      globalDimension,
-      sTs,
-      isInverted
-    } = getInfoTms(e.crs);
-    const center = e.center(_c);
-    e.planarDimensions(_dimensionTile);
-    // Each level has 2^n * 2^n tiles...
-    // ... so we count how many tiles of the same width as tile we can fit in the layer
-    // ... 2^zoom = tilecount => zoom = log2(tilecount)
-    const zoom = Math.floor(Math.log2(Math.round(globalDimension.x / (_dimensionTile.x * sTs.x))));
-    const countTiles = getCountTiles(tms, zoom);
-
-    // Now that we have computed zoom, we can deduce x and y (or row / column)
-    _tmsCoord.x = center.x - globalExtent.west;
-    _tmsCoord.y = isInverted ? globalExtent.north - center.y : center.y - globalExtent.south;
-    _tmsCoord.divide(globalDimension).multiply(countTiles).floor();
-    target.set(zoom, _tmsCoord.y, _tmsCoord.x);
-    return [target];
-  }
-}
-export default Tile;

package/lib/Core/Tile/TileGrid.js

@@ -1,46 +0,0 @@
-import * as THREE from 'three';
-import CRS from "../Geographic/Crs.js";
-import Extent from "../Geographic/Extent.js";
-const _countTiles = new THREE.Vector2();
-const _dim = new THREE.Vector2();
-export const globalExtentTMS = new Map();
-export const schemeTiles = new Map();
-const extent4326 = new Extent('EPSG:4326', -180, 180, -90, 90);
-globalExtentTMS.set('EPSG:4326', extent4326);
-
-// Compute global extent of TMS in EPSG:3857
-// It's square whose a side is between -180° to 180°.
-// So, west extent, it's 180 convert in EPSG:3857
-const extent3857 = extent4326.as('EPSG:3857');
-extent3857.clampSouthNorth(extent3857.west, extent3857.east);
-globalExtentTMS.set('EPSG:3857', extent3857);
-schemeTiles.set('default', new THREE.Vector2(1, 1));
-schemeTiles.set(CRS.tms_3857, schemeTiles.get('default'));
-schemeTiles.set(CRS.tms_4326, new THREE.Vector2(2, 1));
-export function getInfoTms(/** @type {string} */crs) {
-  const epsg = CRS.formatToEPSG(crs);
-  const globalExtent = globalExtentTMS.get(epsg);
-  const globalDimension = globalExtent.planarDimensions(_dim);
-  const tms = CRS.formatToTms(crs);
-  const sTs = schemeTiles.get(tms) || schemeTiles.get('default');
-  // The isInverted parameter is to be set to the correct value, true or false
-  // (default being false) if the computation of the coordinates needs to be
-  // inverted to match the same scheme as OSM, Google Maps or other system.
-  // See link below for more information
-  // https://alastaira.wordpress.com/2011/07/06/converting-tms-tile-coordinates-to-googlebingosm-tile-coordinates/
-  // in crs includes ':NI' => tms isn't inverted (NOT INVERTED)
-  const isInverted = !tms.includes(':NI');
-  return {
-    epsg,
-    globalExtent,
-    globalDimension,
-    sTs,
-    isInverted
-  };
-}
-export function getCountTiles(/** @type {string} */crs, /** @type {number} */zoom) {
-  const sTs = schemeTiles.get(CRS.formatToTms(crs)) || schemeTiles.get('default');
-  const count = 2 ** zoom;
-  _countTiles.set(count, count).multiply(sTs);
-  return _countTiles;
-}

package/lib/Core/TileGeometry.js

@@ -1,40 +0,0 @@
-import * as THREE from 'three';
-import computeBuffers, { getBufferIndexSize } from "./Prefab/computeBufferTileGeometry.js";
-function defaultBuffers(params) {
-  params.buildIndexAndUv_0 = true;
-  params.center = params.builder.center(params.extent).clone();
-  const buffers = computeBuffers(params);
-  buffers.index = new THREE.BufferAttribute(buffers.index, 1);
-  buffers.uvs[0] = new THREE.BufferAttribute(buffers.uvs[0], 2);
-  buffers.position = new THREE.BufferAttribute(buffers.position, 3);
-  buffers.normal = new THREE.BufferAttribute(buffers.normal, 3);
-  for (let i = 1; i < params.builder.uvCount; i++) {
-    buffers.uvs[1] = new THREE.BufferAttribute(buffers.uvs[1], 1);
-  }
-  return buffers;
-}
-class TileGeometry extends THREE.BufferGeometry {
-  constructor(params) {
-    let buffers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultBuffers(params);
-    super();
-    this.center = params.center;
-    this.extent = params.extent;
-    this.segments = params.segments;
-    this.setIndex(buffers.index);
-    this.setAttribute('position', buffers.position);
-    this.setAttribute('normal', buffers.normal);
-    this.setAttribute('uv', buffers.uvs[0]);
-    for (let i = 1; i < buffers.uvs.length; i++) {
-      this.setAttribute(`uv_${i}`, buffers.uvs[i]);
-    }
-    this.computeBoundingBox();
-    this.OBB = {};
-    if (params.hideSkirt) {
-      this.hideSkirt = params.hideSkirt;
-    }
-  }
-  set hideSkirt(value) {
-    this.setDrawRange(0, getBufferIndexSize(this.segments, value));
-  }
-}
-export default TileGeometry;

package/lib/Core/TileMesh.js

@@ -1,109 +0,0 @@
-import * as THREE from 'three';
-import CRS from "./Geographic/Crs.js";
-import { geoidLayerIsVisible } from "../Layer/GeoidLayer.js";
-import { tiledCovering } from "./Tile/Tile.js";
-
-/**
- * A TileMesh is a THREE.Mesh with a geometricError and an OBB
- * The objectId property of the material is the with the id of the TileMesh
- * @param {TileGeometry} geometry - the tile geometry
- * @param {THREE.Material} material - a THREE.Material compatible with THREE.Mesh
- * @param {Layer} layer - the layer the tile is added to
- * @param {Extent} extent - the tile extent
- * @param {?number} level - the tile level (default = 0)
- */
-class TileMesh extends THREE.Mesh {
-  #_tms = (() => new Map())();
-  #visible = true;
-  constructor(geometry, material, layer, extent) {
-    let level = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
-    super(geometry, material);
-    if (!extent) {
-      throw new Error('extent is mandatory to build a TileMesh');
-    }
-    this.layer = layer;
-    this.extent = extent;
-    this.extent.zoom = level;
-    this.level = level;
-    this.material.objectId = this.id;
-    this.obb = this.geometry.OBB.clone();
-    this.boundingSphere = new THREE.Sphere();
-    this.obb.box3D.getBoundingSphere(this.boundingSphere);
-    for (const tms of layer.tileMatrixSets) {
-      this.#_tms.set(tms, tiledCovering(this.extent, tms));
-    }
-    this.frustumCulled = false;
-    this.matrixAutoUpdate = false;
-    this.rotationAutoUpdate = false;
-    this.layerUpdateState = {};
-    this.isTileMesh = true;
-    this.geoidHeight = 0;
-    this.link = {};
-    Object.defineProperty(this, 'visible', {
-      get() {
-        return this.#visible;
-      },
-      set(v) {
-        if (this.#visible != v) {
-          this.#visible = v;
-          this.dispatchEvent({
-            type: v ? 'shown' : 'hidden'
-          });
-        }
-      }
-    });
-  }
-  /**
-   * If specified, update the min and max elevation of the OBB
-   * and updates accordingly the bounding sphere and the geometric error
-   *
-   * @param {Object}  elevation
-   * @param {number}  [elevation.min]
-   * @param {number}  [elevation.max]
-   * @param {number}  [elevation.scale]
-   */
-  setBBoxZ(elevation) {
-    elevation.geoidHeight = geoidLayerIsVisible(this.layer) ? this.geoidHeight : 0;
-    this.obb.updateZ(elevation);
-    if (this.horizonCullingPointElevationScaled) {
-      this.horizonCullingPointElevationScaled.setLength(this.obb.z.delta + this.horizonCullingPoint.length());
-    }
-    this.obb.box3D.getBoundingSphere(this.boundingSphere);
-  }
-  getExtentsByProjection(crs) {
-    return this.#_tms.get(CRS.formatToTms(crs));
-  }
-
-  /**
-   * Search for a common ancestor between this tile and another one. It goes
-   * through parents on each side until one is found.
-   *
-   * @param {TileMesh} tile
-   *
-   * @return {TileMesh} the resulting common ancestor
-   */
-  findCommonAncestor(tile) {
-    if (!tile) {
-      return undefined;
-    }
-    if (tile.level == this.level) {
-      if (tile.id == this.id) {
-        return tile;
-      } else if (tile.level != 0) {
-        return this.parent.findCommonAncestor(tile.parent);
-      } else {
-        return undefined;
-      }
-    } else if (tile.level < this.level) {
-      return this.parent.findCommonAncestor(tile);
-    } else {
-      return this.findCommonAncestor(tile.parent);
-    }
-  }
-  onBeforeRender() {
-    if (this.material.layersNeedUpdate) {
-      this.material.updateLayersUniforms();
-    }
-  }
-}
-export default TileMesh;