@antv/l7-layers 2.21.1 → 2.21.3

package/es/plugins/LayerMaskPlugin.js

@@ -1,28 +1,19 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 /**
  * 更新图层样式，初始图层相关配置
  */
-var LayerStylePlugin = /*#__PURE__*/function () {
-  function LayerStylePlugin() {
-    _classCallCheck(this, LayerStylePlugin);
+export default class LayerStylePlugin {
+  apply(layer) {
+    layer.hooks.afterInit.tap('LayerMaskPlugin', () => {
+      const {
+        maskLayers,
+        enableMask
+      } = layer.getLayerConfig();
+      // mask 初始化
+      if (!layer.tileLayer && maskLayers && maskLayers.length > 0) {
+        layer.updateLayerConfig({
+          mask: true && enableMask
+        });
+      }
+    });
   }
-  _createClass(LayerStylePlugin, [{
-    key: "apply",
-    value: function apply(layer) {
-      layer.hooks.afterInit.tap('LayerMaskPlugin', function () {
-        var _layer$getLayerConfig = layer.getLayerConfig(),
-          maskLayers = _layer$getLayerConfig.maskLayers,
-          enableMask = _layer$getLayerConfig.enableMask;
-        // mask 初始化
-        if (!layer.tileLayer && maskLayers && maskLayers.length > 0) {
-          layer.updateLayerConfig({
-            mask: true && enableMask
-          });
-        }
-      });
-    }
-  }]);
-  return LayerStylePlugin;
-}();
-export { LayerStylePlugin as default };
+}

package/es/plugins/LayerModelPlugin.js

@@ -1,144 +1,60 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { IDebugLog, ILayerStage } from '@antv/l7-core';
 // import TileLayer from '../tile/core/BaseLayer';
 /**
  * Layer Model 初始化，更新，销毁
  */
-var LayerModelPlugin = /*#__PURE__*/function () {
-  function LayerModelPlugin() {
-    _classCallCheck(this, LayerModelPlugin);
+export default class LayerModelPlugin {
+  build(layer) {
+    return _asyncToGenerator(function* () {
+      // 更新Model 配置项 style options
+      layer.prepareBuildModel();
+      // 初始化 Model
+      yield layer.buildModels();
+    })();
   }
-  _createClass(LayerModelPlugin, [{
-    key: "build",
-    value: function () {
-      var _build = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(layer) {
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              // 更新Model 配置项 style options
-              layer.prepareBuildModel();
-              // 初始化 Model
-              _context.next = 3;
-              return layer.buildModels();
-            case 3:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee);
-      }));
-      function build(_x) {
-        return _build.apply(this, arguments);
-      }
-      return build;
-    }()
-  }, {
-    key: "initLayerModel",
-    value: function () {
-      var _initLayerModel = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(layer) {
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.next = 2;
-              return this.build(layer);
-            case 2:
-              layer.styleNeedUpdate = false;
-            case 3:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function initLayerModel(_x2) {
-        return _initLayerModel.apply(this, arguments);
-      }
-      return initLayerModel;
-    }()
-  }, {
-    key: "prepareLayerModel",
-    value: function () {
-      var _prepareLayerModel = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(layer) {
-        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              _context3.next = 2;
-              return this.build(layer);
-            case 2:
-              layer.styleNeedUpdate = false;
-            case 3:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function prepareLayerModel(_x3) {
-        return _prepareLayerModel.apply(this, arguments);
+  initLayerModel(layer) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      yield _this.build(layer);
+      layer.styleNeedUpdate = false;
+    })();
+  }
+  prepareLayerModel(layer) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      yield _this2.build(layer);
+      layer.styleNeedUpdate = false;
+    })();
+  }
+  apply(layer) {
+    var _this3 = this;
+    layer.hooks.init.tapPromise('LayerModelPlugin', /*#__PURE__*/_asyncToGenerator(function* () {
+      if (layer.getSource().isTile) {
+        layer.prepareBuildModel();
+        return;
       }
-      return prepareLayerModel;
-    }()
-  }, {
-    key: "apply",
-    value: function apply(layer) {
-      var _this = this;
-      layer.hooks.init.tapPromise('LayerModelPlugin', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
-        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              if (!layer.getSource().isTile) {
-                _context4.next = 3;
-                break;
-              }
-              layer.prepareBuildModel();
-              return _context4.abrupt("return");
-            case 3:
-              layer.log(IDebugLog.BuildModelStart, ILayerStage.INIT);
-              _context4.next = 6;
-              return _this.initLayerModel(layer);
-            case 6:
-              layer.log(IDebugLog.BuildModelEnd, ILayerStage.INIT);
-            case 7:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4);
-      })));
-      layer.hooks.beforeRenderData.tapPromise('LayerModelPlugin', /*#__PURE__*/function () {
-        var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(flag) {
-          return _regeneratorRuntime.wrap(function _callee5$(_context5) {
-            while (1) switch (_context5.prev = _context5.next) {
-              case 0:
-                if (flag) {
-                  _context5.next = 2;
-                  break;
-                }
-                return _context5.abrupt("return", false);
-              case 2:
-                if (!layer.getSource().isTile) {
-                  _context5.next = 4;
-                  break;
-                }
-                return _context5.abrupt("return", false);
-              case 4:
-                layer.log(IDebugLog.BuildModelStart, ILayerStage.UPDATE);
-                _context5.next = 7;
-                return _this.prepareLayerModel(layer);
-              case 7:
-                layer.log(IDebugLog.BuildModelEnd, ILayerStage.UPDATE);
-                return _context5.abrupt("return", true);
-              case 9:
-              case "end":
-                return _context5.stop();
-            }
-          }, _callee5);
-        }));
-        return function (_x4) {
-          return _ref2.apply(this, arguments);
-        };
-      }());
-    }
-  }]);
-  return LayerModelPlugin;
-}();
-export { LayerModelPlugin as default };
+      layer.log(IDebugLog.BuildModelStart, ILayerStage.INIT);
+      yield _this3.initLayerModel(layer);
+      layer.log(IDebugLog.BuildModelEnd, ILayerStage.INIT);
+    }));
+    layer.hooks.beforeRenderData.tapPromise('LayerModelPlugin', /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (flag) {
+        if (!flag) {
+          // TileLayer  不需要rebuilder
+          return false;
+        }
+        if (layer.getSource().isTile) {
+          return false;
+        }
+        layer.log(IDebugLog.BuildModelStart, ILayerStage.UPDATE);
+        yield _this3.prepareLayerModel(layer);
+        layer.log(IDebugLog.BuildModelEnd, ILayerStage.UPDATE);
+        return true;
+      });
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+  }
+}

package/es/plugins/LayerStylePlugin.js

@@ -1,27 +1,18 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 /**
  * 更新图层样式，初始图层相关配置
  */
-var LayerStylePlugin = /*#__PURE__*/function () {
-  function LayerStylePlugin() {
-    _classCallCheck(this, LayerStylePlugin);
+export default class LayerStylePlugin {
+  apply(layer) {
+    layer.hooks.afterInit.tap('LayerStylePlugin', () => {
+      const {
+        autoFit,
+        fitBoundsOptions
+      } = layer.getLayerConfig();
+      // mask 初始化
+      if (autoFit) {
+        layer.fitBounds(fitBoundsOptions);
+      }
+      layer.styleNeedUpdate = false;
+    });
   }
-  _createClass(LayerStylePlugin, [{
-    key: "apply",
-    value: function apply(layer) {
-      layer.hooks.afterInit.tap('LayerStylePlugin', function () {
-        var _layer$getLayerConfig = layer.getLayerConfig(),
-          autoFit = _layer$getLayerConfig.autoFit,
-          fitBoundsOptions = _layer$getLayerConfig.fitBoundsOptions;
-        // mask 初始化
-        if (autoFit) {
-          layer.fitBounds(fitBoundsOptions);
-        }
-        layer.styleNeedUpdate = false;
-      });
-    }
-  }]);
-  return LayerStylePlugin;
-}();
-export { LayerStylePlugin as default };
+}

package/es/plugins/LightingPlugin.js

@@ -1,9 +1,7 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-var _excluded = ["type"];
-var lightTypeUniformMap = {
+const _excluded = ["type"];
+const lightTypeUniformMap = {
   directional: {
     lights: 'u_DirectionalLights',
     num: 'u_NumOfDirectionalLights'
@@ -13,20 +11,20 @@ var lightTypeUniformMap = {
     num: 'u_NumOfSpotLights'
   }
 };
-var DEFAULT_LIGHT = {
+const DEFAULT_LIGHT = {
   type: 'directional',
   direction: [1, 10.5, 12],
   ambient: [0.2, 0.2, 0.2],
   diffuse: [0.6, 0.6, 0.6],
   specular: [0.1, 0.1, 0.1]
 };
-var DEFAULT_DIRECTIONAL_LIGHT = {
+const DEFAULT_DIRECTIONAL_LIGHT = {
   direction: [0, 0, 0],
   ambient: [0, 0, 0],
   diffuse: [0, 0, 0],
   specular: [0, 0, 0]
 };
-var DEFAULT_SPOT_LIGHT = {
+const DEFAULT_SPOT_LIGHT = {
   position: [0, 0, 0],
   direction: [0, 0, 0],
   ambient: [0, 0, 0],
@@ -40,7 +38,7 @@ var DEFAULT_SPOT_LIGHT = {
   blur: 5
 };
 export function generateLightingUniforms(lights) {
-  var lightsMap = {
+  const lightsMap = {
     u_DirectionalLights: new Array(3).fill(_objectSpread({}, DEFAULT_DIRECTIONAL_LIGHT)),
     u_NumOfDirectionalLights: 0,
     u_SpotLights: new Array(3).fill(_objectSpread({}, DEFAULT_SPOT_LIGHT)),
@@ -49,15 +47,16 @@ export function generateLightingUniforms(lights) {
   if (!lights || !lights.length) {
     lights = [DEFAULT_LIGHT];
   }
-  lights.forEach(function (_ref) {
-    var _ref$type = _ref.type,
-      type = _ref$type === void 0 ? 'directional' : _ref$type,
+  lights.forEach(_ref => {
+    let {
+        type = 'directional'
+      } = _ref,
       rest = _objectWithoutProperties(_ref, _excluded);
-    var lightsUniformName = lightTypeUniformMap[type].lights;
-    var lightsNumUniformName = lightTypeUniformMap[type].num;
+    const lightsUniformName = lightTypeUniformMap[type].lights;
+    const lightsNumUniformName = lightTypeUniformMap[type].num;
 
     // @ts-ignore
-    var num = lightsMap[lightsNumUniformName];
+    const num = lightsMap[lightsNumUniformName];
     // @ts-ignore
     lightsMap[lightsUniformName][num] = _objectSpread(_objectSpread({}, lightsMap[lightsUniformName][num]), rest);
     // @ts-ignore
@@ -69,27 +68,17 @@ export function generateLightingUniforms(lights) {
 /**
  * 光照 & Shadow
  */
-var LightingPlugin = /*#__PURE__*/function () {
-  function LightingPlugin() {
-    _classCallCheck(this, LightingPlugin);
+export default class LightingPlugin {
+  apply(layer) {
+    layer.hooks.beforeRender.tap('LightingPlugin', () => {
+      const {
+        enableLighting
+      } = layer.getLayerConfig();
+      if (enableLighting) {
+        layer.models.forEach(model =>
+        // @ts-ignore
+        model.addUniforms(_objectSpread({}, generateLightingUniforms())));
+      }
+    });
   }
-  _createClass(LightingPlugin, [{
-    key: "apply",
-    value: function apply(layer) {
-      layer.hooks.beforeRender.tap('LightingPlugin', function () {
-        var _layer$getLayerConfig = layer.getLayerConfig(),
-          enableLighting = _layer$getLayerConfig.enableLighting;
-        if (enableLighting) {
-          layer.models.forEach(function (model) {
-            return (
-              // @ts-ignore
-              model.addUniforms(_objectSpread({}, generateLightingUniforms()))
-            );
-          });
-        }
-      });
-    }
-  }]);
-  return LightingPlugin;
-}();
-export { LightingPlugin as default };
+}

package/es/plugins/MultiPassRendererPlugin.js

@@ -1,5 +1,4 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { createMultiPassRenderer } from "../utils/multiPassRender";
 
 /**
@@ -15,43 +14,39 @@ import { createMultiPassRenderer } from "../utils/multiPassRender";
  *   ],
  * })
  */
-var MultiPassRendererPlugin = /*#__PURE__*/function () {
-  function MultiPassRendererPlugin() {
-    _classCallCheck(this, MultiPassRendererPlugin);
+export default class MultiPassRendererPlugin {
+  constructor() {
+    _defineProperty(this, "enabled", void 0);
   }
-  _createClass(MultiPassRendererPlugin, [{
-    key: "apply",
-    value: function apply(layer, _ref) {
-      var _this = this;
-      var rendererService = _ref.rendererService,
-        postProcessingPassFactory = _ref.postProcessingPassFactory,
-        normalPassFactory = _ref.normalPassFactory;
-      layer.hooks.init.tapPromise('MultiPassRendererPlugin', function () {
-        var _layer$getLayerConfig = layer.getLayerConfig(),
-          enableMultiPassRenderer = _layer$getLayerConfig.enableMultiPassRenderer,
-          _layer$getLayerConfig2 = _layer$getLayerConfig.passes,
-          passes = _layer$getLayerConfig2 === void 0 ? [] : _layer$getLayerConfig2;
+  apply(layer, {
+    rendererService,
+    postProcessingPassFactory,
+    normalPassFactory
+  }) {
+    layer.hooks.init.tapPromise('MultiPassRendererPlugin', () => {
+      const {
+        enableMultiPassRenderer,
+        passes = []
+      } = layer.getLayerConfig();
 
-        // SceneConfig 的 enableMultiPassRenderer 配置项可以统一关闭
-        _this.enabled = !!enableMultiPassRenderer && layer.getLayerConfig().enableMultiPassRenderer !== false;
+      // SceneConfig 的 enableMultiPassRenderer 配置项可以统一关闭
+      this.enabled = !!enableMultiPassRenderer && layer.getLayerConfig().enableMultiPassRenderer !== false;
 
-        // 根据 LayerConfig passes 配置项初始化
-        if (_this.enabled) {
-          layer.multiPassRenderer = createMultiPassRenderer(layer, passes, postProcessingPassFactory, normalPassFactory);
-          layer.multiPassRenderer.setRenderFlag(true);
-        }
-      });
-      layer.hooks.beforeRender.tap('MultiPassRendererPlugin', function () {
-        if (_this.enabled) {
-          // 渲染前根据 viewport 调整 FBO size
-          var _rendererService$getV = rendererService.getViewportSize(),
-            width = _rendererService$getV.width,
-            height = _rendererService$getV.height;
-          layer.multiPassRenderer.resize(width, height);
-        }
-      });
-    }
-  }]);
-  return MultiPassRendererPlugin;
-}();
-export { MultiPassRendererPlugin as default };
+      // 根据 LayerConfig passes 配置项初始化
+      if (this.enabled) {
+        layer.multiPassRenderer = createMultiPassRenderer(layer, passes, postProcessingPassFactory, normalPassFactory);
+        layer.multiPassRenderer.setRenderFlag(true);
+      }
+    });
+    layer.hooks.beforeRender.tap('MultiPassRendererPlugin', () => {
+      if (this.enabled) {
+        // 渲染前根据 viewport 调整 FBO size
+        const {
+          width,
+          height
+        } = rendererService.getViewportSize();
+        layer.multiPassRenderer.resize(width, height);
+      }
+    });
+  }
+}