@antv/l7-layers 2.10.6 → 2.10.7

package/es/core/BaseModel.d.ts

@@ -124,8 +124,8 @@ export default class BaseModel<ChildLayerStyleOptions = {}> implements ILayerMod
     getUninforms(): IModelUniform;
     getAnimateUniforms(): IModelUniform;
     needUpdate(): boolean;
-    buildModels(callbackModel: (models: IModel[]) => void): void;
-    initModels(callbackModel: (models: IModel[]) => void): void;
+    buildModels(): Promise<IModel[]>;
+    initModels(): Promise<IModel[]>;
     clearModels(refresh?: boolean): void;
     getAttribute(): {
         attributes: {

package/es/core/BaseModel.js

@@ -1,3 +1,4 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _initializerDefineProperty from "@babel/runtime/helpers/esm/initializerDefineProperty";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
@@ -8,6 +9,8 @@ import _initializerWarningHelper from "@babel/runtime/helpers/esm/initializerWar
 
 var _dec, _class, _descriptor;
 
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
@@ -432,15 +435,53 @@ var BaseModel = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
 
   }, {
     key: "buildModels",
-    value: function buildModels(callbackModel) {
-      throw new Error('Method not implemented.');
-    } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    value: function () {
+      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                throw new Error('Method not implemented.');
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
+
+      return buildModels;
+    }() // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
   }, {
     key: "initModels",
-    value: function initModels(callbackModel) {
-      throw new Error('Method not implemented.');
-    } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    value: function () {
+      var _initModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                throw new Error('Method not implemented.');
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function initModels() {
+        return _initModels.apply(this, arguments);
+      }
+
+      return initModels;
+    }() // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
   }, {
     key: "clearModels",

package/es/core/LayerPickService.d.ts

@@ -0,0 +1,12 @@
+import { IInteractionTarget, ILayer, ILayerPickService, IMapService } from '@antv/l7-core';
+export default class BaseLayerPickService implements ILayerPickService {
+    private layer;
+    constructor(layer: ILayer);
+    pickRender(target: IInteractionTarget): void;
+    pick(layer: ILayer, target: IInteractionTarget): boolean;
+    pickRasterLayer(layer: ILayer, target: IInteractionTarget, parent?: ILayer): boolean;
+    readRasterValue(layer: ILayer, bbox: number[], mapService: IMapService, x: number, y: number): any;
+    selectFeature(pickedColors: Uint8Array | undefined): void;
+    highlightPickedFeature(pickedColors: Uint8Array | undefined): void;
+    getFeatureById(pickedFeatureIdx: number): any;
+}

package/es/core/LayerPickService.js

@@ -0,0 +1,165 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { TYPES } from '@antv/l7-core';
+import { lngLatInExtent } from '@antv/l7-utils';
+
+var BaseLayerPickService = /*#__PURE__*/function () {
+  function BaseLayerPickService(layer) {
+    _classCallCheck(this, BaseLayerPickService);
+
+    this.layer = layer;
+  }
+
+  _createClass(BaseLayerPickService, [{
+    key: "pickRender",
+    value: function pickRender(target) {
+      var layer = this.layer; // 瓦片图层的拾取绘制
+
+      if (layer.tileLayer) {
+        return layer.tileLayer.pickRender(target);
+      }
+
+      layer.hooks.beforePickingEncode.call();
+
+      if (layer.masks.length > 0) {
+        // 若存在 mask，则在 pick 阶段的绘制也启用
+        layer.masks.filter(function (mask) {
+          return mask.inited;
+        }).forEach( /*#__PURE__*/function () {
+          var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(m) {
+            return _regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    m.render();
+
+                  case 1:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }));
+
+          return function (_x) {
+            return _ref.apply(this, arguments);
+          };
+        }());
+      }
+
+      layer.renderModels(true);
+      layer.hooks.afterPickingEncode.call();
+    }
+  }, {
+    key: "pick",
+    value: function pick(layer, target) {
+      var container = this.layer.getContainer();
+      var pickingService = container.get(TYPES.IPickingService);
+
+      if (layer.type === 'RasterLayer') {
+        return this.pickRasterLayer(layer, target);
+      }
+
+      this.pickRender(target);
+      return pickingService.pickFromPickingFBO(layer, target);
+    }
+  }, {
+    key: "pickRasterLayer",
+    value: function pickRasterLayer(layer, target, parent) {
+      var container = this.layer.getContainer();
+      var pickingService = container.get(TYPES.IPickingService);
+      var mapService = container.get(TYPES.IMapService);
+      var extent = this.layer.getSource().extent;
+      var isPick = lngLatInExtent(target.lngLat, extent);
+      var layerTarget = {
+        x: target.x,
+        y: target.y,
+        type: target.type,
+        lngLat: target.lngLat,
+        target: target,
+        rasterValue: null
+      };
+      var adviceTarget = parent ? parent : layer;
+
+      if (isPick) {
+        var rasterValue = this.readRasterValue(layer, extent, mapService, target.x, target.y);
+        layerTarget.rasterValue = rasterValue;
+        pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
+        return true;
+      } else {
+        layerTarget.type = target.type === 'mousemove' ? 'mouseout' : 'un' + target.type;
+        pickingService.triggerHoverOnLayer(adviceTarget, _objectSpread(_objectSpread({}, layerTarget), {}, {
+          type: 'unpick'
+        }));
+        pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
+        return false;
+      }
+    }
+  }, {
+    key: "readRasterValue",
+    value: function readRasterValue(layer, bbox, mapService, x, y) {
+      var rasterData = layer.getSource().data.dataArray[0];
+
+      var _bbox = _slicedToArray(bbox, 4),
+          _bbox$ = _bbox[0],
+          minLng = _bbox$ === void 0 ? 0 : _bbox$,
+          _bbox$2 = _bbox[1],
+          minLat = _bbox$2 === void 0 ? 0 : _bbox$2,
+          _bbox$3 = _bbox[2],
+          maxLng = _bbox$3 === void 0 ? 10 : _bbox$3,
+          _bbox$4 = _bbox[3],
+          maxLat = _bbox$4 === void 0 ? -10 : _bbox$4;
+
+      var tileXY = mapService.lngLatToContainer([minLng, minLat]);
+      var tileMaxXY = mapService.lngLatToContainer([maxLng, maxLat]);
+      var tilePixelWidth = tileMaxXY.x - tileXY.x;
+      var tilePixelHeight = tileXY.y - tileMaxXY.y;
+      var pos = [(x - tileXY.x) / tilePixelWidth, // x
+      (y - tileMaxXY.y) / tilePixelHeight // y
+      ];
+      var tileWidth = rasterData.width || 1;
+      var tileHeight = rasterData.height || 1;
+      var indexX = Math.floor(pos[0] * tileWidth);
+      var indexY = Math.floor(pos[1] * tileHeight);
+      var index = Math.max(0, indexY - 1) * tileWidth + indexX;
+      var data = rasterData.data[index];
+      return data;
+    }
+  }, {
+    key: "selectFeature",
+    value: function selectFeature(pickedColors) {
+      var layer = this.layer; // @ts-ignore
+
+      var _pickedColors = _slicedToArray(pickedColors, 3),
+          r = _pickedColors[0],
+          g = _pickedColors[1],
+          b = _pickedColors[2];
+
+      layer.hooks.beforeSelect.call([r, g, b]);
+    }
+  }, {
+    key: "highlightPickedFeature",
+    value: function highlightPickedFeature(pickedColors) {
+      // @ts-ignore
+      var _pickedColors2 = _slicedToArray(pickedColors, 3),
+          r = _pickedColors2[0],
+          g = _pickedColors2[1],
+          b = _pickedColors2[2];
+
+      this.layer.hooks.beforeHighlight.call([r, g, b]);
+    }
+  }, {
+    key: "getFeatureById",
+    value: function getFeatureById(pickedFeatureIdx) {
+      return this.layer.getSource().getFeatureById(pickedFeatureIdx);
+    }
+  }]);
+
+  return BaseLayerPickService;
+}();
+
+export { BaseLayerPickService as default };

package/es/core/TextureService.d.ts

@@ -0,0 +1,14 @@
+import { ILayer, ITexture2D, ITextureService } from '@antv/l7-core';
+import { IColorRamp } from '@antv/l7-utils';
+export default class TextureService implements ITextureService {
+    private layer;
+    private rendererService;
+    private colorTexture;
+    private key;
+    constructor(layer: ILayer);
+    getColorTexture(colorRamp: IColorRamp): ITexture2D;
+    createColorTexture(colorRamp: IColorRamp): ITexture2D;
+    setColorTexture(texture: ITexture2D, colorRamp: IColorRamp): void;
+    destroy(): void;
+    private getTextureKey;
+}

package/es/core/TextureService.js

@@ -0,0 +1,67 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { TYPES } from '@antv/l7-core';
+import { generateColorRamp } from '@antv/l7-utils';
+
+var TextureService = /*#__PURE__*/function () {
+  function TextureService(layer) {
+    _classCallCheck(this, TextureService);
+
+    this.layer = layer;
+    var container = this.layer.getContainer();
+    this.rendererService = container.get(TYPES.IRendererService);
+  }
+
+  _createClass(TextureService, [{
+    key: "getColorTexture",
+    value: function getColorTexture(colorRamp) {
+      // TODO 支持传入图片
+      var currentkey = this.getTextureKey(colorRamp);
+
+      if (this.key === currentkey) {
+        return this.colorTexture;
+      } else {
+        this.createColorTexture(colorRamp);
+      }
+
+      this.key = currentkey;
+      return this.colorTexture;
+    }
+  }, {
+    key: "createColorTexture",
+    value: function createColorTexture(colorRamp) {
+      var createTexture2D = this.rendererService.createTexture2D;
+      var imageData = generateColorRamp(colorRamp);
+      var texture = createTexture2D({
+        data: imageData.data,
+        width: imageData.width,
+        height: imageData.height,
+        flipY: false
+      });
+      this.colorTexture = texture;
+      return texture;
+    }
+  }, {
+    key: "setColorTexture",
+    value: function setColorTexture(texture, colorRamp) {
+      this.key = this.getTextureKey(colorRamp);
+      this.colorTexture = texture;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this$colorTexture;
+
+      (_this$colorTexture = this.colorTexture) === null || _this$colorTexture === void 0 ? void 0 : _this$colorTexture.destroy();
+    }
+  }, {
+    key: "getTextureKey",
+    value: function getTextureKey(colorRamp) {
+      return "".concat(colorRamp.colors.join('_'), "_").concat(colorRamp.positions.join('_'));
+    }
+  }]);
+
+  return TextureService;
+}();
+
+export { TextureService as default };

package/es/core/triangulation.js

@@ -204,7 +204,14 @@ function pushDis(point, n) {
   return point;
 }
 
-function getSimpleLineVertices(points) {
+function getSimpleLineVertices(coordinates) {
+  var points = coordinates;
+
+  if (Array.isArray(points) && Array.isArray(points[0]) && Array.isArray(points[0][0])) {
+    // @ts-ignore
+    points = coordinates.flat();
+  }
+
   var distance = 0;
 
   if (points.length < 2) {

package/es/earth/index.d.ts

@@ -11,12 +11,12 @@ export default class EarthLayer extends BaseLayer<IEarthLayerStyleOptions> {
         data: any[];
         options: ISourceCFG | undefined;
     };
-    buildModels(): void;
+    buildModels(): Promise<void>;
     /**
      * 设置当前地球时间
      * @param time
      */
     setEarthTime(time: number): void;
-    protected getModelType(): EarthModelType;
+    getModelType(): EarthModelType;
 }
 export {};

package/es/earth/index.js

@@ -1,3 +1,4 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
@@ -5,6 +6,7 @@ import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -53,15 +55,32 @@ var EarthLayer = /*#__PURE__*/function (_BaseLayer) {
 
   _createClass(EarthLayer, [{
     key: "buildModels",
-    value: function buildModels() {
-      var _this2 = this;
-
-      var shape = this.getModelType();
-      this.layerModel = new EarthModels[shape](this);
-      this.layerModel.initModels(function (models) {
-        _this2.dispatchModelLoad(models);
-      });
-    }
+    value: function () {
+      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var shape;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                shape = this.getModelType();
+                this.layerModel = new EarthModels[shape](this);
+                _context.next = 4;
+                return this.initLayerModels();
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
+
+      return buildModels;
+    }()
     /**
      * 设置当前地球时间
      * @param time

package/es/earth/models/atmosphere.d.ts

@@ -2,8 +2,8 @@ import { IModel, IModelUniform } from '@antv/l7-core';
 import BaseModel from '../../core/BaseModel';
 export default class EarthAtomSphereModel extends BaseModel {
     getUninforms(): IModelUniform;
-    initModels(callbackModel: (models: IModel[]) => void): void;
+    initModels(): Promise<IModel[]>;
     clearModels(): string;
-    buildModels(callbackModel: (models: IModel[]) => void): void;
+    buildModels(): Promise<IModel[]>;
     protected registerBuiltinAttributes(): void;
 }

package/es/earth/models/atmosphere.js

@@ -1,8 +1,10 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -43,9 +45,32 @@ var EarthAtomSphereModel = /*#__PURE__*/function (_BaseModel) {
     }
   }, {
     key: "initModels",
-    value: function initModels(callbackModel) {
-      this.buildModels(callbackModel);
-    }
+    value: function () {
+      var _initModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.buildModels();
+
+              case 2:
+                return _context.abrupt("return", _context.sent);
+
+              case 3:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initModels() {
+        return _initModels.apply(this, arguments);
+      }
+
+      return initModels;
+    }()
   }, {
     key: "clearModels",
     value: function clearModels() {
@@ -53,25 +78,45 @@ var EarthAtomSphereModel = /*#__PURE__*/function (_BaseModel) {
     }
   }, {
     key: "buildModels",
-    value: function buildModels(callbackModel) {
-      // TODO: 调整图层的绘制顺序 地球大气层
-      this.layer.zIndex = -997;
-      this.layer.buildLayerModel({
-        moduleName: 'earthAtmoSphere',
-        vertexShader: atmoSphereVert,
-        fragmentShader: atmoSphereFrag,
-        triangulation: earthTriangulation,
-        depth: {
-          enable: false
-        },
-        blend: this.getBlend()
-      }).then(function (model) {
-        callbackModel([model]);
-      }).catch(function (err) {
-        console.warn(err);
-        callbackModel([]);
-      });
-    }
+    value: function () {
+      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var model;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                // TODO: 调整图层的绘制顺序 地球大气层
+                this.layer.zIndex = -997;
+                _context2.next = 3;
+                return this.layer.buildLayerModel({
+                  moduleName: 'earthAtmoSphere',
+                  vertexShader: atmoSphereVert,
+                  fragmentShader: atmoSphereFrag,
+                  triangulation: earthTriangulation,
+                  depth: {
+                    enable: false
+                  },
+                  blend: this.getBlend()
+                });
+
+              case 3:
+                model = _context2.sent;
+                return _context2.abrupt("return", [model]);
+
+              case 5:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
+
+      return buildModels;
+    }()
   }, {
     key: "registerBuiltinAttributes",
     value: function registerBuiltinAttributes() {

package/es/earth/models/base.d.ts

@@ -9,8 +9,8 @@ export default class BaseEarthModel extends BaseModel {
     private sunRadius;
     getUninforms(): IModelUniform;
     setEarthTime(time: number): void;
-    initModels(callbackModel: (models: IModel[]) => void): void;
+    initModels(): Promise<IModel[]>;
     clearModels(): string;
-    buildModels(callbackModel: (models: IModel[]) => void): void;
+    buildModels(): Promise<IModel[]>;
     protected registerBuiltinAttributes(): void;
 }