@antv/l7-layers 2.9.32-alpha.3 → 2.9.32-alpha.4

package/es/plugins/LightingPlugin.js

@@ -0,0 +1,104 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+
+var _dec, _class;
+
+var _excluded = ["type"];
+import { injectable } from 'inversify';
+import 'reflect-metadata';
+var lightTypeUniformMap = {
+  directional: {
+    lights: 'u_DirectionalLights',
+    num: 'u_NumOfDirectionalLights'
+  },
+  spot: {
+    lights: 'u_SpotLights',
+    num: 'u_NumOfSpotLights'
+  }
+};
+var 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 = {
+  direction: [0, 0, 0],
+  ambient: [0, 0, 0],
+  diffuse: [0, 0, 0],
+  specular: [0, 0, 0]
+};
+var DEFAULT_SPOT_LIGHT = {
+  position: [0, 0, 0],
+  direction: [0, 0, 0],
+  ambient: [0, 0, 0],
+  diffuse: [0, 0, 0],
+  specular: [0, 0, 0],
+  constant: 1,
+  linear: 0,
+  quadratic: 0,
+  angle: 14,
+  exponent: 40,
+  blur: 5
+};
+export function generateLightingUniforms(lights) {
+  var lightsMap = {
+    u_DirectionalLights: new Array(3).fill(_objectSpread({}, DEFAULT_DIRECTIONAL_LIGHT)),
+    u_NumOfDirectionalLights: 0,
+    u_SpotLights: new Array(3).fill(_objectSpread({}, DEFAULT_SPOT_LIGHT)),
+    u_NumOfSpotLights: 0
+  };
+
+  if (!lights || !lights.length) {
+    lights = [DEFAULT_LIGHT];
+  }
+
+  lights.forEach(function (_ref, i) {
+    var _ref$type = _ref.type,
+        type = _ref$type === void 0 ? 'directional' : _ref$type,
+        rest = _objectWithoutProperties(_ref, _excluded);
+
+    var lightsUniformName = lightTypeUniformMap[type].lights;
+    var lightsNumUniformName = lightTypeUniformMap[type].num; // @ts-ignore
+
+    var num = lightsMap[lightsNumUniformName]; // @ts-ignore
+
+    lightsMap[lightsUniformName][num] = _objectSpread(_objectSpread({}, lightsMap[lightsUniformName][num]), rest); // @ts-ignore
+
+    lightsMap[lightsNumUniformName]++;
+  });
+  return lightsMap;
+}
+/**
+ * 光照 & Shadow
+ */
+
+var LightingPlugin = (_dec = injectable(), _dec(_class = /*#__PURE__*/function () {
+  function LightingPlugin() {
+    _classCallCheck(this, LightingPlugin);
+  }
+
+  _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;
+}()) || _class);
+export { LightingPlugin as default };

package/es/plugins/MultiPassRendererPlugin.d.ts

@@ -0,0 +1,23 @@
+import { ILayer, ILayerPlugin, IPass, IPostProcessingPass, IRendererService } from '@antv/l7-core';
+import 'reflect-metadata';
+/**
+ * 自定义渲染管线：
+ * ClearPass -> PixelPickingPass(可选) -> RenderPass/TAAPass -> PostProcessing -> CopyPass
+ * 根据 Layer 配置的 passes 创建 PostProcessing
+ * @example
+ * new PolygonLayer({
+ *   enableMultiPassRenderer: true,
+ *   passes: [
+ *     'blurH',
+ *     ['blurV', { radius: 10 }],
+ *   ],
+ * })
+ */
+export default class MultiPassRendererPlugin implements ILayerPlugin {
+    private enabled;
+    apply(layer: ILayer, { rendererService, postProcessingPassFactory, normalPassFactory, }: {
+        rendererService: IRendererService;
+        postProcessingPassFactory: (name: string) => IPostProcessingPass<unknown>;
+        normalPassFactory: (name: string) => IPass<unknown>;
+    }): void;
+}

package/es/plugins/MultiPassRendererPlugin.js

@@ -0,0 +1,65 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+var _dec, _class;
+
+import { injectable } from 'inversify';
+import 'reflect-metadata';
+import { createMultiPassRenderer } from "../utils/multiPassRender";
+/**
+ * 自定义渲染管线：
+ * ClearPass -> PixelPickingPass(可选) -> RenderPass/TAAPass -> PostProcessing -> CopyPass
+ * 根据 Layer 配置的 passes 创建 PostProcessing
+ * @example
+ * new PolygonLayer({
+ *   enableMultiPassRenderer: true,
+ *   passes: [
+ *     'blurH',
+ *     ['blurV', { radius: 10 }],
+ *   ],
+ * })
+ */
+
+var MultiPassRendererPlugin = (_dec = injectable(), _dec(_class = /*#__PURE__*/function () {
+  function MultiPassRendererPlugin() {
+    _classCallCheck(this, MultiPassRendererPlugin);
+  }
+
+  _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.tap('MultiPassRendererPlugin', function () {
+        var _layer$getLayerConfig = layer.getLayerConfig(),
+            enableMultiPassRenderer = _layer$getLayerConfig.enableMultiPassRenderer,
+            _layer$getLayerConfig2 = _layer$getLayerConfig.passes,
+            passes = _layer$getLayerConfig2 === void 0 ? [] : _layer$getLayerConfig2; // 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;
+}()) || _class);
+export { MultiPassRendererPlugin as default };

package/es/plugins/PixelPickingPlugin.d.ts

@@ -0,0 +1,8 @@
+import { ILayer, ILayerPlugin, IRendererService, IStyleAttributeService } from '@antv/l7-core';
+import 'reflect-metadata';
+export default class PixelPickingPlugin implements ILayerPlugin {
+    apply(layer: ILayer, { styleAttributeService, }: {
+        rendererService: IRendererService;
+        styleAttributeService: IStyleAttributeService;
+    }): void;
+}

package/es/plugins/PixelPickingPlugin.js

@@ -0,0 +1,126 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+var _dec, _class;
+
+import { AttributeType, gl } from '@antv/l7-core';
+import { decodePickingColor, encodePickingColor, rgb2arr } from '@antv/l7-utils';
+import { injectable } from 'inversify';
+import 'reflect-metadata';
+var PickingStage = {
+  NONE: 0.0,
+  ENCODE: 1.0,
+  HIGHLIGHT: 2.0
+};
+var PixelPickingPlugin = (_dec = injectable(), _dec(_class = /*#__PURE__*/function () {
+  function PixelPickingPlugin() {
+    _classCallCheck(this, PixelPickingPlugin);
+  }
+
+  _createClass(PixelPickingPlugin, [{
+    key: "apply",
+    value: function apply(layer, _ref) {
+      var styleAttributeService = _ref.styleAttributeService;
+      // TODO: 由于 Shader 目前无法根据是否开启拾取进行内容修改，因此即使不开启也需要生成 a_PickingColor
+      layer.hooks.init.tap('PixelPickingPlugin', function () {
+        var _layer$getLayerConfig = layer.getLayerConfig(),
+            enablePicking = _layer$getLayerConfig.enablePicking;
+
+        styleAttributeService.registerStyleAttribute({
+          name: 'pickingColor',
+          type: AttributeType.Attribute,
+          descriptor: {
+            name: 'a_PickingColor',
+            buffer: {
+              data: [],
+              type: gl.FLOAT
+            },
+            size: 3,
+            // TODO: 固定 feature range 范围内的 pickingColor 都是固定的，可以生成 cache
+            update: function update(feature) {
+              // 只有开启拾取才需要 encode
+              var id = feature.id;
+              return enablePicking ? encodePickingColor(id) : [0, 0, 0];
+            }
+          }
+        });
+      }); // 必须要与 PixelPickingPass 结合使用，因此必须开启 multiPassRenderer
+
+      layer.hooks.beforePickingEncode.tap('PixelPickingPlugin', function () {
+        var _layer$getLayerConfig2 = layer.getLayerConfig(),
+            enablePicking = _layer$getLayerConfig2.enablePicking;
+
+        if (enablePicking && layer.isVisible()) {
+          layer.models.forEach(function (model) {
+            return model.addUniforms({
+              u_PickingStage: PickingStage.ENCODE
+            });
+          });
+        }
+      });
+      layer.hooks.afterPickingEncode.tap('PixelPickingPlugin', function () {
+        var _layer$getLayerConfig3 = layer.getLayerConfig(),
+            enablePicking = _layer$getLayerConfig3.enablePicking; // 区分选中高亮 和滑过高亮
+
+
+        if (enablePicking && layer.isVisible()) {
+          layer.models.forEach(function (model) {
+            return model.addUniforms({
+              u_PickingStage: PickingStage.HIGHLIGHT
+            });
+          });
+        }
+      });
+      layer.hooks.beforeHighlight.tap('PixelPickingPlugin', function (pickedColor) {
+        var _layer$getLayerConfig4 = layer.getLayerConfig(),
+            highlightColor = _layer$getLayerConfig4.highlightColor,
+            _layer$getLayerConfig5 = _layer$getLayerConfig4.activeMix,
+            activeMix = _layer$getLayerConfig5 === void 0 ? 0 : _layer$getLayerConfig5;
+
+        var highlightColorInArray = typeof highlightColor === 'string' ? rgb2arr(highlightColor) : highlightColor || [1, 0, 0, 1];
+        layer.updateLayerConfig({
+          pickedFeatureID: decodePickingColor(new Uint8Array(pickedColor))
+        });
+        layer.models.forEach(function (model) {
+          return model.addUniforms({
+            u_PickingStage: PickingStage.HIGHLIGHT,
+            u_PickingColor: pickedColor,
+            u_HighlightColor: highlightColorInArray.map(function (c) {
+              return c * 255;
+            }),
+            u_activeMix: activeMix
+          });
+        });
+      });
+      layer.hooks.beforeSelect.tap('PixelPickingPlugin', function (pickedColor) {
+        var _layer$getLayerConfig6 = layer.getLayerConfig(),
+            selectColor = _layer$getLayerConfig6.selectColor,
+            _layer$getLayerConfig7 = _layer$getLayerConfig6.selectMix,
+            selectMix = _layer$getLayerConfig7 === void 0 ? 0 : _layer$getLayerConfig7;
+
+        var highlightColorInArray = typeof selectColor === 'string' ? rgb2arr(selectColor) : selectColor || [1, 0, 0, 1];
+        layer.updateLayerConfig({
+          pickedFeatureID: decodePickingColor(new Uint8Array(pickedColor))
+        });
+        layer.models.forEach(function (model) {
+          return model.addUniforms({
+            u_PickingStage: PickingStage.HIGHLIGHT,
+            u_PickingColor: pickedColor,
+            u_HighlightColor: highlightColorInArray.map(function (c) {
+              return c * 255;
+            }),
+            u_activeMix: selectMix,
+            u_CurrentSelectedId: pickedColor,
+            u_SelectColor: highlightColorInArray.map(function (c) {
+              return c * 255;
+            }),
+            u_EnableSelect: 1
+          });
+        });
+      });
+    }
+  }]);
+
+  return PixelPickingPlugin;
+}()) || _class);
+export { PixelPickingPlugin as default };

package/es/plugins/RegisterStyleAttributePlugin.d.ts

@@ -0,0 +1,15 @@
+import { ILayer, ILayerPlugin, IStyleAttributeService } from '@antv/l7-core';
+import 'reflect-metadata';
+/**
+ * 在初始化阶段完成属性的注册，以及首次根据 Layer 指定的三角化方法完成 indices 和 attribute 的创建
+ */
+export default class RegisterStyleAttributePlugin implements ILayerPlugin {
+    apply(layer: ILayer, { styleAttributeService, }: {
+        styleAttributeService: IStyleAttributeService;
+    }): void;
+    private registerBuiltinAttributes;
+    private registerPositionAttribute;
+    private registerFilterAttribute;
+    private registerColorAttribute;
+    private registerVertexIdAttribute;
+}

package/es/plugins/RegisterStyleAttributePlugin.js

@@ -0,0 +1,156 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+var _dec, _class;
+
+import { AttributeType, gl } from '@antv/l7-core';
+import { injectable } from 'inversify';
+import 'reflect-metadata';
+/**
+ * 在初始化阶段完成属性的注册，以及首次根据 Layer 指定的三角化方法完成 indices 和 attribute 的创建
+ */
+
+var RegisterStyleAttributePlugin = (_dec = injectable(), _dec(_class = /*#__PURE__*/function () {
+  function RegisterStyleAttributePlugin() {
+    _classCallCheck(this, RegisterStyleAttributePlugin);
+  }
+
+  _createClass(RegisterStyleAttributePlugin, [{
+    key: "apply",
+    value: function apply(layer, _ref) {
+      var _this = this;
+
+      var styleAttributeService = _ref.styleAttributeService;
+      layer.hooks.init.tap('RegisterStyleAttributePlugin', function () {
+        _this.registerBuiltinAttributes(styleAttributeService, layer);
+      });
+    }
+  }, {
+    key: "registerBuiltinAttributes",
+    value: function registerBuiltinAttributes(styleAttributeService, layer) {
+      // 过滤 tileGroup layer （瓦片图层）
+      var source = layer.getSource();
+
+      switch (source.parser.type) {
+        case 'mvt':
+        case 'testTile':
+        case 'rasterTile':
+          // layer 仅作为 group 使用
+          return;
+      }
+
+      if (layer.type === 'MaskLayer') {
+        this.registerPositionAttribute(styleAttributeService);
+        return;
+      }
+
+      var _layer$getLayerConfig = layer.getLayerConfig(),
+          usage = _layer$getLayerConfig.usage;
+
+      if (usage === 'basemap ') {
+        this.registerPositionAttribute(styleAttributeService);
+        return;
+      }
+
+      if (layer.isTileLayer) {
+        this.registerPositionAttribute(styleAttributeService);
+        this.registerColorAttribute(styleAttributeService);
+        return;
+      } // Tip: normal render layer
+
+
+      this.registerPositionAttribute(styleAttributeService);
+      this.registerFilterAttribute(styleAttributeService);
+      this.registerColorAttribute(styleAttributeService);
+      this.registerVertexIdAttribute(styleAttributeService);
+    }
+  }, {
+    key: "registerPositionAttribute",
+    value: function registerPositionAttribute(styleAttributeService) {
+      styleAttributeService.registerStyleAttribute({
+        name: 'position',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_Position',
+          buffer: {
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 3,
+          update: function update(feature, featureIdx, vertex) {
+            return vertex.length === 2 ? [vertex[0], vertex[1], 0] : [vertex[0], vertex[1], vertex[2]];
+          }
+        }
+      });
+    }
+  }, {
+    key: "registerFilterAttribute",
+    value: function registerFilterAttribute(styleAttributeService) {
+      styleAttributeService.registerStyleAttribute({
+        name: 'filter',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'filter',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.DYNAMIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 1,
+          update: function update(feature) {
+            var filter = feature.filter;
+            return filter ? [1] : [0];
+          }
+        }
+      });
+    }
+  }, {
+    key: "registerColorAttribute",
+    value: function registerColorAttribute(styleAttributeService) {
+      styleAttributeService.registerStyleAttribute({
+        name: 'color',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_Color',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.DYNAMIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 4,
+          update: function update(feature) {
+            var color = feature.color;
+            return !color || !color.length ? [1, 1, 1, 1] : color;
+          }
+        }
+      });
+    }
+  }, {
+    key: "registerVertexIdAttribute",
+    value: function registerVertexIdAttribute(styleAttributeService) {
+      styleAttributeService.registerStyleAttribute({
+        // 统一注册每个顶点的唯一编号（目前用于样式的数据映射计算使用）
+        name: 'vertexId',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_vertexId',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.DYNAMIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 1,
+          update: function update(feature, featureIdx) {
+            return [featureIdx];
+          }
+        }
+      });
+    }
+  }]);
+
+  return RegisterStyleAttributePlugin;
+}()) || _class);
+export { RegisterStyleAttributePlugin as default };

package/es/plugins/ShaderUniformPlugin.d.ts

@@ -0,0 +1,17 @@
+import { ILayer, ILayerPlugin } from '@antv/l7-core';
+import 'reflect-metadata';
+/**
+ * 在渲染之前需要获取当前 Shader 所需 Uniform，例如：
+ * 1. 从相机服务中获取 View & ProjectionMatrix，当前缩放等级等等
+ * 2. 从坐标系服务中获取当前坐标系，例如是否是偏移坐标系
+ *    @see https://yuque.antfin-inc.com/yuqi.pyq/fgetpa/doml91
+ * 3. 当前 Layer 本身的样式属性
+ */
+export default class ShaderUniformPlugin implements ILayerPlugin {
+    private readonly cameraService;
+    private readonly coordinateSystemService;
+    private readonly rendererService;
+    private readonly mapService;
+    apply(layer: ILayer): void;
+    private getLayerCenter;
+}

package/es/plugins/ShaderUniformPlugin.js

@@ -0,0 +1,107 @@
+import _initializerDefineProperty from "@babel/runtime/helpers/initializerDefineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _applyDecoratedDescriptor from "@babel/runtime/helpers/applyDecoratedDescriptor";
+import _initializerWarningHelper from "@babel/runtime/helpers/initializerWarningHelper";
+
+var _dec, _dec2, _dec3, _dec4, _dec5, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4;
+
+import { CameraUniform, CoordinateUniform, TYPES } from '@antv/l7-core';
+import { $window } from '@antv/l7-utils';
+import { inject, injectable } from 'inversify';
+import 'reflect-metadata';
+/**
+ * 在渲染之前需要获取当前 Shader 所需 Uniform，例如：
+ * 1. 从相机服务中获取 View & ProjectionMatrix，当前缩放等级等等
+ * 2. 从坐标系服务中获取当前坐标系，例如是否是偏移坐标系
+ *    @see https://yuque.antfin-inc.com/yuqi.pyq/fgetpa/doml91
+ * 3. 当前 Layer 本身的样式属性
+ */
+
+var ShaderUniformPlugin = (_dec = injectable(), _dec2 = inject(TYPES.ICameraService), _dec3 = inject(TYPES.ICoordinateSystemService), _dec4 = inject(TYPES.IRendererService), _dec5 = inject(TYPES.IMapService), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  function ShaderUniformPlugin() {
+    _classCallCheck(this, ShaderUniformPlugin);
+
+    _initializerDefineProperty(this, "cameraService", _descriptor, this);
+
+    _initializerDefineProperty(this, "coordinateSystemService", _descriptor2, this);
+
+    _initializerDefineProperty(this, "rendererService", _descriptor3, this);
+
+    _initializerDefineProperty(this, "mapService", _descriptor4, this);
+  }
+
+  _createClass(ShaderUniformPlugin, [{
+    key: "apply",
+    value: function apply(layer) {
+      var _this = this;
+
+      var version = this.mapService.version;
+      var mvp = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; // default matrix (for gaode2.x)
+
+      var sceneCenterMKT = [0, 0];
+      layer.hooks.beforeRender.tap('ShaderUniformPlugin', function () {
+        // @ts-ignore
+        var offset = layer.getLayerConfig().tileOrigin; // 重新计算坐标系参数
+
+        _this.coordinateSystemService.refresh(offset);
+
+        if (version === 'GAODE2.x') {
+          var layerCenter = _this.getLayerCenter(layer); // @ts-ignore
+
+
+          _this.mapService.map.customCoords.setCenter(layerCenter); // @ts-ignore
+
+
+          _this.mapService.setCustomCoordCenter(layerCenter); // @ts-ignore
+
+
+          mvp = _this.mapService.map.customCoords.getMVPMatrix(); // mvp = amapCustomCoords.getMVPMatrix()
+          // @ts-ignore
+
+          sceneCenterMKT = _this.mapService.getCustomCoordCenter();
+        }
+
+        var _this$rendererService = _this.rendererService.getViewportSize(),
+            width = _this$rendererService.width,
+            height = _this$rendererService.height;
+
+        layer.models.forEach(function (model) {
+          var _model$addUniforms;
+
+          model.addUniforms((_model$addUniforms = {}, _defineProperty(_model$addUniforms, CameraUniform.ProjectionMatrix, _this.cameraService.getProjectionMatrix()), _defineProperty(_model$addUniforms, CameraUniform.ViewMatrix, _this.cameraService.getViewMatrix()), _defineProperty(_model$addUniforms, CameraUniform.ViewProjectionMatrix, _this.cameraService.getViewProjectionMatrix()), _defineProperty(_model$addUniforms, CameraUniform.Zoom, _this.cameraService.getZoom()), _defineProperty(_model$addUniforms, CameraUniform.ZoomScale, _this.cameraService.getZoomScale()), _defineProperty(_model$addUniforms, CameraUniform.FocalDistance, _this.cameraService.getFocalDistance()), _defineProperty(_model$addUniforms, CameraUniform.CameraPosition, _this.cameraService.getCameraPosition()), _defineProperty(_model$addUniforms, CoordinateUniform.CoordinateSystem, _this.coordinateSystemService.getCoordinateSystem()), _defineProperty(_model$addUniforms, CoordinateUniform.ViewportCenter, _this.coordinateSystemService.getViewportCenter()), _defineProperty(_model$addUniforms, CoordinateUniform.ViewportCenterProjection, _this.coordinateSystemService.getViewportCenterProjection()), _defineProperty(_model$addUniforms, CoordinateUniform.PixelsPerDegree, _this.coordinateSystemService.getPixelsPerDegree()), _defineProperty(_model$addUniforms, CoordinateUniform.PixelsPerDegree2, _this.coordinateSystemService.getPixelsPerDegree2()), _defineProperty(_model$addUniforms, CoordinateUniform.PixelsPerMeter, _this.coordinateSystemService.getPixelsPerMeter()), _defineProperty(_model$addUniforms, CoordinateUniform.Mvp, mvp), _defineProperty(_model$addUniforms, "u_SceneCenterMKT", sceneCenterMKT), _defineProperty(_model$addUniforms, "u_ViewportSize", [width, height]), _defineProperty(_model$addUniforms, "u_ModelMatrix", _this.cameraService.getModelMatrix()), _defineProperty(_model$addUniforms, "u_DevicePixelRatio", $window.devicePixelRatio), _defineProperty(_model$addUniforms, "u_PickingBuffer", layer.getLayerConfig().pickingBuffer || 0), _defineProperty(_model$addUniforms, "u_shaderPick", Number(layer.getShaderPickStat())), _model$addUniforms));
+        }); // TODO：脏检查，决定是否需要渲染
+      });
+    }
+  }, {
+    key: "getLayerCenter",
+    value: function getLayerCenter(layer) {
+      var source = layer.getSource();
+      return source.center;
+    }
+  }]);
+
+  return ShaderUniformPlugin;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "cameraService", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "coordinateSystemService", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "rendererService", [_dec4], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor4 = _applyDecoratedDescriptor(_class2.prototype, "mapService", [_dec5], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class2)) || _class);
+export { ShaderUniformPlugin as default };

package/es/plugins/UpdateModelPlugin.d.ts

@@ -0,0 +1,8 @@
+import { ILayer, ILayerPlugin } from '@antv/l7-core';
+import 'reflect-metadata';
+/**
+ * Model 更新
+ */
+export default class UpdateModelPlugin implements ILayerPlugin {
+    apply(layer: ILayer): void;
+}

package/es/plugins/UpdateModelPlugin.js

@@ -0,0 +1,31 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+var _dec, _class;
+
+import { injectable } from 'inversify';
+import 'reflect-metadata';
+/**
+ * Model 更新
+ */
+
+var UpdateModelPlugin = (_dec = injectable(), _dec(_class = /*#__PURE__*/function () {
+  function UpdateModelPlugin() {
+    _classCallCheck(this, UpdateModelPlugin);
+  }
+
+  _createClass(UpdateModelPlugin, [{
+    key: "apply",
+    value: function apply(layer) {
+      layer.hooks.beforeRender.tap('UpdateModelPlugin', function () {
+        // 处理文本更新
+        if (layer.layerModel) {
+          layer.layerModel.needUpdate();
+        }
+      });
+    }
+  }]);
+
+  return UpdateModelPlugin;
+}()) || _class);
+export { UpdateModelPlugin as default };

package/es/plugins/UpdateStyleAttributePlugin.d.ts

@@ -0,0 +1,12 @@
+import { ILayer, ILayerPlugin, IStyleAttributeService } from '@antv/l7-core';
+import 'reflect-metadata';
+/**
+ * 在初始化阶段完成属性的注册，以及首次根据 Layer 指定的三角化方法完成 indices 和 attribute 的创建
+ */
+export default class UpdateStyleAttributePlugin implements ILayerPlugin {
+    apply(layer: ILayer, { styleAttributeService, }: {
+        styleAttributeService: IStyleAttributeService;
+    }): void;
+    private updateStyleAttribute;
+    private initStyleAttribute;
+}