itowns 2.37.0 → 2.38.2

package/lib/Renderer/c3DEngine.js

@@ -19,7 +19,7 @@ var _Capabilities = _interopRequireDefault(require("../Core/System/Capabilities"
 
 var _LayeredMaterial = require("./LayeredMaterial");
 
-var _WebGL = require("../ThreeExtended/WebGL");
+var _WebGL = _interopRequireDefault(require("../ThreeExtended/capabilities/WebGL"));
 
 var _Label2DRenderer = _interopRequireDefault(require("./Label2DRenderer"));
 
@@ -84,7 +84,10 @@ var c3DEngine = /*#__PURE__*/function () {
     this.renderView = function (view) {
       this.renderer.clear();
       this.renderer.render(view.scene, view.camera.camera3D);
-      this.label2dRenderer.render(view.scene, view.camera.camera3D);
+
+      if (view.tileLayer) {
+        this.label2dRenderer.render(view.tileLayer.object3d, view.camera.camera3D);
+      }
     }.bind(this);
 
     this.onWindowResize = function (w, h) {
@@ -116,10 +119,10 @@ var c3DEngine = /*#__PURE__*/function () {
     }
 
     if (!this.renderer) {
-      if (!_WebGL.WEBGL.isWebGLAvailable()) {
-        viewerDiv.appendChild(_WebGL.WEBGL.getErrorMessage(1));
-      } else if (!_WebGL.WEBGL.isWebGL2Available()) {
-        viewerDiv.appendChild(_WebGL.WEBGL.getErrorMessage(2));
+      if (!_WebGL["default"].isWebGLAvailable()) {
+        viewerDiv.appendChild(_WebGL["default"].getErrorMessage(1));
+      } else if (!_WebGL["default"].isWebGL2Available()) {
+        viewerDiv.appendChild(_WebGL["default"].getErrorMessage(2));
       }
 
       throw new Error('WebGL unsupported');

package/lib/Source/FileSource.js

@@ -107,7 +107,14 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
  *     .then(function _(geojson) {
  *         return itowns.GeoJsonParser.parse(geojson, {
  *             in: { crs: 'EPSG:4326' },
- *             out: { crs: view.tileLayer.extent.crs },
+ *             out: { crs: view.tileLayer.extent.crs,
+ *                      style: new itowns.Style({
+ *                          fill: {
+ *                              color: new itowns.THREE.Color(0xffcc00),
+ *                              extrusion_height: () => 5000,
+ *                      }),
+ *                  },
+ *             },
  *         });
  *     }).then(function _(features) {
  *         ariege.source = new itowns.FileSource({

package/lib/Source/VectorTilesSource.js

@@ -184,6 +184,11 @@ var VectorTilesSource = /*#__PURE__*/function (_TMSSource) {
       (0, _get2["default"])((0, _getPrototypeOf2["default"])(VectorTilesSource.prototype), "onLayerAdded", this).call(this, options);
 
       if (options.out.style) {
+        if (options.out.isFeatureGeometryLayer && options.out.accurate) {
+          console.warn('With VectorTilesSource and FeatureGeometryLayer, the accurate option is always false');
+          options.out.accurate = false;
+        }
+
         var keys = Object.keys(this.styles);
         keys.forEach(function (k) {
           _this2.styles[k].parent = options.out.style;

package/lib/Source/WFSSource.js

@@ -107,10 +107,16 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
  * });
  *
  * // Create the layer
- * const geometryLayer = new itowns.GeometryLayer('mesh_build', {
- *     update: itowns.FeatureProcessing.update,
- *     convert: itowns.Feature2Mesh.convert({ extrude: () => 50 }),
+ * const geometryLayer = new itowns.FeatureGeometryLayer('mesh_build', {
+ *     style: new itowns.Style({
+ *         fill: {
+ *             color: new itowns.THREE.Color(0xffcc00),
+ *             base_altitude: (p) => p.altitude,
+ *             extrusion_height: (p) => p.height,
+ *         }
+ *     },
  *     source: wfsSource,
+ *     zoom: { min: 14 },
  * });
  *
  * // Add the layer

package/lib/ThreeExtended/{WebGL.js → capabilities/WebGL.js}

@@ -5,18 +5,18 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.WEBGL = void 0;
+exports["default"] = void 0;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var WEBGL = /*#__PURE__*/function () {
-  function WEBGL() {
-    (0, _classCallCheck2["default"])(this, WEBGL);
+var WebGL = /*#__PURE__*/function () {
+  function WebGL() {
+    (0, _classCallCheck2["default"])(this, WebGL);
   }
 
-  (0, _createClass2["default"])(WEBGL, null, [{
+  (0, _createClass2["default"])(WebGL, null, [{
     key: "isWebGLAvailable",
     value: function isWebGLAvailable() {
       try {
@@ -80,7 +80,8 @@ var WEBGL = /*#__PURE__*/function () {
       return element;
     }
   }]);
-  return WEBGL;
+  return WebGL;
 }();
 
-exports.WEBGL = WEBGL;
+var _default = WebGL;
+exports["default"] = _default;

package/lib/ThreeExtended/loaders/GLTFLoader.js

@@ -1120,7 +1120,7 @@ var GLTFTextureTransformExtension = /*#__PURE__*/function () {
 /**
  * Specular-Glossiness Extension
  *
- * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness
  */
 
 /**
@@ -1144,7 +1144,7 @@ var GLTFMeshStandardSGMaterial = /*#__PURE__*/function (_MeshStandardMaterial) {
 
     var specularMapParsFragmentChunk = ['#ifdef USE_SPECULARMAP', '	uniform sampler2D specularMap;', '#endif'].join('\n');
     var glossinessMapParsFragmentChunk = ['#ifdef USE_GLOSSINESSMAP', '	uniform sampler2D glossinessMap;', '#endif'].join('\n');
-    var specularMapFragmentChunk = ['vec3 specularFactor = specular;', '#ifdef USE_SPECULARMAP', '	vec4 texelSpecular = texture2D( specularMap, vUv );', '	texelSpecular = sRGBToLinear( texelSpecular );', '	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture', '	specularFactor *= texelSpecular.rgb;', '#endif'].join('\n');
+    var specularMapFragmentChunk = ['vec3 specularFactor = specular;', '#ifdef USE_SPECULARMAP', '	vec4 texelSpecular = texture2D( specularMap, vUv );', '	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture', '	specularFactor *= texelSpecular.rgb;', '#endif'].join('\n');
     var glossinessMapFragmentChunk = ['float glossinessFactor = glossiness;', '#ifdef USE_GLOSSINESSMAP', '	vec4 texelGlossiness = texture2D( glossinessMap, vUv );', '	// reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture', '	glossinessFactor *= texelGlossiness.a;', '#endif'].join('\n');
     var lightPhysicalFragmentChunk = ['PhysicalMaterial material;', 'material.diffuseColor = diffuseColor.rgb * ( 1. - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );', 'vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );', 'float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );', 'material.roughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.', 'material.roughness += geometryRoughness;', 'material.roughness = min( material.roughness, 1.0 );', 'material.specularColor = specularFactor;'].join('\n');
     var uniforms = {
@@ -1727,7 +1727,7 @@ var GLTFParser = /*#__PURE__*/function () {
     this.nodeNamesUsed = {}; // Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the
     // expensive work of uploading a texture to the GPU off the main thread.
 
-    if (typeof createImageBitmap !== 'undefined' && /Firefox/.test(navigator.userAgent) === false) {
+    if (typeof createImageBitmap !== 'undefined' && /Firefox|^((?!chrome|android).)*safari/i.test(navigator.userAgent) === false) {
       this.textureLoader = new _three.ImageBitmapLoader(this.options.manager);
     } else {
       this.textureLoader = new _three.TextureLoader(this.options.manager);
@@ -2446,7 +2446,6 @@ var GLTFParser = /*#__PURE__*/function () {
 
         materialParams.depthWrite = false;
       } else {
-        materialParams.format = _three.RGBFormat;
         materialParams.transparent = false;
 
         if (alphaMode === ALPHA_MODES.MASK) {

package/lib/Utils/DEMUtils.js

@@ -352,10 +352,12 @@ function offsetInExtent(point, extent) {
 }
 
 function _readZ(layer, method, coord, nodes, cache) {
+  var _cache$tile;
+
   var pt = coord.as(layer.extent.crs, temp.coord1);
   var tileWithValidElevationTexture = null; // first check in cache
 
-  if (cache && cache.tile && cache.tile.material) {
+  if (cache !== null && cache !== void 0 && (_cache$tile = cache.tile) !== null && _cache$tile !== void 0 && _cache$tile.material) {
     tileWithValidElevationTexture = tileAt(pt, cache.tile);
   }
 

package/lib/Utils/gui/Main.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Minimap", {
+  enumerable: true,
+  get: function get() {
+    return _Minimap["default"];
+  }
+});
+Object.defineProperty(exports, "Navigation", {
+  enumerable: true,
+  get: function get() {
+    return _Navigation["default"];
+  }
+});
+Object.defineProperty(exports, "Scale", {
+  enumerable: true,
+  get: function get() {
+    return _Scale["default"];
+  }
+});
+Object.defineProperty(exports, "Searchbar", {
+  enumerable: true,
+  get: function get() {
+    return _Searchbar["default"];
+  }
+});
+
+var _Navigation = _interopRequireDefault(require("./Navigation"));
+
+var _Minimap = _interopRequireDefault(require("./Minimap"));
+
+var _Scale = _interopRequireDefault(require("./Scale"));
+
+var _Searchbar = _interopRequireDefault(require("./Searchbar"));

package/lib/Utils/gui/Minimap.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _Coordinates = _interopRequireDefault(require("../../Core/Geographic/Coordinates"));
+
+var _MainLoop = require("../../Core/MainLoop");
+
+var _PlanarView = _interopRequireDefault(require("../../Core/Prefab/PlanarView"));
+
+var _Camera = require("../../Renderer/Camera");
+
+var _Widget2 = _interopRequireDefault(require("./Widget"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var DEFAULT_OPTIONS = {
+  minScale: 1 / 500000,
+  maxScale: 1 / 5E8,
+  zoomRatio: 1 / 30,
+  width: 150,
+  height: 150,
+  position: 'bottom-left'
+};
+/**
+ * A widget for minimap
+ *
+ * To use it, you need to link the widgets' stylesheet to your html webpage. This stylesheet is included in
+ * [itowns bundles](https://github.com/iTowns/itowns/releases) if you downloaded them, or it can be found in
+ * `node_modules/itowns/examples/css` if you installed iTowns with npm. Otherwise, it can be found at
+ * [this link](https://raw.githubusercontent.com/iTowns/itowns/master/examples/css/widgets.css). See
+ * [this example](http://www.itowns-project.org/itowns/examples/#widgets_minimap) for more details.
+ *
+ * @extends Widget
+ *
+ * @property    {HTMLElement}   domElement      An html div containing the minimap.
+ * @property    {HTMLElement}   parentElement   The parent HTML container of `this.domElement`.
+ */
+
+var Minimap = /*#__PURE__*/function (_Widget) {
+  (0, _inherits2["default"])(Minimap, _Widget);
+
+  var _super = _createSuper(Minimap);
+
+  /**
+   * @param   {GlobeView}             view                                    The iTowns view the minimap should be
+                                                                              * linked to. Only {@link GlobeView} is
+                                                                              * supported at the moment.
+   * @param   {ColorLayer}            layer                                   The {@link ColorLayer} that should be
+                                                                              * displayed on the minimap.
+   * @param   {Object}                [options]                               The minimap optional configuration.
+   * @param   {HTMLElement}           [options.parentElement=view.domElement] The parent HTML container of the div
+                                                                              * which contains minimap widgets.
+   * @param   {number}                [options.size]                          The size of the minimap. It is a number
+                                                                              * that describes both width and height
+                                                                              * in pixels of the minimap.
+   * @param   {number}                [options.width=150]                     The width in pixels of the minimap.
+   * @param   {number}                [options.height=150]                    The height in pixels of the minimap.
+   * @param   {string}                [options.position='bottom-left']        Defines which position within the
+                                                                              * `parentElement` the minimap should be
+                                                                              * displayed to. Possible values are
+                                                                              * `top`, `bottom`, `left`, `right`,
+                                                                              * `top-left`, `top-right`, `bottom-left`
+                                                                              * and `bottom-right`. If the input value
+                                                                              * does not match one of these, it will
+                                                                              * be defaulted to `bottom-left`.
+   * @param   {Object}                [options.translate]                     An optional translation of the minimap.
+   * @param   {number}                [options.translate.x=0]                 The minimap translation along the page
+                                                                              * x-axis.
+   * @param   {number}                [options.translate.y=0]                 The minimap translation along the page
+                                                                              * y-axis.
+   * @param   {HTMLElement|string}    [options.cursor]                        An html element or an HTML string
+                                                                              * describing a cursor showing minimap
+                                                                              * view camera target position at the
+                                                                              * center of the minimap.
+   * @param   {number}                [options.minScale=1/2000]               The minimal scale the minimap can reach.
+   * @param   {number}                [options.maxScale=1/1_250_000]          The maximal scale the minimap can reach.
+   * @param   {number}                [options.zoomRatio=1/30]                The ratio between minimap camera zoom
+                                                                              * and view camera zoom.
+   * @param   {number}                [options.pitch=0.28]                    The screen pixel pitch, used to compute
+                                                                              * view and minimap scale.
+   */
+  function Minimap(view, layer) {
+    var _this;
+
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    (0, _classCallCheck2["default"])(this, Minimap);
+
+    // ---------- BUILD PROPERTIES ACCORDING TO DEFAULT OPTIONS AND OPTIONS PASSED IN PARAMETERS : ----------
+    if (!view.isGlobeView) {
+      throw new Error('\'Minimap\' plugin only supports \'GlobeView\'. Therefore, the \'view\' parameter must be a ' + '\'GlobeView\'.');
+    }
+
+    if (!layer.isColorLayer) {
+      throw new Error('\'layer\' parameter form \'Minimap\' constructor should be a \'ColorLayer\'.');
+    }
+
+    _this = _super.call(this, view, options, DEFAULT_OPTIONS);
+    _this.minScale = options.minScale || DEFAULT_OPTIONS.minScale;
+    _this.maxScale = options.maxScale || DEFAULT_OPTIONS.maxScale; // TODO : it could be interesting to be able to specify a method as zoomRatio parameter. This method could
+    //  return a zoom ratio from the scale of the minimap.
+
+    _this.zoomRatio = options.zoomRatio || DEFAULT_OPTIONS.zoomRatio; // ---------- this.domElement SETTINGS SPECIFIC TO MINIMAP : ----------
+
+    _this.domElement.id = 'widgets-minimap'; // Display a cursor at the center of the minimap, if requested.
+
+    if (options.cursor) {
+      // Wrap cursor domElement inside a div to center it in minimap.
+      var cursorWrapper = document.createElement('div');
+      cursorWrapper.id = 'cursor-wrapper';
+
+      _this.domElement.appendChild(cursorWrapper); // Add specified cursor to its wrapper.
+
+
+      if (typeof options.cursor === 'string') {
+        cursorWrapper.innerHTML = options.cursor;
+      } else if (options.cursor instanceof HTMLElement) {
+        cursorWrapper.appendChild(options.cursor);
+      }
+    } // ---------- CREATE A MINIMAP View AND DISPLAY DATA PASSED IN Layer PARAMETER : ----------
+
+
+    _this.view = new _PlanarView["default"](_this.domElement, layer.source.extent, {
+      camera: {
+        type: _Camera.CAMERA_TYPE.ORTHOGRAPHIC
+      },
+      placement: layer.source.extent,
+      // TODO : the default placement should be the view extent for ortho camera
+      noControls: true,
+      maxSubdivisionLevel: view.tileLayer.maxSubdivisionLevel,
+      disableFocusOnStart: true
+    });
+
+    _this.view.addLayer(layer); // TODO : should this promise be returned by constructor so that user can use it ?
+    // Prevent the minimap domElement to get focus when clicked, and prevent click event to be propagated to the
+    // main view controls.
+
+
+    _this.domElement.addEventListener('pointerdown', function (event) {
+      event.preventDefault();
+    }); // Store minimap view camera3D in constant for code convenience.
+
+
+    var camera3D = _this.view.camera.camera3D; // ---------- UPDATE MINIMAP VIEW WHEN UPDATING THE MAIN VIEW : ----------
+    // The minimal and maximal value the minimap camera3D zoom can reach in order to stay in the scale limits.
+
+    var initialScale = _this.view.getScale(options.pitch);
+
+    var minZoom = camera3D.zoom * _this.maxScale / initialScale;
+    var maxZoom = camera3D.zoom * _this.minScale / initialScale; // Coordinates used to transform position vectors from the main view CRS to the minimap view CRS.
+
+    var mainViewCoordinates = new _Coordinates["default"](view.referenceCrs);
+    var viewCoordinates = new _Coordinates["default"](_this.view.referenceCrs);
+    var targetPosition = view.controls.getCameraTargetPosition();
+    view.addFrameRequester(_MainLoop.MAIN_LOOP_EVENTS.AFTER_RENDER, function () {
+      // Update minimap camera zoom
+      var distance = view.camera.camera3D.position.distanceTo(targetPosition);
+      var scale = view.getScaleFromDistance(options.pitch, distance);
+      camera3D.zoom = _this.zoomRatio * maxZoom * scale / _this.minScale;
+      camera3D.zoom = Math.min(Math.max(camera3D.zoom, minZoom), maxZoom);
+      camera3D.updateProjectionMatrix(); // Update minimap camera position.
+
+      mainViewCoordinates.setFromVector3(view.controls.getCameraTargetPosition());
+      mainViewCoordinates.as(_this.view.referenceCrs, viewCoordinates);
+      camera3D.position.x = viewCoordinates.x;
+      camera3D.position.y = viewCoordinates.y;
+      camera3D.updateMatrixWorld(true);
+
+      _this.view.notifyChange(camera3D);
+    });
+    return _this;
+  }
+
+  return (0, _createClass2["default"])(Minimap);
+}(_Widget2["default"]);
+
+var _default = Minimap;
+exports["default"] = _default;