itowns 2.34.0 → 2.36.2

package/lib/Controls/PlanarControls.js

@@ -527,14 +527,7 @@ var PlanarControls = /*#__PURE__*/function (_THREE$EventDispatche) {
   }, {
     key: "initiateZoom",
     value: function initiateZoom(event) {
-      var delta; // mousewheel delta
-
-      if (undefined !== event.wheelDelta) {
-        delta = event.wheelDelta;
-      } else if (undefined !== event.detail) {
-        delta = -event.detail;
-      }
-
+      var delta = -event.deltaY;
       pointUnderCursor.copy(this.getWorldPointAtScreenXY(mousePosition));
       var newPos = new THREE.Vector3();
 
@@ -863,7 +856,7 @@ var PlanarControls = /*#__PURE__*/function (_THREE$EventDispatche) {
       this.view.domElement.addEventListener('mouseup', this._handlerOnMouseUp, false);
       this.view.domElement.addEventListener('mouseleave', this._handlerOnMouseUp, false);
       this.view.domElement.addEventListener('mousemove', this._handlerOnMouseMove, false);
-      this.view.domElement.addEventListener('mousewheel', this._handlerOnMouseWheel, false); // focus policy
+      this.view.domElement.addEventListener('wheel', this._handlerOnMouseWheel, false); // focus policy
 
       if (this.focusOnMouseOver) {
         this.view.domElement.addEventListener('mouseover', this._handlerFocusOnMouseOver, false);
@@ -875,9 +868,7 @@ var PlanarControls = /*#__PURE__*/function (_THREE$EventDispatche) {
       // this allows to use right-click for input without the menu appearing
 
 
-      this.view.domElement.addEventListener('contextmenu', this._handlerContextMenu, false); // for firefox
-
-      this.view.domElement.addEventListener('MozMousePixelScroll', this._handlerOnMouseWheel, false);
+      this.view.domElement.addEventListener('contextmenu', this._handlerContextMenu, false);
     }
     /**
      * Removes all the input listeners (deactivate the controls).
@@ -893,12 +884,10 @@ var PlanarControls = /*#__PURE__*/function (_THREE$EventDispatche) {
       this.view.domElement.removeEventListener('mouseup', this._handlerOnMouseUp, false);
       this.view.domElement.removeEventListener('mouseleave', this._handlerOnMouseUp, false);
       this.view.domElement.removeEventListener('mousemove', this._handlerOnMouseMove, false);
-      this.view.domElement.removeEventListener('mousewheel', this._handlerOnMouseWheel, false);
+      this.view.domElement.removeEventListener('wheel', this._handlerOnMouseWheel, false);
       this.view.domElement.removeEventListener('mouseover', this._handlerFocusOnMouseOver, false);
       this.view.domElement.removeEventListener('click', this._handlerFocusOnMouseClick, false);
-      this.view.domElement.removeEventListener('contextmenu', this._handlerContextMenu, false); // for firefox
-
-      this.view.domElement.removeEventListener('MozMousePixelScroll', this._handlerOnMouseWheel, false);
+      this.view.domElement.removeEventListener('contextmenu', this._handlerContextMenu, false);
     }
     /**
      * Update the cursor image according to the control state.

package/lib/Controls/StateControl.js

@@ -13,6 +13,8 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
@@ -38,19 +40,99 @@ var CONTROL_KEYS = {
   SHIFT: 16,
   CTRL: 17,
   S: 83
-};
-
-function stateToTrigger(state) {
-  if (!state) {
-    return undefined;
-  } else if (state.mouseButton === THREE.MOUSE.LEFT && state["double"]) {
-    return 'dblclick';
-  } else if (state.mouseButton === THREE.MOUSE.RIGHT && state["double"]) {
-    return 'dblclick-right';
-  } else if (state.keyboard) {
-    return 'keydown';
+}; // TODO : a class should be made for `State`, and the properties marked with `_` prefix should be made private
+
+var DEFAULT_STATES = {
+  ORBIT: {
+    enable: true,
+    mouseButton: THREE.MOUSE.LEFT,
+    "double": false,
+    keyboard: CONTROL_KEYS.CTRL,
+    finger: 2,
+    _event: 'rotate'
+  },
+  MOVE_GLOBE: {
+    enable: true,
+    mouseButton: THREE.MOUSE.LEFT,
+    "double": false,
+    finger: 1,
+    _event: 'drag'
+  },
+  DOLLY: {
+    enable: true,
+    mouseButton: THREE.MOUSE.MIDDLE,
+    "double": false,
+    finger: 2,
+    _event: 'dolly'
+  },
+  PAN: {
+    enable: true,
+    mouseButton: THREE.MOUSE.RIGHT,
+    "double": false,
+    finger: 3,
+    _event: 'pan'
+  },
+  PANORAMIC: {
+    enable: true,
+    mouseButton: THREE.MOUSE.LEFT,
+    "double": false,
+    keyboard: CONTROL_KEYS.SHIFT,
+    _event: 'panoramic'
+  },
+  TRAVEL_IN: {
+    enable: true,
+    mouseButton: THREE.MOUSE.LEFT,
+    "double": true,
+    _event: 'travel_in',
+    _trigger: true,
+    _direction: 'in'
+  },
+  TRAVEL_OUT: {
+    enable: false,
+    "double": false,
+    _event: 'travel_out',
+    _trigger: true,
+    _direction: 'out'
+  },
+  ZOOM: {
+    enable: true,
+    _event: 'zoom',
+    _trigger: true
+  },
+  PAN_UP: {
+    enable: true,
+    keyboard: CONTROL_KEYS.UP,
+    "double": false,
+    _event: 'pan',
+    _trigger: true,
+    _direction: 'up'
+  },
+  PAN_BOTTOM: {
+    enable: true,
+    keyboard: CONTROL_KEYS.BOTTOM,
+    "double": false,
+    _event: 'pan',
+    _trigger: true,
+    _direction: 'bottom'
+  },
+  PAN_LEFT: {
+    enable: true,
+    keyboard: CONTROL_KEYS.LEFT,
+    "double": false,
+    _event: 'pan',
+    _trigger: true,
+    _direction: 'left'
+  },
+  PAN_RIGHT: {
+    enable: true,
+    keyboard: CONTROL_KEYS.RIGHT,
+    "double": false,
+    _event: 'pan',
+    _trigger: true,
+    _direction: 'right'
   }
-}
+};
+var viewCoords = new THREE.Vector2();
 /**
  * @typedef {Object} StateControl~State
  * @property {boolean} enable=true Indicate whether the state is enabled or not.
@@ -80,18 +162,20 @@ function stateToTrigger(state) {
  * @property {State}    PANORAMIC   {@link State} describing camera panoramic movement : the camera is rotated around
                                     * its own position.
  * @property {State}    TRAVEL_IN   {@link State} describing camera travel in movement : the camera is zoomed in toward
-                                    * a given position. The choice of the target position is made in the Controls
-                                    * associated to this StateControl.
-                                    * This state can only be associated to double click on mouse buttons (left or right)
-                                    * or a keyboard key.
+                                    * a given position. The target position depends on the key/mouse binding of this
+                                    * state. If bound to a mouse button, the target position is the mouse position.
+                                    * Otherwise, it is the center of the screen.
  * @property {State}    TRAVEL_OUT  {@link State} describing camera travel out movement : the camera is zoomed out from
-                                    * a given position. The choice of the target position is made in the Controls
-                                    * associated to this StateControl.
-                                    * This state can only be associated to double click on mouse buttons (left or right)
-                                    * or a keyboard key. It is disabled by default.
+                                    * a given position. The target position depends on the key/mouse binding of this
+                                    * state. If bound to a mouse button, the target position is the mouse position.
+                                    * Otherwise, it is the center of the screen. It is disabled by default.
+ * @property {State}    ZOOM        {@link State} describing camera zoom in and out movement.
+ * @property {boolean}  enable      Defines whether all input will be communicated to the associated `Controls` or not.
+                                    * Default is true.
+ * @property {boolean}  enableKeys  Defines whether keyboard input will be communicated to the associated `Controls` or
+                                    * not. Default is true.
  */
 
-
 var StateControl = /*#__PURE__*/function (_THREE$EventDispatche) {
   (0, _inherits2["default"])(StateControl, _THREE$EventDispatche);
 
@@ -105,48 +189,120 @@ var StateControl = /*#__PURE__*/function (_THREE$EventDispatche) {
     _this = _super.call(this);
     _this._view = view;
     _this._domElement = view.domElement;
-    _this.NONE = {};
+    var enabled = true;
+    Object.defineProperty((0, _assertThisInitialized2["default"])(_this), 'enabled', {
+      get: function get() {
+        return enabled;
+      },
+      set: function set(value) {
+        if (!value) {
+          _this.onKeyUp();
+
+          _this.onPointerUp();
+        }
 
-    _this._handleTravelInEvent = function (event) {
-      if (_this.TRAVEL_IN === _this.inputToState(event.button, event.keyCode, _this.TRAVEL_IN["double"])) {
-        _this.dispatchEvent({
-          type: 'travel_in',
-          viewCoords: _this._view.eventToViewCoords(event)
-        });
+        enabled = value;
       }
-    };
+    }); // Set to true to disable use of the keys
+
+    var enableKeys = true;
+    Object.defineProperty((0, _assertThisInitialized2["default"])(_this), 'enableKeys', {
+      get: function get() {
+        return enableKeys;
+      },
+      set: function set(value) {
+        if (!value) {
+          _this.onKeyUp();
+        }
 
-    _this._handleTravelOutEvent = function (event) {
-      if (_this.TRAVEL_OUT === _this.inputToState(event.button, event.keyCode, _this.TRAVEL_OUT["double"])) {
-        _this.dispatchEvent({
-          type: 'travel_out',
-          viewCoords: _this._view.eventToViewCoords(event)
-        });
+        enableKeys = value;
       }
+    });
+    _this.NONE = {};
+    var currentState = _this.NONE;
+    Object.defineProperty((0, _assertThisInitialized2["default"])(_this), 'currentState', {
+      get: function get() {
+        return currentState;
+      },
+      set: function set(newState) {
+        if (currentState !== newState) {
+          var previous = currentState;
+          currentState = newState;
+
+          _this.dispatchEvent({
+            type: 'state-changed',
+            viewCoords: viewCoords,
+            previous: previous
+          });
+        }
+      }
+    }); // TODO : the 4 next properties should be made private when ES6 allows it
+
+    _this._clickTimeStamp = 0;
+    _this._lastMousePressed = {
+      viewCoords: new THREE.Vector2()
     };
+    _this._currentMousePressed = undefined;
+    _this._currentKeyPressed = undefined;
+    _this._onPointerDown = _this.onPointerDown.bind((0, _assertThisInitialized2["default"])(_this));
+    _this._onPointerMove = _this.onPointerMove.bind((0, _assertThisInitialized2["default"])(_this));
+    _this._onPointerUp = _this.onPointerUp.bind((0, _assertThisInitialized2["default"])(_this));
+    _this._onMouseWheel = _this.onMouseWheel.bind((0, _assertThisInitialized2["default"])(_this));
+    _this._onKeyDown = _this.onKeyDown.bind((0, _assertThisInitialized2["default"])(_this));
+    _this._onKeyUp = _this.onKeyUp.bind((0, _assertThisInitialized2["default"])(_this));
+    _this._onBlur = _this.onBlur.bind((0, _assertThisInitialized2["default"])(_this));
+    _this._onContextMenu = _this.onContextMenu.bind((0, _assertThisInitialized2["default"])(_this));
+
+    _this._domElement.addEventListener('pointerdown', _this._onPointerDown, false);
+
+    _this._domElement.addEventListener('wheel', _this._onMouseWheel, false); // The event listener is added on `window` so that key input can be accounted event if the view does not have
+    // the focus. This can occur at page loading, when a mini map is displayed : the minimap initially has the focus
+    // and key input would not be considered on the view's domElement.
+
+
+    window.addEventListener('keydown', _this._onKeyDown, false);
+    window.addEventListener('keyup', _this._onKeyUp, false); // Reset key/mouse when window loose focus
+
+    window.addEventListener('blur', _this._onBlur); // disable context menu when right-clicking
+
+    _this._domElement.addEventListener('contextmenu', _this._onContextMenu, false);
 
     _this.setFromOptions(options);
 
     return _this;
   }
   /**
-   * get the state corresponding to the mouse button and the keyboard key
+   * get the state corresponding to the mouse button and the keyboard key. If the input relates to a trigger - a
+   * single event which triggers movement, without the move of the mouse for instance -, dispatch a relevant event.
    * @param      {Number}  mouseButton  The mouse button
    * @param      {Number}  keyboard     The keyboard
    * @param      {Boolean} [double]     Value of the searched state `double` property
-   * @return     {state}  the state corresponding
+   * @return     {State}  the state corresponding
    */
 
 
   (0, _createClass2["default"])(StateControl, [{
     key: "inputToState",
-    value: function inputToState(mouseButton, keyboard, _double) {
-      for (var _i = 0, _Object$keys = Object.keys(this); _i < _Object$keys.length; _i++) {
+    value: function inputToState(mouseButton, keyboard) {
+      var _double = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+      for (var _i = 0, _Object$keys = Object.keys(DEFAULT_STATES); _i < _Object$keys.length; _i++) {
         var key = _Object$keys[_i];
         var state = this[key];
 
         if (state.enable && state.mouseButton === mouseButton && state.keyboard === keyboard && state["double"] === _double) {
-          return state;
+          // If the input relates to a state, returns it
+          if (!state._trigger) {
+            return state;
+          } // If the input relates to a trigger (TRAVEL_IN, TRAVEL_OUT), dispatch a relevant event.
+
+
+          this.dispatchEvent({
+            type: state._event,
+            // Dont pass viewCoords if the input is only a keyboard input.
+            viewCoords: mouseButton !== undefined && viewCoords,
+            direction: state._direction
+          });
         }
       }
 
@@ -162,7 +318,7 @@ var StateControl = /*#__PURE__*/function (_THREE$EventDispatche) {
   }, {
     key: "touchToState",
     value: function touchToState(finger) {
-      for (var _i2 = 0, _Object$keys2 = Object.keys(this); _i2 < _Object$keys2.length; _i2++) {
+      for (var _i2 = 0, _Object$keys2 = Object.keys(DEFAULT_STATES); _i2 < _Object$keys2.length; _i2++) {
         var key = _Object$keys2[_i2];
         var state = this[key];
 
@@ -176,73 +332,167 @@ var StateControl = /*#__PURE__*/function (_THREE$EventDispatche) {
     /**
      * Set the current StateControl {@link State} properties to given values.
      * @param {Object}  options     Object containing the `State` values to set current `StateControl` properties to.
+                                    * The `enable` property do not necessarily need to be specified. In that case, the
+                                    * previous value of this property will be kept for the new {@link State}.
      *
      * @example
-     * // Switch bindings for PAN and MOVE_GLOBE actions :
+     * // Switch bindings for PAN and MOVE_GLOBE actions, and disabling PANORAMIC movement :
      * view.controls.states.setFromOptions({
      *     PAN: {
-     *        enable: true,
-     *        mouseButton: itowns.THREE.MOUSE.LEFT,
+     *         mouseButton: itowns.THREE.MOUSE.LEFT,
      *     },
      *     MOVE_GLOBE: {
-     *         enable: true,
      *         mouseButton: itowns.THREE.MOUSE.RIGHT,
      *     },
+     *     PANORAMIC: {
+     *         enable: false,
+     *     },
      * };
      */
 
   }, {
     key: "setFromOptions",
     value: function setFromOptions(options) {
-      this.ORBIT = options.ORBIT || this.ORBIT || {
-        mouseButton: THREE.MOUSE.LEFT,
-        keyboard: CONTROL_KEYS.CTRL,
-        enable: true,
-        finger: 2
-      };
-      this.DOLLY = options.DOLLY || this.DOLLY || {
-        mouseButton: THREE.MOUSE.MIDDLE,
-        enable: true
-      };
-      this.PAN = options.PAN || this.PAN || {
-        mouseButton: THREE.MOUSE.RIGHT,
-        up: CONTROL_KEYS.UP,
-        bottom: CONTROL_KEYS.BOTTOM,
-        left: CONTROL_KEYS.LEFT,
-        right: CONTROL_KEYS.RIGHT,
-        enable: true,
-        finger: 3
-      };
-      this.MOVE_GLOBE = options.MOVE_GLOBE || this.MOVE_GLOBE || {
-        mouseButton: THREE.MOUSE.LEFT,
-        enable: true,
-        finger: 1
-      };
-      this.PANORAMIC = options.PANORAMIC || this.PANORAMIC || {
-        mouseButton: THREE.MOUSE.LEFT,
-        keyboard: CONTROL_KEYS.SHIFT,
-        enable: true
-      };
-      var newTravelIn = options.TRAVEL_IN || this.TRAVEL_IN || {
-        enable: true,
-        mouseButton: THREE.MOUSE.LEFT,
-        "double": true
-      };
-
-      this._domElement.removeEventListener(stateToTrigger(this.TRAVEL_IN), this._handleTravelInEvent, false);
-
-      this._domElement.addEventListener(stateToTrigger(newTravelIn), this._handleTravelInEvent, false);
-
-      this.TRAVEL_IN = newTravelIn;
-      var newTravelOut = options.TRAVEL_OUT || this.TRAVEL_OUT || {
-        enable: false
-      };
-
-      this._domElement.removeEventListener(stateToTrigger(this.TRAVEL_OUT), this._handleTravelOutEvent, false);
-
-      this._domElement.addEventListener(stateToTrigger(newTravelOut), this._handleTravelOutEvent, false);
-
-      this.TRAVEL_OUT = newTravelOut;
+      for (var state in DEFAULT_STATES) {
+        if ({}.hasOwnProperty.call(DEFAULT_STATES, state)) {
+          var newState = {};
+          newState = options[state] || this[state] || Object.assign(newState, DEFAULT_STATES[state]); // Copy the previous value of `enable` property if not defined in options
+
+          if (options[state] && options[state].enable === undefined) {
+            newState.enable = this[state].enable;
+          } // If no value is provided for the `double` property,
+          // defaults it to `false` instead of leaving it undefined
+
+
+          newState["double"] = !!newState["double"]; // Copy the `_event` and `_trigger` properties
+
+          newState._event = DEFAULT_STATES[state]._event;
+          newState._trigger = DEFAULT_STATES[state]._trigger;
+          newState._direction = DEFAULT_STATES[state]._direction;
+          this[state] = newState;
+        }
+      }
+    } // ---------- POINTER EVENTS : ----------
+
+  }, {
+    key: "onPointerDown",
+    value: function onPointerDown(event) {
+      if (!this.enabled) {
+        return;
+      }
+
+      viewCoords.copy(this._view.eventToViewCoords(event));
+
+      switch (event.pointerType) {
+        case 'mouse':
+          this._currentMousePressed = event.button;
+          this.currentState = this.inputToState(this._currentMousePressed, this._currentKeyPressed, // Detect if the mouse button was pressed less than 500 ms before, and if the cursor has not moved two much
+          // since previous click. If so, set dblclick to true.
+          event.timeStamp - this._clickTimeStamp < 500 && this._lastMousePressed.button === this._currentMousePressed && this._lastMousePressed.viewCoords.distanceTo(viewCoords) < 5);
+          this._clickTimeStamp = event.timeStamp;
+          this._lastMousePressed.button = this._currentMousePressed;
+
+          this._lastMousePressed.viewCoords.copy(viewCoords);
+
+          break;
+        // TODO : add touch event management
+
+        default:
+      }
+
+      this._domElement.addEventListener('pointermove', this._onPointerMove, false);
+
+      this._domElement.addEventListener('pointerup', this._onPointerUp, false);
+
+      this._domElement.addEventListener('mouseleave', this._onPointerUp, false);
+    }
+  }, {
+    key: "onPointerMove",
+    value: function onPointerMove(event) {
+      event.preventDefault();
+
+      if (!this.enabled) {
+        return;
+      }
+
+      viewCoords.copy(this._view.eventToViewCoords(event));
+
+      switch (event.pointerType) {
+        case 'mouse':
+          this.dispatchEvent({
+            type: this.currentState._event,
+            viewCoords: viewCoords
+          });
+          break;
+        // TODO : add touch event management
+
+        default:
+      }
+    }
+  }, {
+    key: "onPointerUp",
+    value: function onPointerUp() {
+      if (!this.enabled) {
+        return;
+      }
+
+      this._currentMousePressed = undefined;
+
+      this._domElement.removeEventListener('pointermove', this._onPointerMove, false);
+
+      this._domElement.removeEventListener('pointerup', this._onPointerUp, false);
+
+      this._domElement.removeEventListener('mouseleave', this._onPointerUp, false);
+
+      this.currentState = this.NONE;
+    } // ---------- WHEEL EVENT : ----------
+
+  }, {
+    key: "onMouseWheel",
+    value: function onMouseWheel(event) {
+      event.preventDefault();
+
+      if (this.enabled && this.ZOOM.enable) {
+        this.dispatchEvent({
+          type: this.ZOOM._event,
+          delta: event.deltaY
+        });
+      }
+    } // ---------- KEYBOARD EVENTS : ----------
+
+  }, {
+    key: "onKeyDown",
+    value: function onKeyDown(event) {
+      if (!this.enabled || !this.enableKeys) {
+        return;
+      }
+
+      this._currentKeyPressed = event.keyCode;
+      this.inputToState(this._currentMousePressed, this._currentKeyPressed);
+    }
+  }, {
+    key: "onKeyUp",
+    value: function onKeyUp() {
+      if (!this.enabled || !this.enableKeys) {
+        return;
+      }
+
+      this._currentKeyPressed = undefined;
+
+      if (this._currentMousePressed === undefined) {
+        this.currentState = this.NONE;
+      }
+    }
+  }, {
+    key: "onBlur",
+    value: function onBlur() {
+      this.onKeyUp();
+      this.onPointerUp();
+    }
+  }, {
+    key: "onContextMenu",
+    value: function onContextMenu(event) {
+      event.preventDefault();
     }
     /**
      * Remove all event listeners created within this instance of `StateControl`
@@ -251,9 +501,25 @@ var StateControl = /*#__PURE__*/function (_THREE$EventDispatche) {
   }, {
     key: "dispose",
     value: function dispose() {
-      this._domElement.removeEventListener(this.TRAVEL_IN.trigger, this._handleTravelInEvent, false);
+      this._clickTimeStamp = 0;
+      this._lastMousePressed = undefined;
+      this._currentKeyPressed = undefined;
+
+      this._domElement.removeEventListener('pointerdown', this._onPointerDown, false);
+
+      this._domElement.removeEventListener('pointermove', this._onPointerMove, false);
+
+      this._domElement.removeEventListener('pointerup', this._onPointerUp, false);
+
+      this._domElement.removeEventListener('wheel', this._onMouseWheel, false);
+
+      this._domElement.removeEventListener('keydown', this._onKeyDown, false);
+
+      this._domElement.removeEventListener('keyup', this._onKeyUp, false);
+
+      window.removeEventListener('blur', this._onBlur);
 
-      this._domElement.removeEventListener(this.TRAVEL_OUT.trigger, this._handleTravelInEvent, false);
+      this._domElement.removeEventListener('contextmenu', this._onContextMenu, false);
     }
   }]);
   return StateControl;

package/lib/Converter/Feature2Mesh.js

@@ -29,6 +29,10 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 
 var _color = new THREE.Color();
 
+var maxValueUint8 = Math.pow(2, 8) - 1;
+var maxValueUint16 = Math.pow(2, 16) - 1;
+var maxValueUint32 = Math.pow(2, 32) - 1;
+
 function toColor(color) {
   if (color) {
     if (color.type == 'Color') {
@@ -58,6 +62,16 @@ function fillBatchIdArray(batchId, batchIdArray, start, end) {
     batchIdArray[i] = batchId;
   }
 }
+
+function getIntArrayFromSize(data, size) {
+  if (size <= maxValueUint8) {
+    return new Uint8Array(data);
+  } else if (size <= maxValueUint16) {
+    return new Uint16Array(data);
+  } else {
+    return new Uint32Array(data);
+  }
+}
 /**
  * Convert coordinates to vertices positionned at a given altitude
  *
@@ -230,7 +244,7 @@ function featureToLine(feature, options) {
 
   if (feature.geometries.length > 1) {
     var countIndices = (count - feature.geometries.length) * 2;
-    var indices = new Uint16Array(countIndices);
+    var indices = getIntArrayFromSize(countIndices, count);
     var i = 0; // Multi line case
 
     var _iterator2 = _createForOfIteratorHelper(feature.geometries),
@@ -342,9 +356,9 @@ function featureToPolygon(feature, options) {
   try {
     var _loop3 = function () {
       var geometry = _step3.value;
-      var start = geometry.indices[0].offset; // To avoid integer overflow with indice value (16 bits)
+      var start = geometry.indices[0].offset; // To avoid integer overflow with index value (32 bits)
 
-      if (start > 0xffff) {
+      if (start > maxValueUint32) {
         console.warn('Feature to Polygon: integer overflow, too many points in polygons');
         return "break";
       }
@@ -396,7 +410,7 @@ function featureToPolygon(feature, options) {
     geom.setAttribute('batchId', new THREE.BufferAttribute(batchIds, 1));
   }
 
-  geom.setIndex(new THREE.BufferAttribute(new Uint16Array(indices), 1));
+  geom.setIndex(new THREE.BufferAttribute(getIntArrayFromSize(indices, vertices.length / 3), 1));
   return new THREE.Mesh(geom, material);
 }
 
@@ -509,7 +523,7 @@ function featureToExtrudedPolygon(feature, options) {
     geom.setAttribute('batchId', new THREE.BufferAttribute(batchIds, 1));
   }
 
-  geom.setIndex(new THREE.BufferAttribute(new Uint16Array(indices), 1));
+  geom.setIndex(new THREE.BufferAttribute(getIntArrayFromSize(indices, vertices.length / 3), 1));
   var mesh = new THREE.Mesh(geom, material);
   return mesh;
 }
@@ -615,6 +629,7 @@ var _default = {
       });
       group.quaternion.copy(collection.quaternion);
       group.position.copy(collection.position);
+      group.scale.copy(collection.scale);
       return group;
     };
   }