@antv/l7-layers 2.9.25-alpha.0 → 2.9.26-alpha.1

package/lib/core/BaseLayer.js

@@ -1,891 +1,1408 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-
-// src/core/BaseLayer.ts
-var BaseLayer_exports = {};
-__export(BaseLayer_exports, {
-  default: () => BaseLayer
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(BaseLayer_exports);
-var import_async_hook = require("@antv/async-hook");
-var import_l7_core = require("@antv/l7-core");
-var import_l7_source = __toESM(require("@antv/l7-source"));
-var import_l7_utils = require("@antv/l7-utils");
-var import_eventemitter3 = require("eventemitter3");
-var import_lodash = require("lodash");
-var import_blend = require("../utils/blend");
-var import_dataMappingStyle = require("../utils/dataMappingStyle");
-var import_layerData = require("../utils/layerData");
-var import_multiPassRender = require("../utils/multiPassRender");
-var import_updateShape = require("../utils/updateShape");
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _initializerDefineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/initializerDefineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+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"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
+
+var _initializerWarningHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/initializerWarningHelper"));
+
+var _asyncHook = require("@antv/async-hook");
+
+var _l7Core = require("@antv/l7-core");
+
+var _l7Source = _interopRequireDefault(require("@antv/l7-source"));
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _eventemitter = require("eventemitter3");
+
+var _lodash = require("lodash");
+
+var _blend = require("../utils/blend");
+
+var _dataMappingStyle = require("../utils/dataMappingStyle");
+
+var _layerData = require("../utils/layerData");
+
+var _multiPassRender = require("../utils/multiPassRender");
+
+var _updateShape = require("../utils/updateShape");
+
+var _excluded = ["passes"],
+    _excluded2 = ["moduleName", "vertexShader", "fragmentShader", "triangulation", "segmentNumber", "workerEnabled", "workerOptions"];
+
+var _dec, _class, _descriptor;
+
+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); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { 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; } }
+
+/**
+ * 分配 layer id
+ */
 var layerIdCounter = 0;
-var BaseLayer = class extends import_eventemitter3.EventEmitter {
-  constructor(config = {}) {
-    super();
-    this.id = `${layerIdCounter++}`;
-    this.name = `${layerIdCounter}`;
-    this.visible = true;
-    this.zIndex = 0;
-    this.inited = false;
-    this.layerModelNeedUpdate = false;
-    this.pickedFeatureID = null;
-    this.selectedFeatureID = null;
-    this.styleNeedUpdate = false;
-    this.clusterZoom = 0;
-    this.dataState = {
+var BaseLayer = (_dec = (0, _l7Core.lazyInject)(_l7Core.TYPES.IGlobalConfigService), (_class = /*#__PURE__*/function (_ref) {
+  (0, _inherits2.default)(BaseLayer, _ref);
+
+  var _super = _createSuper(BaseLayer);
+
+  // 生命周期钩子
+  // 待渲染 model 列表
+  // TODO: 用于保存子图层对象
+  // Tip: 用于标识矢量图层
+
+  /**
+   * 待更新样式属性，在初始化阶段完成注册
+   */
+  // TODO: layer 保底颜色
+  // private pickingPassRender: IPass<'pixelPicking'>;
+  function BaseLayer() {
+    var _this;
+
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, BaseLayer);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "id", "".concat(layerIdCounter++));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "name", "".concat(layerIdCounter));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "visible", true);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "zIndex", 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "inited", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "layerModelNeedUpdate", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "pickedFeatureID", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "selectedFeatureID", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "styleNeedUpdate", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "clusterZoom", 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "dataState", {
       dataSourceNeedUpdate: false,
       dataMappingNeedUpdate: false,
       filterNeedUpdate: false,
       featureScaleNeedUpdate: false,
       StyleAttrNeedUpdate: false
-    };
-    this.hooks = {
-      init: new import_async_hook.SyncBailHook(),
-      afterInit: new import_async_hook.SyncBailHook(),
-      beforeRender: new import_async_hook.SyncBailHook(),
-      beforeRenderData: new import_async_hook.SyncWaterfallHook(),
-      afterRender: new import_async_hook.SyncHook(),
-      beforePickingEncode: new import_async_hook.SyncHook(),
-      afterPickingEncode: new import_async_hook.SyncHook(),
-      beforeHighlight: new import_async_hook.SyncHook(["pickedColor"]),
-      afterHighlight: new import_async_hook.SyncHook(),
-      beforeSelect: new import_async_hook.SyncHook(["pickedColor"]),
-      afterSelect: new import_async_hook.SyncHook(),
-      beforeDestroy: new import_async_hook.SyncHook(),
-      afterDestroy: new import_async_hook.SyncHook()
-    };
-    this.models = [];
-    this.layerChildren = [];
-    this.masks = [];
-    this.isVector = false;
-    this.animateOptions = { enable: false };
-    this.currentPickId = null;
-    this.pendingStyleAttributes = [];
-    this.scaleOptions = {};
-    this.aniamateStatus = false;
-    this.bottomColor = "rgba(0, 0, 0, 0)";
-    this.isDestroied = false;
-    this.sourceEvent = () => {
-      this.dataState.dataSourceNeedUpdate = true;
-      const layerConfig = this.getLayerConfig();
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "hooks", {
+      init: new _asyncHook.SyncBailHook(),
+      afterInit: new _asyncHook.SyncBailHook(),
+      beforeRender: new _asyncHook.SyncBailHook(),
+      beforeRenderData: new _asyncHook.SyncWaterfallHook(),
+      afterRender: new _asyncHook.SyncHook(),
+      beforePickingEncode: new _asyncHook.SyncHook(),
+      afterPickingEncode: new _asyncHook.SyncHook(),
+      beforeHighlight: new _asyncHook.SyncHook(['pickedColor']),
+      afterHighlight: new _asyncHook.SyncHook(),
+      beforeSelect: new _asyncHook.SyncHook(['pickedColor']),
+      afterSelect: new _asyncHook.SyncHook(),
+      beforeDestroy: new _asyncHook.SyncHook(),
+      afterDestroy: new _asyncHook.SyncHook()
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "models", []);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "layerChildren", []);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "masks", []);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isVector", false);
+    (0, _initializerDefineProperty2.default)((0, _assertThisInitialized2.default)(_this), "configService", _descriptor, (0, _assertThisInitialized2.default)(_this));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "animateOptions", {
+      enable: false
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "currentPickId", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "pendingStyleAttributes", []);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "scaleOptions", {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "aniamateStatus", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "bottomColor", 'rgba(0, 0, 0, 0)');
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isDestroied", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "sourceEvent", function () {
+      _this.dataState.dataSourceNeedUpdate = true;
+
+      var layerConfig = _this.getLayerConfig();
+
       if (layerConfig && layerConfig.autoFit) {
-        this.fitBounds(layerConfig.fitBoundsOptions);
-      }
-      this.reRender();
-    };
-    this.name = config.name || this.id;
-    this.zIndex = config.zIndex || 0;
-    this.rawConfig = config;
-  }
-  addMaskLayer(maskLayer) {
-    this.masks.push(maskLayer);
+        _this.fitBounds(layerConfig.fitBoundsOptions);
+      } // 对外暴露事件 迁移到 DataMappingPlugin generateMapping，保证在重新重新映射后触发
+      // this.emit('dataUpdate');
+
+
+      _this.reRender();
+    });
+    _this.name = config.name || _this.id;
+    _this.zIndex = config.zIndex || 0;
+    _this.rawConfig = config;
+    return _this;
   }
-  removeMaskLayer(maskLayer) {
-    const layerIndex = this.masks.indexOf(maskLayer);
-    if (layerIndex > -1) {
-      this.masks.splice(layerIndex, 1);
+
+  (0, _createClass2.default)(BaseLayer, [{
+    key: "addMaskLayer",
+    value: function addMaskLayer(maskLayer) {
+      this.masks.push(maskLayer);
     }
-    maskLayer.destroy();
-  }
-  getAttribute(name) {
-    return this.styleAttributeService.getLayerStyleAttribute(name);
-  }
-  getLayerConfig() {
-    return this.configService.getLayerConfig(this.id);
-  }
-  updateLayerConfig(configToUpdate) {
-    Object.keys(configToUpdate).map((key) => {
-      if (key in this.rawConfig) {
-        this.rawConfig[key] = configToUpdate[key];
+  }, {
+    key: "removeMaskLayer",
+    value: function removeMaskLayer(maskLayer) {
+      var layerIndex = this.masks.indexOf(maskLayer);
+
+      if (layerIndex > -1) {
+        this.masks.splice(layerIndex, 1);
       }
-    });
-    if (!this.inited) {
-      this.needUpdateConfig = {
-        ...this.needUpdateConfig,
-        ...configToUpdate
-      };
-    } else {
-      const sceneId = this.container.get(import_l7_core.TYPES.SceneID);
-      (0, import_dataMappingStyle.handleStyleDataMapping)(configToUpdate, this);
-      this.configService.setLayerConfig(sceneId, this.id, {
-        ...this.configService.getLayerConfig(this.id),
-        ...this.needUpdateConfig,
-        ...configToUpdate
-      });
-      this.needUpdateConfig = {};
+
+      maskLayer.destroy();
     }
-  }
-  setContainer(container, sceneContainer) {
-    this.container = container;
-    this.sceneContainer = sceneContainer;
-  }
-  getContainer() {
-    return this.container;
-  }
-  setBottomColor(color) {
-    this.bottomColor = color;
-  }
-  getBottomColor() {
-    return this.bottomColor;
-  }
-  addPlugin(plugin) {
-    this.plugins.push(plugin);
-    return this;
-  }
-  init() {
-    const sceneId = this.container.get(import_l7_core.TYPES.SceneID);
-    this.configService.setLayerConfig(sceneId, this.id, this.rawConfig);
-    this.layerType = this.rawConfig.layerType;
-    this.iconService = this.container.get(import_l7_core.TYPES.IIconService);
-    this.fontService = this.container.get(import_l7_core.TYPES.IFontService);
-    this.rendererService = this.container.get(import_l7_core.TYPES.IRendererService);
-    this.layerService = this.container.get(import_l7_core.TYPES.ILayerService);
-    this.interactionService = this.container.get(import_l7_core.TYPES.IInteractionService);
-    this.pickingService = this.container.get(import_l7_core.TYPES.IPickingService);
-    this.mapService = this.container.get(import_l7_core.TYPES.IMapService);
-    const { enableMultiPassRenderer, passes } = this.getLayerConfig();
-    if (enableMultiPassRenderer && (passes == null ? void 0 : passes.length) && passes.length > 0) {
-      this.mapService.on("mapAfterFrameChange", () => {
-        this.renderLayers();
-      });
+  }, {
+    key: "getAttribute",
+    value: function getAttribute(name) {
+      return this.styleAttributeService.getLayerStyleAttribute(name);
+    }
+  }, {
+    key: "getLayerConfig",
+    value: function getLayerConfig() {
+      return this.configService.getLayerConfig(this.id);
     }
-    this.cameraService = this.container.get(import_l7_core.TYPES.ICameraService);
-    this.coordinateService = this.container.get(import_l7_core.TYPES.ICoordinateSystemService);
-    this.shaderModuleService = this.container.get(import_l7_core.TYPES.IShaderModuleService);
-    this.postProcessingPassFactory = this.container.get(import_l7_core.TYPES.IFactoryPostProcessingPass);
-    this.normalPassFactory = this.container.get(import_l7_core.TYPES.IFactoryNormalPass);
-    this.styleAttributeService = this.container.get(import_l7_core.TYPES.IStyleAttributeService);
-    this.multiPassRenderer = this.container.get(import_l7_core.TYPES.IMultiPassRenderer);
-    this.multiPassRenderer.setLayer(this);
-    this.pendingStyleAttributes.forEach(({ attributeName, attributeField, attributeValues, updateOptions }) => {
-      this.styleAttributeService.updateStyleAttribute(attributeName, {
-        scale: {
-          field: attributeField,
-          ...this.splitValuesAndCallbackInAttribute(attributeValues, this.getLayerConfig()[attributeName])
+  }, {
+    key: "updateLayerConfig",
+    value: function updateLayerConfig(configToUpdate) {
+      var _this2 = this;
+
+      // 同步 rawConfig
+      Object.keys(configToUpdate).map(function (key) {
+        if (key in _this2.rawConfig) {
+          // @ts-ignore
+          _this2.rawConfig[key] = configToUpdate[key];
         }
-      }, updateOptions);
-    });
-    this.pendingStyleAttributes = [];
-    this.plugins = this.container.getAll(import_l7_core.TYPES.ILayerPlugin);
-    for (const plugin of this.plugins) {
-      plugin.apply(this, {
-        rendererService: this.rendererService,
-        mapService: this.mapService,
-        styleAttributeService: this.styleAttributeService,
-        normalPassFactory: this.normalPassFactory,
-        postProcessingPassFactory: this.postProcessingPassFactory
       });
+
+      if (!this.inited) {
+        this.needUpdateConfig = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, this.needUpdateConfig), configToUpdate);
+      } else {
+        var sceneId = this.container.get(_l7Core.TYPES.SceneID); // @ts-ignore
+
+        (0, _dataMappingStyle.handleStyleDataMapping)(configToUpdate, this); // 处理 style 中进行数据映射的属性字段
+
+        this.configService.setLayerConfig(sceneId, this.id, (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, this.configService.getLayerConfig(this.id)), this.needUpdateConfig), configToUpdate));
+        this.needUpdateConfig = {};
+      }
     }
-    this.hooks.init.call();
-    this.hooks.afterInit.call();
-    this.emit("inited", {
-      target: this,
-      type: "inited"
-    });
-    this.emit("add", {
-      target: this,
-      type: "add"
-    });
-    return this;
-  }
-  updateModelData(data) {
-    if (data.attributes && data.elements) {
-      this.models.map((m) => {
-        m.updateAttributesAndElements(data.attributes, data.elements);
+    /**
+     * 注入图层容器，父容器为场景容器
+     * RootContainer 1
+     *  -> SceneContainer 1.*
+     *   -> LayerContainer 1.*
+     */
+
+  }, {
+    key: "setContainer",
+    value: function setContainer(container, sceneContainer) {
+      this.container = container;
+      this.sceneContainer = sceneContainer;
+    }
+  }, {
+    key: "getContainer",
+    value: function getContainer() {
+      return this.container;
+    }
+  }, {
+    key: "setBottomColor",
+    value: function setBottomColor(color) {
+      this.bottomColor = color;
+    }
+  }, {
+    key: "getBottomColor",
+    value: function getBottomColor() {
+      return this.bottomColor;
+    }
+  }, {
+    key: "addPlugin",
+    value: function addPlugin(plugin) {
+      // TODO: 控制插件注册顺序
+      // @example:
+      // pointLayer.addPlugin(new MyCustomPlugin(), {
+      //   before: 'L7BuiltinPlugin'
+      // });
+      this.plugins.push(plugin);
+      return this;
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      var _this3 = this;
+
+      // 设置配置项
+      var sceneId = this.container.get(_l7Core.TYPES.SceneID); // 初始化图层配置项
+      // const { enableMultiPassRenderer = false } = this.rawConfig;
+      // this.configService.setLayerConfig(sceneId, this.id, {
+      //   enableMultiPassRenderer,
+      // });
+
+      this.configService.setLayerConfig(sceneId, this.id, this.rawConfig);
+      this.layerType = this.rawConfig.layerType; // 全局容器服务
+      // 场景容器服务
+
+      this.iconService = this.container.get(_l7Core.TYPES.IIconService);
+      this.fontService = this.container.get(_l7Core.TYPES.IFontService);
+      this.rendererService = this.container.get(_l7Core.TYPES.IRendererService);
+      this.layerService = this.container.get(_l7Core.TYPES.ILayerService);
+      this.interactionService = this.container.get(_l7Core.TYPES.IInteractionService);
+      this.pickingService = this.container.get(_l7Core.TYPES.IPickingService);
+      this.mapService = this.container.get(_l7Core.TYPES.IMapService);
+
+      var _this$getLayerConfig = this.getLayerConfig(),
+          enableMultiPassRenderer = _this$getLayerConfig.enableMultiPassRenderer,
+          passes = _this$getLayerConfig.passes;
+
+      if (enableMultiPassRenderer && passes !== null && passes !== void 0 && passes.length && passes.length > 0) {
+        // Tip: 兼容 multiPassRender 在 amap1 时存在的图层不同步问题 zoom
+        this.mapService.on('mapAfterFrameChange', function () {
+          _this3.renderLayers();
+        });
+      }
+
+      this.cameraService = this.container.get(_l7Core.TYPES.ICameraService);
+      this.coordinateService = this.container.get(_l7Core.TYPES.ICoordinateSystemService);
+      this.shaderModuleService = this.container.get(_l7Core.TYPES.IShaderModuleService);
+      this.postProcessingPassFactory = this.container.get(_l7Core.TYPES.IFactoryPostProcessingPass);
+      this.normalPassFactory = this.container.get(_l7Core.TYPES.IFactoryNormalPass); // 图层容器服务
+
+      this.styleAttributeService = this.container.get(_l7Core.TYPES.IStyleAttributeService);
+      this.multiPassRenderer = this.container.get(_l7Core.TYPES.IMultiPassRenderer);
+      this.multiPassRenderer.setLayer(this); // 完成样式服务注册完成前添加的属性
+
+      this.pendingStyleAttributes.forEach(function (_ref2) {
+        var attributeName = _ref2.attributeName,
+            attributeField = _ref2.attributeField,
+            attributeValues = _ref2.attributeValues,
+            updateOptions = _ref2.updateOptions;
+
+        _this3.styleAttributeService.updateStyleAttribute(attributeName, {
+          // @ts-ignore
+          scale: (0, _objectSpread2.default)({
+            field: attributeField
+          }, _this3.splitValuesAndCallbackInAttribute( // @ts-ignore
+          attributeValues, // @ts-ignore
+          _this3.getLayerConfig()[attributeName]))
+        }, // @ts-ignore
+        updateOptions);
+      });
+      this.pendingStyleAttributes = []; // 获取插件集
+
+      this.plugins = this.container.getAll(_l7Core.TYPES.ILayerPlugin); // 完成插件注册，传入场景和图层容器内的服务
+
+      var _iterator = _createForOfIteratorHelper(this.plugins),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var plugin = _step.value;
+          plugin.apply(this, {
+            rendererService: this.rendererService,
+            mapService: this.mapService,
+            styleAttributeService: this.styleAttributeService,
+            normalPassFactory: this.normalPassFactory,
+            postProcessingPassFactory: this.postProcessingPassFactory
+          });
+        } // 触发 init 生命周期插件
+
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      this.hooks.init.call(); // this.pickingPassRender = this.normalPassFactory('pixelPicking');
+      // this.pickingPassRender.init(this);
+
+      this.hooks.afterInit.call(); // 触发初始化完成事件;
+
+      this.emit('inited', {
+        target: this,
+        type: 'inited'
+      });
+      this.emit('add', {
+        target: this,
+        type: 'add'
       });
-    } else {
-      console.warn("data error");
+      return this;
     }
-  }
-  createModelData(data, option) {
-    var _a;
-    if ((_a = this.layerModel) == null ? void 0 : _a.createModelData) {
-      return this.layerModel.createModelData(option);
-    }
-    const calEncodeData = this.calculateEncodeData(data, option);
-    const triangulation = this.triangulation;
-    if (calEncodeData && triangulation) {
-      return this.styleAttributeService.createAttributesAndIndices(calEncodeData, triangulation);
-    } else {
-      return {
-        attributes: void 0,
-        elements: void 0
-      };
+  }, {
+    key: "updateModelData",
+    value: function updateModelData(data) {
+      if (data.attributes && data.elements) {
+        this.models.map(function (m) {
+          m.updateAttributesAndElements(data.attributes, data.elements);
+        });
+      } else {
+        console.warn('data error');
+      }
     }
-  }
-  calculateEncodeData(data, option) {
-    if (this.inited) {
-      return (0, import_layerData.calculateData)(this, this.fontService, this.mapService, this.styleAttributeService, data, option);
-    } else {
-      console.warn("layer not inited!");
-      return null;
+  }, {
+    key: "createModelData",
+    value: function createModelData(data, option) {
+      var _this$layerModel;
+
+      if ((_this$layerModel = this.layerModel) !== null && _this$layerModel !== void 0 && _this$layerModel.createModelData) {
+        // 在某些特殊图层中单独构建 attribute & elements
+        return this.layerModel.createModelData(option);
+      }
+
+      var calEncodeData = this.calculateEncodeData(data, option);
+      var triangulation = this.triangulation;
+
+      if (calEncodeData && triangulation) {
+        return this.styleAttributeService.createAttributesAndIndices(calEncodeData, triangulation);
+      } else {
+        return {
+          attributes: undefined,
+          elements: undefined
+        };
+      }
     }
-  }
-  prepareBuildModel() {
-    this.inited = true;
-    this.updateLayerConfig({
-      ...this.getDefaultConfig(),
-      ...this.rawConfig
-    });
-    const { animateOption } = this.getLayerConfig();
-    if (animateOption == null ? void 0 : animateOption.enable) {
-      this.layerService.startAnimate();
-      this.aniamateStatus = true;
+  }, {
+    key: "calculateEncodeData",
+    value: function calculateEncodeData(data, option) {
+      if (this.inited) {
+        return (0, _layerData.calculateData)(this, this.fontService, this.mapService, this.styleAttributeService, data, option);
+      } else {
+        console.warn('layer not inited!');
+        return null;
+      }
     }
-  }
-  color(field, values, updateOptions) {
-    this.updateStyleAttribute("color", field, values, updateOptions);
-    return this;
-  }
-  texture(field, values, updateOptions) {
-    this.updateStyleAttribute("texture", field, values, updateOptions);
-    return this;
-  }
-  rotate(field, values, updateOptions) {
-    this.updateStyleAttribute("rotate", field, values, updateOptions);
-    return this;
-  }
-  size(field, values, updateOptions) {
-    this.updateStyleAttribute("size", field, values, updateOptions);
-    return this;
-  }
-  filter(field, values, updateOptions) {
-    this.updateStyleAttribute("filter", field, values, updateOptions);
-    return this;
-  }
-  shape(field, values, updateOptions) {
-    var _a, _b, _c;
-    const lastShape = (_c = (_b = (_a = this.styleAttributeService) == null ? void 0 : _a.getLayerStyleAttribute("shape")) == null ? void 0 : _b.scale) == null ? void 0 : _c.field;
-    const currentShape = field;
-    this.shapeOption = {
-      field,
-      values
-    };
-    this.updateStyleAttribute("shape", field, values, updateOptions);
-    if (!this.tileLayer) {
-      (0, import_updateShape.updateShape)(this, lastShape, currentShape);
-    }
-    return this;
-  }
-  label(field, values, updateOptions) {
-    this.pendingStyleAttributes.push({
-      attributeName: "label",
-      attributeField: field,
-      attributeValues: values,
-      updateOptions
-    });
-    return this;
-  }
-  animate(options) {
-    let rawAnimate = {};
-    if ((0, import_lodash.isObject)(options)) {
-      rawAnimate.enable = true;
-      rawAnimate = {
-        ...rawAnimate,
-        ...options
-      };
-    } else {
-      rawAnimate.enable = options;
+    /**
+     * Model初始化前需要更新Model样式
+     */
+
+  }, {
+    key: "prepareBuildModel",
+    value: function prepareBuildModel() {
+      this.inited = true;
+      this.updateLayerConfig((0, _objectSpread2.default)((0, _objectSpread2.default)({}, this.getDefaultConfig()), this.rawConfig)); // 启动动画
+
+      var _this$getLayerConfig2 = this.getLayerConfig(),
+          animateOption = _this$getLayerConfig2.animateOption;
+
+      if (animateOption !== null && animateOption !== void 0 && animateOption.enable) {
+        this.layerService.startAnimate();
+        this.aniamateStatus = true;
+      }
     }
-    this.updateLayerConfig({
-      animateOption: rawAnimate
-    });
-    return this;
-  }
-  source(data, options) {
-    if (data == null ? void 0 : data.data) {
-      this.setSource(data);
+  }, {
+    key: "color",
+    value: function color(field, values, updateOptions) {
+      // 设置 color、size、shape、style 时由于场景服务尚未完成（并没有调用 scene.addLayer），因此暂时加入待更新属性列表
+      this.updateStyleAttribute('color', field, values, updateOptions); // this.pendingStyleAttributes.push({
+      //   attributeName: 'color',
+      //   attributeField: field,
+      //   attributeValues: values,
+      //   defaultName: 'colors',
+      //   updateOptions,
+      // });
+
+      return this;
+    } // 为对应的图层传入纹理的编号名称（point/image 在 shape 方法中传入纹理名称的方法并不通用）
+
+  }, {
+    key: "texture",
+    value: function texture(field, values, updateOptions) {
+      this.updateStyleAttribute('texture', field, values, updateOptions);
       return this;
     }
-    this.sourceOption = {
-      data,
-      options
-    };
-    this.clusterZoom = 0;
-    return this;
-  }
-  setData(data, options) {
-    if (this.inited) {
-      this.layerSource.setData(data, options);
-    } else {
-      this.on("inited", () => {
-        const currentSource = this.getSource();
-        if (!currentSource) {
-          this.source(new import_l7_source.default(data, options));
-          this.sourceEvent();
-        } else {
-          this.layerSource.setData(data, options);
-        }
-      });
+  }, {
+    key: "rotate",
+    value: function rotate(field, values, updateOptions) {
+      this.updateStyleAttribute('rotate', field, values, updateOptions);
+      return this;
     }
-    return this;
-  }
-  style(options) {
-    const lastConfig = this.getLayerConfig();
-    const { passes, ...rest } = options;
-    if (passes) {
-      (0, import_multiPassRender.normalizePasses)(passes).forEach((pass) => {
-        const postProcessingPass = this.multiPassRenderer.getPostProcessor().getPostProcessingPassByName(pass[0]);
-        if (postProcessingPass) {
-          postProcessingPass.updateOptions(pass[1]);
-        }
-      });
+  }, {
+    key: "size",
+    value: function size(field, values, updateOptions) {
+      this.updateStyleAttribute('size', field, values, updateOptions);
+      return this;
+    } // 对mapping后的数据过滤，scale保持不变
+
+  }, {
+    key: "filter",
+    value: function filter(field, values, updateOptions) {
+      this.updateStyleAttribute('filter', field, values, updateOptions);
+      return this;
+    }
+  }, {
+    key: "shape",
+    value: function shape(field, values, updateOptions) {
+      var _this$styleAttributeS, _this$styleAttributeS2, _this$styleAttributeS3;
+
+      var lastShape = (_this$styleAttributeS = this.styleAttributeService) === null || _this$styleAttributeS === void 0 ? void 0 : (_this$styleAttributeS2 = _this$styleAttributeS.getLayerStyleAttribute('shape')) === null || _this$styleAttributeS2 === void 0 ? void 0 : (_this$styleAttributeS3 = _this$styleAttributeS2.scale) === null || _this$styleAttributeS3 === void 0 ? void 0 : _this$styleAttributeS3.field;
+      var currentShape = field;
+      this.shapeOption = {
+        field: field,
+        values: values
+      };
+      this.updateStyleAttribute('shape', field, values, updateOptions); // TODO: 根据 shape 判断是否需要更新 model
+
+      if (!this.tileLayer) {
+        (0, _updateShape.updateShape)(this, lastShape, currentShape);
+      }
+
+      return this;
     }
-    this.rawConfig = {
-      ...this.rawConfig,
-      ...rest
-    };
-    if (this.container) {
-      this.updateLayerConfig(this.rawConfig);
-      this.styleNeedUpdate = true;
-    }
-    if (lastConfig && lastConfig.mask === true && options.mask === false) {
-      this.clearModels();
-      this.layerModel.buildModels((models) => {
-        this.models = models;
+  }, {
+    key: "label",
+    value: function label(field, values, updateOptions) {
+      this.pendingStyleAttributes.push({
+        attributeName: 'label',
+        attributeField: field,
+        attributeValues: values,
+        updateOptions: updateOptions
       });
+      return this;
     }
-    return this;
-  }
-  scale(field, cfg) {
-    if ((0, import_lodash.isObject)(field)) {
-      this.scaleOptions = {
-        ...this.scaleOptions,
-        ...field
+  }, {
+    key: "animate",
+    value: function animate(options) {
+      var rawAnimate = {};
+
+      if ((0, _lodash.isObject)(options)) {
+        rawAnimate.enable = true;
+        rawAnimate = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, rawAnimate), options);
+      } else {
+        rawAnimate.enable = options;
+      }
+
+      this.updateLayerConfig({
+        animateOption: rawAnimate
+      }); // this.animateOptions = options;
+
+      return this;
+    }
+  }, {
+    key: "source",
+    value: function source(data, options) {
+      if (data !== null && data !== void 0 && data.data) {
+        // 判断是否为source
+        this.setSource(data);
+        return this;
+      }
+
+      this.sourceOption = {
+        data: data,
+        options: options
       };
-    } else {
-      this.scaleOptions[field] = cfg;
+      this.clusterZoom = 0;
+      return this;
     }
-    return this;
-  }
-  renderLayers() {
-    this.rendering = true;
-    this.layerService.renderLayers();
-    this.rendering = false;
-  }
-  render() {
-    if (this.tileLayer !== void 0) {
-      this.tileLayer.render();
+  }, {
+    key: "setData",
+    value: function setData(data, options) {
+      var _this4 = this;
+
+      if (this.inited) {
+        this.layerSource.setData(data, options);
+      } else {
+        this.on('inited', function () {
+          var currentSource = _this4.getSource();
+
+          if (!currentSource) {
+            // 执行 setData 的时候 source 还不存在（还未执行 addLayer）
+            _this4.source(new _l7Source.default(data, options));
+
+            _this4.sourceEvent();
+          } else {
+            _this4.layerSource.setData(data, options);
+          } // this.layerSource.setData(data, options);
+
+        });
+      }
+
       return this;
     }
-    if (this.getEncodedData() && this.getEncodedData().length !== 0) {
-      this.renderModels();
+  }, {
+    key: "style",
+    value: function style(options) {
+      var _this5 = this;
+
+      var lastConfig = this.getLayerConfig();
+      var passes = options.passes,
+          rest = (0, _objectWithoutProperties2.default)(options, _excluded); // passes 特殊处理
+
+      if (passes) {
+        (0, _multiPassRender.normalizePasses)(passes).forEach(function (pass) {
+          var postProcessingPass = _this5.multiPassRenderer.getPostProcessor().getPostProcessingPassByName(pass[0]);
+
+          if (postProcessingPass) {
+            postProcessingPass.updateOptions(pass[1]);
+          }
+        });
+      }
+
+      this.rawConfig = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, this.rawConfig), rest);
+
+      if (this.container) {
+        this.updateLayerConfig(this.rawConfig);
+        this.styleNeedUpdate = true;
+      } // @ts-ignore
+
+
+      if (lastConfig && lastConfig.mask === true && options.mask === false) {
+        this.clearModels();
+        this.layerModel.buildModels(function (models) {
+          _this5.models = models;
+        });
+      }
+
+      return this;
     }
-    return this;
-  }
-  async renderMultiPass() {
-    if (this.getEncodedData() && this.getEncodedData().length !== 0) {
-      if (this.multiPassRenderer && this.multiPassRenderer.getRenderFlag()) {
-        await this.multiPassRenderer.render();
-      } else if (this.multiPassRenderer) {
-        this.renderModels();
+  }, {
+    key: "scale",
+    value: function scale(field, cfg) {
+      if ((0, _lodash.isObject)(field)) {
+        this.scaleOptions = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, this.scaleOptions), field);
       } else {
+        this.scaleOptions[field] = cfg;
+      }
+
+      return this;
+    }
+    /**
+     * 渲染所有的图层
+     */
+
+  }, {
+    key: "renderLayers",
+    value: function renderLayers() {
+      this.rendering = true;
+      this.layerService.renderLayers();
+      this.rendering = false;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      if (this.tileLayer !== undefined) {
+        // 瓦片图层执行单独的 render 渲染队列
+        this.tileLayer.render();
+        return this;
+      } // TODO: this.getEncodedData().length !== 0 这个判断是为了解决在 2.5.x 引入数据纹理后产生的 空数据渲染导致 texture 超出上限问题
+
+
+      if (this.getEncodedData() && this.getEncodedData().length !== 0) {
         this.renderModels();
       }
+
+      return this;
     }
-  }
-  active(options) {
-    const activeOption = {};
-    activeOption.enableHighlight = (0, import_lodash.isObject)(options) ? true : options;
-    if ((0, import_lodash.isObject)(options)) {
-      activeOption.enableHighlight = true;
-      if (options.color) {
-        activeOption.highlightColor = options.color;
-      }
-      if (options.mix) {
-        activeOption.activeMix = options.mix;
-      }
-    } else {
-      activeOption.enableHighlight = !!options;
-    }
-    this.updateLayerConfig(activeOption);
-    return this;
-  }
-  setActive(id, options) {
-    if ((0, import_lodash.isObject)(id)) {
-      const { x = 0, y = 0 } = id;
+    /**
+     * renderMultiPass 专门用于渲染支持 multipass 的 layer
+     */
+
+  }, {
+    key: "renderMultiPass",
+    value: function () {
+      var _renderMultiPass = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(this.getEncodedData() && this.getEncodedData().length !== 0)) {
+                  _context.next = 7;
+                  break;
+                }
+
+                if (!(this.multiPassRenderer && this.multiPassRenderer.getRenderFlag())) {
+                  _context.next = 6;
+                  break;
+                }
+
+                _context.next = 4;
+                return this.multiPassRenderer.render();
+
+              case 4:
+                _context.next = 7;
+                break;
+
+              case 6:
+                if (this.multiPassRenderer) {
+                  // renderPass 触发的渲染
+                  this.renderModels();
+                } else {
+                  this.renderModels();
+                }
+
+              case 7:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function renderMultiPass() {
+        return _renderMultiPass.apply(this, arguments);
+      }
+
+      return renderMultiPass;
+    }()
+  }, {
+    key: "active",
+    value: function active(options) {
+      var activeOption = {};
+      activeOption.enableHighlight = (0, _lodash.isObject)(options) ? true : options;
+
+      if ((0, _lodash.isObject)(options)) {
+        activeOption.enableHighlight = true;
+
+        if (options.color) {
+          activeOption.highlightColor = options.color;
+        }
+
+        if (options.mix) {
+          activeOption.activeMix = options.mix;
+        }
+      } else {
+        activeOption.enableHighlight = !!options;
+      }
+
+      this.updateLayerConfig(activeOption);
+      return this;
+    }
+  }, {
+    key: "setActive",
+    value: function setActive(id, options) {
+      var _this6 = this;
+
+      if ((0, _lodash.isObject)(id)) {
+        var _id$x = id.x,
+            x = _id$x === void 0 ? 0 : _id$x,
+            _id$y = id.y,
+            y = _id$y === void 0 ? 0 : _id$y;
+        this.updateLayerConfig({
+          highlightColor: (0, _lodash.isObject)(options) ? options.color : this.getLayerConfig().highlightColor,
+          activeMix: (0, _lodash.isObject)(options) ? options.mix : this.getLayerConfig().activeMix
+        });
+        this.pick({
+          x: x,
+          y: y
+        });
+      } else {
+        this.updateLayerConfig({
+          pickedFeatureID: id,
+          highlightColor: (0, _lodash.isObject)(options) ? options.color : this.getLayerConfig().highlightColor,
+          activeMix: (0, _lodash.isObject)(options) ? options.mix : this.getLayerConfig().activeMix
+        });
+        this.hooks.beforeSelect.call((0, _l7Utils.encodePickingColor)(id)) // @ts-ignore
+        .then(function () {
+          setTimeout(function () {
+            _this6.reRender();
+          }, 1);
+        });
+      }
+    }
+  }, {
+    key: "select",
+    value: function select(option) {
+      var activeOption = {};
+      activeOption.enableSelect = (0, _lodash.isObject)(option) ? true : option;
+
+      if ((0, _lodash.isObject)(option)) {
+        activeOption.enableSelect = true;
+
+        if (option.color) {
+          activeOption.selectColor = option.color;
+        }
+
+        if (option.mix) {
+          activeOption.selectMix = option.mix;
+        }
+      } else {
+        activeOption.enableSelect = !!option;
+      }
+
+      this.updateLayerConfig(activeOption);
+      return this;
+    }
+  }, {
+    key: "setSelect",
+    value: function setSelect(id, options) {
+      var _this7 = this;
+
+      if ((0, _lodash.isObject)(id)) {
+        var _id$x2 = id.x,
+            x = _id$x2 === void 0 ? 0 : _id$x2,
+            _id$y2 = id.y,
+            y = _id$y2 === void 0 ? 0 : _id$y2;
+        this.updateLayerConfig({
+          selectColor: (0, _lodash.isObject)(options) ? options.color : this.getLayerConfig().selectColor,
+          selectMix: (0, _lodash.isObject)(options) ? options.mix : this.getLayerConfig().selectMix
+        });
+        this.pick({
+          x: x,
+          y: y
+        });
+      } else {
+        this.updateLayerConfig({
+          pickedFeatureID: id,
+          selectColor: (0, _lodash.isObject)(options) ? options.color : this.getLayerConfig().selectColor,
+          selectMix: (0, _lodash.isObject)(options) ? options.mix : this.getLayerConfig().selectMix
+        });
+        this.hooks.beforeSelect.call((0, _l7Utils.encodePickingColor)(id)) // @ts-ignore
+        .then(function () {
+          setTimeout(function () {
+            _this7.reRender();
+          }, 1);
+        });
+      }
+    }
+  }, {
+    key: "setBlend",
+    value: function setBlend(type) {
       this.updateLayerConfig({
-        highlightColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().highlightColor,
-        activeMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().activeMix
+        blend: type
       });
-      this.pick({ x, y });
-    } else {
+      this.layerModelNeedUpdate = true;
+      this.reRender();
+      return this;
+    }
+  }, {
+    key: "show",
+    value: function show() {
       this.updateLayerConfig({
-        pickedFeatureID: id,
-        highlightColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().highlightColor,
-        activeMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().activeMix
-      });
-      this.hooks.beforeSelect.call((0, import_l7_utils.encodePickingColor)(id)).then(() => {
-        setTimeout(() => {
-          this.reRender();
-        }, 1);
+        visible: true
       });
+      this.reRender();
+      return this;
     }
-  }
-  select(option) {
-    const activeOption = {};
-    activeOption.enableSelect = (0, import_lodash.isObject)(option) ? true : option;
-    if ((0, import_lodash.isObject)(option)) {
-      activeOption.enableSelect = true;
-      if (option.color) {
-        activeOption.selectColor = option.color;
-      }
-      if (option.mix) {
-        activeOption.selectMix = option.mix;
-      }
-    } else {
-      activeOption.enableSelect = !!option;
-    }
-    this.updateLayerConfig(activeOption);
-    return this;
-  }
-  setSelect(id, options) {
-    if ((0, import_lodash.isObject)(id)) {
-      const { x = 0, y = 0 } = id;
+  }, {
+    key: "hide",
+    value: function hide() {
+      if (this.type === 'CanvasLayer' && this.layerModel.clearCanvas) {
+        // 对 canvasLayer 的 hide 操作做特殊处理
+        this.layerModel.clearCanvas();
+      }
+
       this.updateLayerConfig({
-        selectColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().selectColor,
-        selectMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().selectMix
+        visible: false
       });
-      this.pick({ x, y });
-    } else {
+      this.reRender();
+      return this;
+    }
+  }, {
+    key: "setIndex",
+    value: function setIndex(index) {
+      this.zIndex = index;
+      this.layerService.updateLayerRenderList();
+      this.layerService.renderLayers();
+      return this;
+    }
+  }, {
+    key: "setCurrentPickId",
+    value: function setCurrentPickId(id) {
+      this.currentPickId = id;
+    }
+  }, {
+    key: "getCurrentPickId",
+    value: function getCurrentPickId() {
+      return this.currentPickId;
+    }
+  }, {
+    key: "setCurrentSelectedId",
+    value: function setCurrentSelectedId(id) {
+      this.selectedFeatureID = id;
+    }
+  }, {
+    key: "getCurrentSelectedId",
+    value: function getCurrentSelectedId() {
+      return this.selectedFeatureID;
+    }
+  }, {
+    key: "isVisible",
+    value: function isVisible() {
+      var zoom = this.mapService.getZoom();
+
+      var _this$getLayerConfig3 = this.getLayerConfig(),
+          visible = _this$getLayerConfig3.visible,
+          _this$getLayerConfig4 = _this$getLayerConfig3.minZoom,
+          minZoom = _this$getLayerConfig4 === void 0 ? -Infinity : _this$getLayerConfig4,
+          _this$getLayerConfig5 = _this$getLayerConfig3.maxZoom,
+          maxZoom = _this$getLayerConfig5 === void 0 ? Infinity : _this$getLayerConfig5;
+
+      return !!visible && zoom >= minZoom && zoom <= maxZoom;
+    }
+  }, {
+    key: "setMultiPass",
+    value: function setMultiPass(enableMultiPass, currentPasses) {
       this.updateLayerConfig({
-        pickedFeatureID: id,
-        selectColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().selectColor,
-        selectMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().selectMix
+        enableMultiPassRenderer: enableMultiPass
       });
-      this.hooks.beforeSelect.call((0, import_l7_utils.encodePickingColor)(id)).then(() => {
-        setTimeout(() => {
-          this.reRender();
-        }, 1);
+
+      if (currentPasses) {
+        this.updateLayerConfig({
+          passes: currentPasses
+        });
+      }
+
+      if (enableMultiPass) {
+        var _this$getLayerConfig6 = this.getLayerConfig(),
+            _this$getLayerConfig7 = _this$getLayerConfig6.passes,
+            passes = _this$getLayerConfig7 === void 0 ? [] : _this$getLayerConfig7;
+
+        this.multiPassRenderer = (0, _multiPassRender.createMultiPassRenderer)(this, passes, this.postProcessingPassFactory, this.normalPassFactory);
+        this.multiPassRenderer.setRenderFlag(true);
+
+        var _this$rendererService = this.rendererService.getViewportSize(),
+            width = _this$rendererService.width,
+            height = _this$rendererService.height;
+
+        this.multiPassRenderer.resize(width, height);
+      }
+
+      return this;
+    }
+  }, {
+    key: "setMinZoom",
+    value: function setMinZoom(minZoom) {
+      this.updateLayerConfig({
+        minZoom: minZoom
       });
+      return this;
     }
-  }
-  setBlend(type) {
-    this.updateLayerConfig({
-      blend: type
-    });
-    this.layerModelNeedUpdate = true;
-    this.reRender();
-    return this;
-  }
-  show() {
-    this.updateLayerConfig({
-      visible: true
-    });
-    this.reRender();
-    return this;
-  }
-  hide() {
-    if (this.type === "CanvasLayer" && this.layerModel.clearCanvas) {
-      this.layerModel.clearCanvas();
+  }, {
+    key: "getMinZoom",
+    value: function getMinZoom() {
+      var _this$getLayerConfig8 = this.getLayerConfig(),
+          minZoom = _this$getLayerConfig8.minZoom;
+
+      return minZoom;
     }
-    this.updateLayerConfig({
-      visible: false
-    });
-    this.reRender();
-    return this;
-  }
-  setIndex(index) {
-    this.zIndex = index;
-    this.layerService.updateLayerRenderList();
-    this.layerService.renderLayers();
-    return this;
-  }
-  setCurrentPickId(id) {
-    this.currentPickId = id;
-  }
-  getCurrentPickId() {
-    return this.currentPickId;
-  }
-  setCurrentSelectedId(id) {
-    this.selectedFeatureID = id;
-  }
-  getCurrentSelectedId() {
-    return this.selectedFeatureID;
-  }
-  isVisible() {
-    const zoom = this.mapService.getZoom();
-    const {
-      visible,
-      minZoom = -Infinity,
-      maxZoom = Infinity
-    } = this.getLayerConfig();
-    return !!visible && zoom >= minZoom && zoom <= maxZoom;
-  }
-  setMultiPass(enableMultiPass, currentPasses) {
-    this.updateLayerConfig({
-      enableMultiPassRenderer: enableMultiPass
-    });
-    if (currentPasses) {
+  }, {
+    key: "getMaxZoom",
+    value: function getMaxZoom() {
+      var _this$getLayerConfig9 = this.getLayerConfig(),
+          maxZoom = _this$getLayerConfig9.maxZoom;
+
+      return maxZoom;
+    }
+  }, {
+    key: "get",
+    value: function get(name) {
+      var cfg = this.getLayerConfig(); // @ts-ignore
+
+      return cfg[name];
+    }
+  }, {
+    key: "setMaxZoom",
+    value: function setMaxZoom(maxZoom) {
       this.updateLayerConfig({
-        passes: currentPasses
+        maxZoom: maxZoom
       });
+      return this;
     }
-    if (enableMultiPass) {
-      const { passes = [] } = this.getLayerConfig();
-      this.multiPassRenderer = (0, import_multiPassRender.createMultiPassRenderer)(this, passes, this.postProcessingPassFactory, this.normalPassFactory);
-      this.multiPassRenderer.setRenderFlag(true);
-      const { width, height } = this.rendererService.getViewportSize();
-      this.multiPassRenderer.resize(width, height);
-    }
-    return this;
-  }
-  setMinZoom(minZoom) {
-    this.updateLayerConfig({
-      minZoom
-    });
-    return this;
-  }
-  getMinZoom() {
-    const { minZoom } = this.getLayerConfig();
-    return minZoom;
-  }
-  getMaxZoom() {
-    const { maxZoom } = this.getLayerConfig();
-    return maxZoom;
-  }
-  get(name) {
-    const cfg = this.getLayerConfig();
-    return cfg[name];
-  }
-  setMaxZoom(maxZoom) {
-    this.updateLayerConfig({
-      maxZoom
-    });
-    return this;
-  }
-  setAutoFit(autoFit) {
-    this.updateLayerConfig({
-      autoFit
-    });
-    return this;
-  }
-  fitBounds(fitBoundsOptions) {
-    if (!this.inited) {
+  }, {
+    key: "setAutoFit",
+    value: function setAutoFit(autoFit) {
       this.updateLayerConfig({
-        autoFit: true
+        autoFit: autoFit
       });
       return this;
     }
-    const source = this.getSource();
-    const extent = source.extent;
-    const isValid = extent.some((v) => Math.abs(v) === Infinity);
-    if (isValid) {
+    /**
+     * zoom to layer Bounds
+     */
+
+  }, {
+    key: "fitBounds",
+    value: function fitBounds(fitBoundsOptions) {
+      if (!this.inited) {
+        this.updateLayerConfig({
+          autoFit: true
+        });
+        return this;
+      }
+
+      var source = this.getSource();
+      var extent = source.extent;
+      var isValid = extent.some(function (v) {
+        return Math.abs(v) === Infinity;
+      });
+
+      if (isValid) {
+        return this;
+      }
+
+      this.mapService.fitBounds([[extent[0], extent[1]], [extent[2], extent[3]]], fitBoundsOptions);
       return this;
     }
-    this.mapService.fitBounds([
-      [extent[0], extent[1]],
-      [extent[2], extent[3]]
-    ], fitBoundsOptions);
-    return this;
-  }
-  destroy(refresh = true) {
-    var _a;
-    if (this.isDestroied) {
-      return;
-    }
-    this.layerChildren.map((child) => child.destroy());
-    this.layerChildren = [];
-    this.masks.map((mask) => mask.destroy());
-    this.masks = [];
-    this.hooks.beforeDestroy.call();
-    this.layerSource.off("sourceUpdate", this.sourceEvent);
-    this.multiPassRenderer.destroy();
-    this.styleAttributeService.clearAllAttributes();
-    this.hooks.afterDestroy.call();
-    (_a = this.layerModel) == null ? void 0 : _a.clearModels();
-    this.models = [];
-    this.layerService.cleanRemove(this, refresh);
-    this.emit("remove", {
-      target: this,
-      type: "remove"
-    });
-    this.emit("destroy", {
-      target: this,
-      type: "destroy"
-    });
-    this.removeAllListeners();
-    this.isDestroied = true;
-  }
-  clear() {
-    this.styleAttributeService.clearAllAttributes();
-  }
-  clearModels() {
-    var _a;
-    this.models.forEach((model) => model.destroy());
-    (_a = this.layerModel) == null ? void 0 : _a.clearModels();
-    this.models = [];
-  }
-  isDirty() {
-    return !!(this.styleAttributeService.getLayerStyleAttributes() || []).filter((attribute) => attribute.needRescale || attribute.needRemapping || attribute.needRegenerateVertices).length;
-  }
-  setSource(source) {
-    if (this.layerSource) {
-      this.layerSource.off("sourceUpdate", this.sourceEvent);
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this$layerModel2;
+
+      var refresh = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+      if (this.isDestroied) {
+        return;
+      } // remove child layer
+
+
+      this.layerChildren.map(function (child) {
+        return child.destroy();
+      });
+      this.layerChildren = []; // remove mask list
+
+      this.masks.map(function (mask) {
+        return mask.destroy();
+      });
+      this.masks = [];
+      this.hooks.beforeDestroy.call(); // 清除sources事件
+
+      this.layerSource.off('sourceUpdate', this.sourceEvent);
+      this.multiPassRenderer.destroy(); // console.log(this.styleAttributeService.getAttributes())
+      // 清除所有属性以及关联的 vao == 销毁所有 => model this.models.forEach((model) => model.destroy());
+
+      this.styleAttributeService.clearAllAttributes(); // 执行每个图层单独的 clearModels 方法 （清除一些额外的 texture、program、buffer 等）
+
+      this.hooks.afterDestroy.call(); // TODO: 清除各个图层自定义的 models 资源
+
+      (_this$layerModel2 = this.layerModel) === null || _this$layerModel2 === void 0 ? void 0 : _this$layerModel2.clearModels();
+      this.models = [];
+      this.layerService.cleanRemove(this, refresh);
+      this.emit('remove', {
+        target: this,
+        type: 'remove'
+      });
+      this.emit('destroy', {
+        target: this,
+        type: 'destroy'
+      });
+      this.removeAllListeners(); // 解绑图层容器中的服务
+      // this.container.unbind(TYPES.IStyleAttributeService);
+
+      this.isDestroied = true;
     }
-    this.layerSource = source;
-    this.clusterZoom = 0;
-    if (this.inited && this.layerSource.cluster) {
-      const zoom = this.mapService.getZoom();
-      this.layerSource.updateClusterData(zoom);
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.styleAttributeService.clearAllAttributes(); // 销毁所有 model
     }
-    if (this.layerSource.inited) {
-      this.sourceEvent();
+  }, {
+    key: "clearModels",
+    value: function clearModels() {
+      var _this$layerModel3;
+
+      this.models.forEach(function (model) {
+        return model.destroy();
+      });
+      (_this$layerModel3 = this.layerModel) === null || _this$layerModel3 === void 0 ? void 0 : _this$layerModel3.clearModels();
+      this.models = [];
     }
-    this.layerSource.on("sourceUpdate", () => {
-      this.sourceEvent();
-    });
-  }
-  getSource() {
-    return this.layerSource;
-  }
-  getScaleOptions() {
-    return this.scaleOptions;
-  }
-  setEncodedData(encodedData) {
-    this.encodedData = encodedData;
-  }
-  getEncodedData() {
-    return this.encodedData;
-  }
-  getScale(name) {
-    return this.styleAttributeService.getLayerAttributeScale(name);
-  }
-  getLegendItems(name) {
-    const scale = this.styleAttributeService.getLayerAttributeScale(name);
-    if (!scale) {
-      return [];
+  }, {
+    key: "isDirty",
+    value: function isDirty() {
+      return !!(this.styleAttributeService.getLayerStyleAttributes() || []).filter(function (attribute) {
+        return attribute.needRescale || attribute.needRemapping || attribute.needRegenerateVertices;
+      }).length;
     }
-    if (scale.invertExtent) {
-      const items = scale.range().map((item) => {
-        return {
-          value: scale.invertExtent(item),
-          [name]: item
-        };
-      });
-      return items;
-    } else if (scale.ticks) {
-      const items = scale.ticks().map((item) => {
-        return {
-          value: item,
-          [name]: scale(item)
-        };
+  }, {
+    key: "setSource",
+    value: function setSource(source) {
+      var _this8 = this;
+
+      // 清除旧 sources 事件
+      if (this.layerSource) {
+        this.layerSource.off('sourceUpdate', this.sourceEvent);
+      }
+
+      this.layerSource = source;
+      this.clusterZoom = 0; // 已 inited 且启用聚合进行更新聚合数据
+
+      if (this.inited && this.layerSource.cluster) {
+        var zoom = this.mapService.getZoom();
+        this.layerSource.updateClusterData(zoom);
+      } // source 可能会复用，会在其它layer被修改
+
+
+      if (this.layerSource.inited) {
+        this.sourceEvent();
+      } // this.layerSource.inited 为 true 后，sourceUpdate 事件不会再触发
+
+
+      this.layerSource.on('sourceUpdate', function () {
+        _this8.sourceEvent();
       });
-      return items;
-    } else if (scale == null ? void 0 : scale.domain) {
-      const items = scale.domain().filter((item) => !(0, import_lodash.isUndefined)(item)).map((item) => {
-        return {
-          value: item,
-          [name]: scale(item)
-        };
+    }
+  }, {
+    key: "getSource",
+    value: function getSource() {
+      return this.layerSource;
+    }
+  }, {
+    key: "getScaleOptions",
+    value: function getScaleOptions() {
+      return this.scaleOptions;
+    }
+  }, {
+    key: "setEncodedData",
+    value: function setEncodedData(encodedData) {
+      this.encodedData = encodedData;
+    }
+  }, {
+    key: "getEncodedData",
+    value: function getEncodedData() {
+      return this.encodedData;
+    }
+  }, {
+    key: "getScale",
+    value: function getScale(name) {
+      return this.styleAttributeService.getLayerAttributeScale(name);
+    }
+  }, {
+    key: "getLegendItems",
+    value: function getLegendItems(name) {
+      var scale = this.styleAttributeService.getLayerAttributeScale(name); // 函数自定义映射，没有 scale 返回为空数组
+
+      if (!scale) {
+        return [];
+      }
+
+      if (scale.invertExtent) {
+        // 分段类型  Quantize、Quantile、Threshold
+        var items = scale.range().map(function (item) {
+          return (0, _defineProperty2.default)({
+            value: scale.invertExtent(item)
+          }, name, item);
+        });
+        return items;
+      } else if (scale.ticks) {
+        // 连续类型 Continuous (Linear, Power, Log, Identity, Time)
+        var _items = scale.ticks().map(function (item) {
+          return (0, _defineProperty2.default)({
+            value: item
+          }, name, scale(item));
+        });
+
+        return _items;
+      } else if (scale !== null && scale !== void 0 && scale.domain) {
+        // 枚举类型 Cat
+        var _items2 = scale.domain().filter(function (item) {
+          return !(0, _lodash.isUndefined)(item);
+        }).map(function (item) {
+          return (0, _defineProperty2.default)({
+            value: item
+          }, name, scale(item));
+        });
+
+        return _items2;
+      }
+
+      return [];
+    }
+  }, {
+    key: "pick",
+    value: function pick(_ref6) {
+      var x = _ref6.x,
+          y = _ref6.y;
+      this.interactionService.triggerHover({
+        x: x,
+        y: y
       });
-      return items;
     }
-    return [];
-  }
-  pick({ x, y }) {
-    this.interactionService.triggerHover({ x, y });
-  }
-  boxSelect(box, cb) {
-    this.pickingService.boxPickLayer(this, box, cb);
-  }
-  buildLayerModel(options) {
-    const {
-      moduleName,
-      vertexShader,
-      fragmentShader,
-      triangulation,
-      segmentNumber,
-      workerEnabled = false,
-      workerOptions,
-      ...rest
-    } = options;
-    this.shaderModuleService.registerModule(moduleName, {
-      vs: vertexShader,
-      fs: fragmentShader
-    });
-    const { vs, fs, uniforms } = this.shaderModuleService.getModule(moduleName);
-    const { createModel } = this.rendererService;
-    return new Promise((resolve, reject) => {
-      if (workerOptions && workerOptions.modelType in import_l7_utils.WorkerSourceMap && workerEnabled) {
-        this.styleAttributeService.createAttributesAndIndicesAscy(this.encodedData, segmentNumber, workerOptions).then(({ attributes, elements }) => {
-          const m = createModel({
-            attributes,
-            uniforms,
-            fs,
-            vs,
-            elements,
-            blend: import_blend.BlendTypes[import_l7_core.BlendType.normal],
-            ...rest
+  }, {
+    key: "boxSelect",
+    value: function boxSelect(box, cb) {
+      this.pickingService.boxPickLayer(this, box, cb);
+    }
+  }, {
+    key: "buildLayerModel",
+    value: function buildLayerModel(options) {
+      var _this9 = this;
+
+      var moduleName = options.moduleName,
+          vertexShader = options.vertexShader,
+          fragmentShader = options.fragmentShader,
+          triangulation = options.triangulation,
+          segmentNumber = options.segmentNumber,
+          _options$workerEnable = options.workerEnabled,
+          workerEnabled = _options$workerEnable === void 0 ? false : _options$workerEnable,
+          workerOptions = options.workerOptions,
+          rest = (0, _objectWithoutProperties2.default)(options, _excluded2);
+      this.shaderModuleService.registerModule(moduleName, {
+        vs: vertexShader,
+        fs: fragmentShader
+      });
+
+      var _this$shaderModuleSer = this.shaderModuleService.getModule(moduleName),
+          vs = _this$shaderModuleSer.vs,
+          fs = _this$shaderModuleSer.fs,
+          uniforms = _this$shaderModuleSer.uniforms;
+
+      var createModel = this.rendererService.createModel;
+      return new Promise(function (resolve, reject) {
+        // filter supported worker & worker enabled layer
+        if (workerOptions && workerOptions.modelType in _l7Utils.WorkerSourceMap && workerEnabled) {
+          _this9.styleAttributeService.createAttributesAndIndicesAscy(_this9.encodedData, segmentNumber, workerOptions).then(function (_ref7) {
+            var attributes = _ref7.attributes,
+                elements = _ref7.elements;
+            var m = createModel((0, _objectSpread2.default)({
+              attributes: attributes,
+              uniforms: uniforms,
+              fs: fs,
+              vs: vs,
+              elements: elements,
+              blend: _blend.BlendTypes[_l7Core.BlendType.normal]
+            }, rest));
+            resolve(m);
+          }).catch(function (err) {
+            return reject(err);
           });
+        } else {
+          var _this9$styleAttribute = _this9.styleAttributeService.createAttributesAndIndices(_this9.encodedData, triangulation, segmentNumber),
+              attributes = _this9$styleAttribute.attributes,
+              elements = _this9$styleAttribute.elements,
+              count = _this9$styleAttribute.count;
+
+          var modeloptions = (0, _objectSpread2.default)({
+            attributes: attributes,
+            uniforms: uniforms,
+            fs: fs,
+            vs: vs,
+            elements: elements,
+            blend: _blend.BlendTypes[_l7Core.BlendType.normal]
+          }, rest);
+
+          if (count) {
+            modeloptions.count = count;
+          }
+
+          var m = createModel(modeloptions);
           resolve(m);
-        }).catch((err) => reject(err));
-      } else {
-        const {
-          attributes,
-          elements,
-          count
-        } = this.styleAttributeService.createAttributesAndIndices(this.encodedData, triangulation, segmentNumber);
-        const modeloptions = {
-          attributes,
-          uniforms,
-          fs,
-          vs,
-          elements,
-          blend: import_blend.BlendTypes[import_l7_core.BlendType.normal],
-          ...rest
-        };
-        if (count) {
-          modeloptions.count = count;
-        }
-        const m = createModel(modeloptions);
-        resolve(m);
-      }
-    });
-  }
-  createAttrubutes(options) {
-    const { triangulation } = options;
-    const { attributes } = this.styleAttributeService.createAttributes(this.encodedData, triangulation);
-    return attributes;
-  }
-  getTime() {
-    return this.layerService.clock.getDelta();
-  }
-  setAnimateStartTime() {
-    this.animateStartTime = this.layerService.clock.getElapsedTime();
-  }
-  stopAnimate() {
-    if (this.aniamateStatus) {
-      this.layerService.stopAnimate();
-      this.aniamateStatus = false;
-      this.updateLayerConfig({
-        animateOption: {
-          enable: false
         }
       });
     }
-  }
-  getLayerAnimateTime() {
-    return this.layerService.clock.getElapsedTime() - this.animateStartTime;
-  }
-  needPick(type) {
-    const {
-      enableHighlight = true,
-      enableSelect = true
-    } = this.getLayerConfig();
-    let isPick = this.eventNames().indexOf(type) !== -1 || this.eventNames().indexOf("un" + type) !== -1;
-    if ((type === "click" || type === "dblclick") && enableSelect) {
-      isPick = true;
-    }
-    if (type === "mousemove" && (enableHighlight || this.eventNames().indexOf("mouseenter") !== -1 || this.eventNames().indexOf("unmousemove") !== -1 || this.eventNames().indexOf("mouseout") !== -1)) {
-      isPick = true;
-    }
-    return this.isVisible() && isPick;
-  }
-  buildModels() {
-    throw new Error("Method not implemented.");
-  }
-  rebuildModels() {
-    throw new Error("Method not implemented.");
-  }
-  async renderMulPass(multiPassRenderer) {
-    await multiPassRenderer.render();
-  }
-  renderModels(isPicking) {
-    var _a;
-    if (this.getEncodedData() && this.getEncodedData().length > 0) {
-      if (this.layerModelNeedUpdate && this.layerModel) {
-        this.layerModel.buildModels((models) => {
-          this.models = models;
-          this.hooks.beforeRender.call();
-          this.layerModelNeedUpdate = false;
+  }, {
+    key: "createAttrubutes",
+    value: function createAttrubutes(options) {
+      var triangulation = options.triangulation; // @ts-ignore
+
+      var _this$styleAttributeS4 = this.styleAttributeService.createAttributes(this.encodedData, triangulation),
+          attributes = _this$styleAttributeS4.attributes;
+
+      return attributes;
+    }
+  }, {
+    key: "getTime",
+    value: function getTime() {
+      return this.layerService.clock.getDelta();
+    }
+  }, {
+    key: "setAnimateStartTime",
+    value: function setAnimateStartTime() {
+      this.animateStartTime = this.layerService.clock.getElapsedTime();
+    }
+  }, {
+    key: "stopAnimate",
+    value: function stopAnimate() {
+      if (this.aniamateStatus) {
+        this.layerService.stopAnimate();
+        this.aniamateStatus = false;
+        this.updateLayerConfig({
+          animateOption: {
+            enable: false
+          }
         });
       }
-      if ((_a = this == null ? void 0 : this.layerModel) == null ? void 0 : _a.renderUpdate) {
-        this.layerModel.renderUpdate();
+    }
+  }, {
+    key: "getLayerAnimateTime",
+    value: function getLayerAnimateTime() {
+      return this.layerService.clock.getElapsedTime() - this.animateStartTime;
+    }
+  }, {
+    key: "needPick",
+    value: function needPick(type) {
+      var _this$getLayerConfig10 = this.getLayerConfig(),
+          _this$getLayerConfig11 = _this$getLayerConfig10.enableHighlight,
+          enableHighlight = _this$getLayerConfig11 === void 0 ? true : _this$getLayerConfig11,
+          _this$getLayerConfig12 = _this$getLayerConfig10.enableSelect,
+          enableSelect = _this$getLayerConfig12 === void 0 ? true : _this$getLayerConfig12; // 判断layer是否监听事件;
+
+
+      var isPick = this.eventNames().indexOf(type) !== -1 || this.eventNames().indexOf('un' + type) !== -1;
+
+      if ((type === 'click' || type === 'dblclick') && enableSelect) {
+        isPick = true;
+      }
+
+      if (type === 'mousemove' && (enableHighlight || this.eventNames().indexOf('mouseenter') !== -1 || this.eventNames().indexOf('unmousemove') !== -1 || this.eventNames().indexOf('mouseout') !== -1)) {
+        isPick = true;
       }
-      this.models.forEach((model) => {
-        model.draw({
-          uniforms: this.layerModel.getUninforms()
-        }, isPicking);
-      });
+
+      return this.isVisible() && isPick;
     }
-    return this;
-  }
-  updateStyleAttribute(type, field, values, updateOptions) {
-    if (!this.inited) {
-      this.pendingStyleAttributes.push({
-        attributeName: type,
-        attributeField: field,
-        attributeValues: values,
-        updateOptions
-      });
-    } else {
-      this.styleAttributeService.updateStyleAttribute(type, {
-        scale: {
-          field,
-          ...this.splitValuesAndCallbackInAttribute(values, this.getLayerConfig()[field])
+  }, {
+    key: "buildModels",
+    value: function buildModels() {
+      throw new Error('Method not implemented.');
+    }
+  }, {
+    key: "rebuildModels",
+    value: function rebuildModels() {
+      throw new Error('Method not implemented.');
+    }
+  }, {
+    key: "renderMulPass",
+    value: function () {
+      var _renderMulPass = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(multiPassRenderer) {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return multiPassRenderer.render();
+
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function renderMulPass(_x) {
+        return _renderMulPass.apply(this, arguments);
+      }
+
+      return renderMulPass;
+    }()
+  }, {
+    key: "renderModels",
+    value: function renderModels(isPicking) {
+      var _this10 = this;
+
+      // TODO: this.getEncodedData().length > 0 这个判断是为了解决在 2.5.x 引入数据纹理后产生的 空数据渲染导致 texture 超出上限问题
+      if (this.getEncodedData() && this.getEncodedData().length > 0) {
+        var _this$layerModel4;
+
+        if (this.layerModelNeedUpdate && this.layerModel) {
+          this.layerModel.buildModels(function (models) {
+            _this10.models = models;
+
+            _this10.hooks.beforeRender.call();
+
+            _this10.layerModelNeedUpdate = false;
+          });
         }
-      }, updateOptions);
+
+        if (this !== null && this !== void 0 && (_this$layerModel4 = this.layerModel) !== null && _this$layerModel4 !== void 0 && _this$layerModel4.renderUpdate) {
+          this.layerModel.renderUpdate();
+        }
+
+        this.models.forEach(function (model) {
+          model.draw({
+            uniforms: _this10.layerModel.getUninforms()
+          }, isPicking);
+        });
+      }
+
+      return this;
     }
-  }
-  getShaderPickStat() {
-    return this.layerService.getShaderPickStat();
-  }
-  setEarthTime(time) {
-    console.warn("empty fn");
-  }
-  getConfigSchema() {
-    throw new Error("Method not implemented.");
-  }
-  getModelType() {
-    throw new Error("Method not implemented.");
-  }
-  getDefaultConfig() {
-    return {};
-  }
-  reRender() {
-    if (this.inited) {
-      this.layerService.updateLayerRenderList();
-      this.layerService.renderLayers();
+  }, {
+    key: "updateStyleAttribute",
+    value: function updateStyleAttribute(type, field, values, updateOptions) {
+      if (!this.inited) {
+        this.pendingStyleAttributes.push({
+          attributeName: type,
+          attributeField: field,
+          attributeValues: values,
+          updateOptions: updateOptions
+        });
+      } else {
+        this.styleAttributeService.updateStyleAttribute(type, {
+          // @ts-ignore
+          scale: (0, _objectSpread2.default)({
+            field: field
+          }, this.splitValuesAndCallbackInAttribute( // @ts-ignore
+          values, // @ts-ignore
+          this.getLayerConfig()[field]))
+        }, // @ts-ignore
+        updateOptions);
+      }
     }
-  }
-  splitValuesAndCallbackInAttribute(valuesOrCallback, defaultValues) {
-    return {
-      values: (0, import_lodash.isFunction)(valuesOrCallback) ? void 0 : valuesOrCallback || defaultValues,
-      callback: (0, import_lodash.isFunction)(valuesOrCallback) ? valuesOrCallback : void 0
-    };
-  }
-};
-__decorateClass([
-  (0, import_l7_core.lazyInject)(import_l7_core.TYPES.IGlobalConfigService)
-], BaseLayer.prototype, "configService", 2);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+  }, {
+    key: "getShaderPickStat",
+    value: function getShaderPickStat() {
+      return this.layerService.getShaderPickStat();
+    }
+    /**
+     * 继承空方法
+     * @param time
+     */
+
+  }, {
+    key: "setEarthTime",
+    value: function setEarthTime(time) {
+      console.warn('empty fn');
+    }
+  }, {
+    key: "getConfigSchema",
+    value: function getConfigSchema() {
+      throw new Error('Method not implemented.');
+    }
+  }, {
+    key: "getModelType",
+    value: function getModelType() {
+      throw new Error('Method not implemented.');
+    }
+  }, {
+    key: "getDefaultConfig",
+    value: function getDefaultConfig() {
+      return {};
+    }
+  }, {
+    key: "reRender",
+    value: function reRender() {
+      if (this.inited) {
+        this.layerService.updateLayerRenderList();
+        this.layerService.renderLayers();
+      }
+    }
+  }, {
+    key: "splitValuesAndCallbackInAttribute",
+    value: function splitValuesAndCallbackInAttribute(valuesOrCallback, defaultValues) {
+      return {
+        values: (0, _lodash.isFunction)(valuesOrCallback) ? undefined : valuesOrCallback || defaultValues,
+        callback: (0, _lodash.isFunction)(valuesOrCallback) ? valuesOrCallback : undefined
+      };
+    }
+  }]);
+  return BaseLayer;
+}(_eventemitter.EventEmitter), (_descriptor = (0, _applyDecoratedDescriptor2.default)(_class.prototype, "configService", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class));
+exports.default = BaseLayer;