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

package/es/core/BaseLayer.js

@@ -0,0 +1,1409 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _initializerDefineProperty from "@babel/runtime/helpers/initializerDefineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _applyDecoratedDescriptor from "@babel/runtime/helpers/applyDecoratedDescriptor";
+import _initializerWarningHelper from "@babel/runtime/helpers/initializerWarningHelper";
+var _excluded = ["passes"],
+    _excluded2 = ["moduleName", "vertexShader", "fragmentShader", "triangulation", "segmentNumber", "workerEnabled", "workerOptions"];
+
+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); }
+
+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 = _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); }; }
+
+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; } }
+
+// @ts-ignore
+import { SyncBailHook, SyncHook, SyncWaterfallHook } from '@antv/async-hook';
+import { BlendType, lazyInject, TYPES } from '@antv/l7-core';
+import Source from '@antv/l7-source';
+import { encodePickingColor, WorkerSourceMap } from '@antv/l7-utils';
+import { EventEmitter } from 'eventemitter3';
+import { isFunction, isObject, isUndefined } from 'lodash';
+import { BlendTypes } from "../utils/blend";
+import { handleStyleDataMapping } from "../utils/dataMappingStyle";
+import { calculateData } from "../utils/layerData";
+import { createMultiPassRenderer, normalizePasses } from "../utils/multiPassRender";
+import { updateShape } from "../utils/updateShape";
+/**
+ * 分配 layer id
+ */
+
+var layerIdCounter = 0;
+var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__PURE__*/function (_ref) {
+  _inherits(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] : {};
+
+    _classCallCheck(this, BaseLayer);
+
+    _this = _super.call(this);
+
+    _defineProperty(_assertThisInitialized(_this), "id", "".concat(layerIdCounter++));
+
+    _defineProperty(_assertThisInitialized(_this), "name", "".concat(layerIdCounter));
+
+    _defineProperty(_assertThisInitialized(_this), "visible", true);
+
+    _defineProperty(_assertThisInitialized(_this), "zIndex", 0);
+
+    _defineProperty(_assertThisInitialized(_this), "inited", false);
+
+    _defineProperty(_assertThisInitialized(_this), "layerModelNeedUpdate", false);
+
+    _defineProperty(_assertThisInitialized(_this), "pickedFeatureID", null);
+
+    _defineProperty(_assertThisInitialized(_this), "selectedFeatureID", null);
+
+    _defineProperty(_assertThisInitialized(_this), "styleNeedUpdate", false);
+
+    _defineProperty(_assertThisInitialized(_this), "clusterZoom", 0);
+
+    _defineProperty(_assertThisInitialized(_this), "dataState", {
+      dataSourceNeedUpdate: false,
+      dataMappingNeedUpdate: false,
+      filterNeedUpdate: false,
+      featureScaleNeedUpdate: false,
+      StyleAttrNeedUpdate: false
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "hooks", {
+      init: new SyncBailHook(),
+      afterInit: new SyncBailHook(),
+      beforeRender: new SyncBailHook(),
+      beforeRenderData: new SyncWaterfallHook(),
+      afterRender: new SyncHook(),
+      beforePickingEncode: new SyncHook(),
+      afterPickingEncode: new SyncHook(),
+      beforeHighlight: new SyncHook(['pickedColor']),
+      afterHighlight: new SyncHook(),
+      beforeSelect: new SyncHook(['pickedColor']),
+      afterSelect: new SyncHook(),
+      beforeDestroy: new SyncHook(),
+      afterDestroy: new SyncHook()
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "models", []);
+
+    _defineProperty(_assertThisInitialized(_this), "layerChildren", []);
+
+    _defineProperty(_assertThisInitialized(_this), "masks", []);
+
+    _defineProperty(_assertThisInitialized(_this), "isVector", false);
+
+    _initializerDefineProperty(_assertThisInitialized(_this), "configService", _descriptor, _assertThisInitialized(_this));
+
+    _defineProperty(_assertThisInitialized(_this), "animateOptions", {
+      enable: false
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "currentPickId", null);
+
+    _defineProperty(_assertThisInitialized(_this), "pendingStyleAttributes", []);
+
+    _defineProperty(_assertThisInitialized(_this), "scaleOptions", {});
+
+    _defineProperty(_assertThisInitialized(_this), "aniamateStatus", false);
+
+    _defineProperty(_assertThisInitialized(_this), "bottomColor", 'rgba(0, 0, 0, 0)');
+
+    _defineProperty(_assertThisInitialized(_this), "isDestroied", false);
+
+    _defineProperty(_assertThisInitialized(_this), "sourceEvent", function () {
+      _this.dataState.dataSourceNeedUpdate = true;
+
+      var layerConfig = _this.getLayerConfig();
+
+      if (layerConfig && layerConfig.autoFit) {
+        _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;
+  }
+
+  _createClass(BaseLayer, [{
+    key: "addMaskLayer",
+    value: function addMaskLayer(maskLayer) {
+      this.masks.push(maskLayer);
+    }
+  }, {
+    key: "removeMaskLayer",
+    value: function removeMaskLayer(maskLayer) {
+      var layerIndex = this.masks.indexOf(maskLayer);
+
+      if (layerIndex > -1) {
+        this.masks.splice(layerIndex, 1);
+      }
+
+      maskLayer.destroy();
+    }
+  }, {
+    key: "getAttribute",
+    value: function getAttribute(name) {
+      return this.styleAttributeService.getLayerStyleAttribute(name);
+    }
+  }, {
+    key: "getLayerConfig",
+    value: function getLayerConfig() {
+      return this.configService.getLayerConfig(this.id);
+    }
+  }, {
+    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];
+        }
+      });
+
+      if (!this.inited) {
+        this.needUpdateConfig = _objectSpread(_objectSpread({}, this.needUpdateConfig), configToUpdate);
+      } else {
+        var sceneId = this.container.get(TYPES.SceneID); // @ts-ignore
+
+        handleStyleDataMapping(configToUpdate, this); // 处理 style 中进行数据映射的属性字段
+
+        this.configService.setLayerConfig(sceneId, this.id, _objectSpread(_objectSpread(_objectSpread({}, this.configService.getLayerConfig(this.id)), this.needUpdateConfig), configToUpdate));
+        this.needUpdateConfig = {};
+      }
+    }
+    /**
+     * 注入图层容器，父容器为场景容器
+     * 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(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(TYPES.IIconService);
+      this.fontService = this.container.get(TYPES.IFontService);
+      this.rendererService = this.container.get(TYPES.IRendererService);
+      this.layerService = this.container.get(TYPES.ILayerService);
+      this.interactionService = this.container.get(TYPES.IInteractionService);
+      this.pickingService = this.container.get(TYPES.IPickingService);
+      this.mapService = this.container.get(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(TYPES.ICameraService);
+      this.coordinateService = this.container.get(TYPES.ICoordinateSystemService);
+      this.shaderModuleService = this.container.get(TYPES.IShaderModuleService);
+      this.postProcessingPassFactory = this.container.get(TYPES.IFactoryPostProcessingPass);
+      this.normalPassFactory = this.container.get(TYPES.IFactoryNormalPass); // 图层容器服务
+
+      this.styleAttributeService = this.container.get(TYPES.IStyleAttributeService);
+      this.multiPassRenderer = this.container.get(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: _objectSpread({
+            field: attributeField
+          }, _this3.splitValuesAndCallbackInAttribute( // @ts-ignore
+          attributeValues, // @ts-ignore
+          _this3.getLayerConfig()[attributeName]))
+        }, // @ts-ignore
+        updateOptions);
+      });
+      this.pendingStyleAttributes = []; // 获取插件集
+
+      this.plugins = this.container.getAll(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'
+      });
+      return this;
+    }
+  }, {
+    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');
+      }
+    }
+  }, {
+    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
+        };
+      }
+    }
+  }, {
+    key: "calculateEncodeData",
+    value: function calculateEncodeData(data, option) {
+      if (this.inited) {
+        return calculateData(this, this.fontService, this.mapService, this.styleAttributeService, data, option);
+      } else {
+        console.warn('layer not inited!');
+        return null;
+      }
+    }
+    /**
+     * Model初始化前需要更新Model样式
+     */
+
+  }, {
+    key: "prepareBuildModel",
+    value: function prepareBuildModel() {
+      this.inited = true;
+      this.updateLayerConfig(_objectSpread(_objectSpread({}, 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;
+      }
+    }
+  }, {
+    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;
+    }
+  }, {
+    key: "rotate",
+    value: function rotate(field, values, updateOptions) {
+      this.updateStyleAttribute('rotate', field, values, updateOptions);
+      return this;
+    }
+  }, {
+    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) {
+        updateShape(this, lastShape, currentShape);
+      }
+
+      return this;
+    }
+  }, {
+    key: "label",
+    value: function label(field, values, updateOptions) {
+      this.pendingStyleAttributes.push({
+        attributeName: 'label',
+        attributeField: field,
+        attributeValues: values,
+        updateOptions: updateOptions
+      });
+      return this;
+    }
+  }, {
+    key: "animate",
+    value: function animate(options) {
+      var rawAnimate = {};
+
+      if (isObject(options)) {
+        rawAnimate.enable = true;
+        rawAnimate = _objectSpread(_objectSpread({}, 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
+      };
+      this.clusterZoom = 0;
+      return this;
+    }
+  }, {
+    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 Source(data, options));
+
+            _this4.sourceEvent();
+          } else {
+            _this4.layerSource.setData(data, options);
+          } // this.layerSource.setData(data, options);
+
+        });
+      }
+
+      return this;
+    }
+  }, {
+    key: "style",
+    value: function style(options) {
+      var _this5 = this;
+
+      var lastConfig = this.getLayerConfig();
+
+      var passes = options.passes,
+          rest = _objectWithoutProperties(options, _excluded); // passes 特殊处理
+
+
+      if (passes) {
+        normalizePasses(passes).forEach(function (pass) {
+          var postProcessingPass = _this5.multiPassRenderer.getPostProcessor().getPostProcessingPassByName(pass[0]);
+
+          if (postProcessingPass) {
+            postProcessingPass.updateOptions(pass[1]);
+          }
+        });
+      }
+
+      this.rawConfig = _objectSpread(_objectSpread({}, 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;
+    }
+  }, {
+    key: "scale",
+    value: function scale(field, cfg) {
+      if (isObject(field)) {
+        this.scaleOptions = _objectSpread(_objectSpread({}, 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;
+    }
+    /**
+     * renderMultiPass 专门用于渲染支持 multipass 的 layer
+     */
+
+  }, {
+    key: "renderMultiPass",
+    value: function () {
+      var _renderMultiPass = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.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 = isObject(options) ? true : options;
+
+      if (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 (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: isObject(options) ? options.color : this.getLayerConfig().highlightColor,
+          activeMix: isObject(options) ? options.mix : this.getLayerConfig().activeMix
+        });
+        this.pick({
+          x: x,
+          y: y
+        });
+      } else {
+        this.updateLayerConfig({
+          pickedFeatureID: id,
+          highlightColor: isObject(options) ? options.color : this.getLayerConfig().highlightColor,
+          activeMix: isObject(options) ? options.mix : this.getLayerConfig().activeMix
+        });
+        this.hooks.beforeSelect.call(encodePickingColor(id)) // @ts-ignore
+        .then(function () {
+          setTimeout(function () {
+            _this6.reRender();
+          }, 1);
+        });
+      }
+    }
+  }, {
+    key: "select",
+    value: function select(option) {
+      var activeOption = {};
+      activeOption.enableSelect = isObject(option) ? true : option;
+
+      if (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 (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: isObject(options) ? options.color : this.getLayerConfig().selectColor,
+          selectMix: isObject(options) ? options.mix : this.getLayerConfig().selectMix
+        });
+        this.pick({
+          x: x,
+          y: y
+        });
+      } else {
+        this.updateLayerConfig({
+          pickedFeatureID: id,
+          selectColor: isObject(options) ? options.color : this.getLayerConfig().selectColor,
+          selectMix: isObject(options) ? options.mix : this.getLayerConfig().selectMix
+        });
+        this.hooks.beforeSelect.call(encodePickingColor(id)) // @ts-ignore
+        .then(function () {
+          setTimeout(function () {
+            _this7.reRender();
+          }, 1);
+        });
+      }
+    }
+  }, {
+    key: "setBlend",
+    value: function setBlend(type) {
+      this.updateLayerConfig({
+        blend: type
+      });
+      this.layerModelNeedUpdate = true;
+      this.reRender();
+      return this;
+    }
+  }, {
+    key: "show",
+    value: function show() {
+      this.updateLayerConfig({
+        visible: true
+      });
+      this.reRender();
+      return this;
+    }
+  }, {
+    key: "hide",
+    value: function hide() {
+      if (this.type === 'CanvasLayer' && this.layerModel.clearCanvas) {
+        // 对 canvasLayer 的 hide 操作做特殊处理
+        this.layerModel.clearCanvas();
+      }
+
+      this.updateLayerConfig({
+        visible: false
+      });
+      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({
+        enableMultiPassRenderer: enableMultiPass
+      });
+
+      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 = 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;
+    }
+  }, {
+    key: "getMinZoom",
+    value: function getMinZoom() {
+      var _this$getLayerConfig8 = this.getLayerConfig(),
+          minZoom = _this$getLayerConfig8.minZoom;
+
+      return minZoom;
+    }
+  }, {
+    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({
+        maxZoom: maxZoom
+      });
+      return this;
+    }
+  }, {
+    key: "setAutoFit",
+    value: function setAutoFit(autoFit) {
+      this.updateLayerConfig({
+        autoFit: autoFit
+      });
+      return this;
+    }
+    /**
+     * 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;
+    }
+  }, {
+    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;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.styleAttributeService.clearAllAttributes(); // 销毁所有 model
+    }
+  }, {
+    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 = [];
+    }
+  }, {
+    key: "isDirty",
+    value: function isDirty() {
+      return !!(this.styleAttributeService.getLayerStyleAttributes() || []).filter(function (attribute) {
+        return attribute.needRescale || attribute.needRemapping || attribute.needRegenerateVertices;
+      }).length;
+    }
+  }, {
+    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();
+      });
+    }
+  }, {
+    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 _defineProperty({
+            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 _defineProperty({
+            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 !isUndefined(item);
+        }).map(function (item) {
+          return _defineProperty({
+            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
+      });
+    }
+  }, {
+    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 = _objectWithoutProperties(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 WorkerSourceMap && workerEnabled) {
+          _this9.styleAttributeService.createAttributesAndIndicesAscy(_this9.encodedData, segmentNumber, workerOptions).then(function (_ref7) {
+            var attributes = _ref7.attributes,
+                elements = _ref7.elements;
+            var m = createModel(_objectSpread({
+              attributes: attributes,
+              uniforms: uniforms,
+              fs: fs,
+              vs: vs,
+              elements: elements,
+              blend: BlendTypes[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 = _objectSpread({
+            attributes: attributes,
+            uniforms: uniforms,
+            fs: fs,
+            vs: vs,
+            elements: elements,
+            blend: BlendTypes[BlendType.normal]
+          }, rest);
+
+          if (count) {
+            modeloptions.count = count;
+          }
+
+          var m = createModel(modeloptions);
+          resolve(m);
+        }
+      });
+    }
+  }, {
+    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
+          }
+        });
+      }
+    }
+  }, {
+    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;
+      }
+
+      return this.isVisible() && isPick;
+    }
+  }, {
+    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 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(multiPassRenderer) {
+        return _regeneratorRuntime.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;
+          });
+        }
+
+        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;
+    }
+  }, {
+    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: _objectSpread({
+            field: field
+          }, this.splitValuesAndCallbackInAttribute( // @ts-ignore
+          values, // @ts-ignore
+          this.getLayerConfig()[field]))
+        }, // @ts-ignore
+        updateOptions);
+      }
+    }
+  }, {
+    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: isFunction(valuesOrCallback) ? undefined : valuesOrCallback || defaultValues,
+        callback: isFunction(valuesOrCallback) ? valuesOrCallback : undefined
+      };
+    }
+  }]);
+
+  return BaseLayer;
+}(EventEmitter), (_descriptor = _applyDecoratedDescriptor(_class.prototype, "configService", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class));
+export { BaseLayer as default };