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

package/es/line/shaders/wall_frag.glsl

@@ -0,0 +1,93 @@
+#define Animate 0.0
+#define LineTexture 1.0
+
+uniform float u_opacity : 1.0;
+uniform float u_textureBlend;
+uniform float u_iconStepCount;
+
+varying vec4 v_color;
+
+// line texture
+uniform float u_line_texture;
+uniform sampler2D u_texture;
+uniform vec2 u_textSize;
+
+varying vec2 v_iconMapUV;
+varying float v_blur;
+
+uniform float u_linearColor: 0;
+uniform vec4 u_sourceColor;
+uniform vec4 u_targetColor;
+
+#pragma include "picking"
+
+uniform float u_time;
+uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ]; // 控制运动
+
+varying mat4 styleMappingMat;
+// [animate, duration, interval, trailLength],
+void main() {
+  float opacity = styleMappingMat[0][0];
+  float animateSpeed = 0.0; // 运动速度
+  float d_distance_ratio = styleMappingMat[3].r; // 当前点位距离占线总长的比例
+  float v = styleMappingMat[3].a;
+
+  if(u_linearColor == 1.0) { // 使用渐变颜色
+    gl_FragColor = mix(u_sourceColor, u_targetColor, v);
+  } else { // 使用 color 方法传入的颜色
+     gl_FragColor = v_color;
+  }
+
+  gl_FragColor.a *= opacity; // 全局透明度
+  if(u_aimate.x == Animate) {
+      animateSpeed = u_time / u_aimate.y;
+       float alpha =1.0 - fract( mod(1.0- d_distance_ratio, u_aimate.z)* (1.0/ u_aimate.z) + animateSpeed);
+      alpha = (alpha + u_aimate.w -1.0) / u_aimate.w;
+      alpha = smoothstep(0., 1., alpha);
+      gl_FragColor.a *= alpha;
+  }
+
+  if(u_line_texture == LineTexture) { // while load texture
+    float aDistance = styleMappingMat[3].g;      // 当前顶点的距离
+    float d_texPixelLen = styleMappingMat[3].b;  // 贴图的像素长度，根据地图层级缩放
+    float u = fract(mod(aDistance, d_texPixelLen)/d_texPixelLen - animateSpeed);
+    float v = styleMappingMat[3].a;  // 线图层贴图部分的 v 坐标值
+
+    // 计算纹理间隔 start
+    float flag = 0.0;
+    if(u > 1.0/u_iconStepCount) {
+      flag = 1.0;
+    }
+    u = fract(u*u_iconStepCount);
+    // 计算纹理间隔 end
+
+    vec2 uv= v_iconMapUV / u_textSize + vec2(u, v) / u_textSize * 64.;
+    vec4 pattern = texture2D(u_texture, uv);
+
+    // Tip: 判断纹理间隔
+    if(flag > 0.0) {
+      pattern = vec4(0.0);
+    }
+
+    if(u_textureBlend == 0.0) { // normal
+      pattern.a = 0.0;
+      gl_FragColor = filterColor(gl_FragColor + pattern);
+    } else { // replace
+        pattern.a *= opacity;
+        if(gl_FragColor.a <= 0.0) {
+          pattern.a = 0.0;
+        }
+        gl_FragColor = filterColor(pattern);
+    }
+  }
+  
+
+  // blur - AA
+  if(v < v_blur) {
+    gl_FragColor.a = mix(0.0, gl_FragColor.a, v/v_blur);
+  } else if(v > 1.0 - v_blur) {
+    gl_FragColor.a = mix(gl_FragColor.a, 0.0, (v - (1.0 - v_blur))/v_blur);
+  }
+
+  gl_FragColor = filterColor(gl_FragColor);
+}

package/es/line/shaders/wall_vert.glsl

@@ -0,0 +1,111 @@
+#define Animate 0.0
+
+attribute float a_Miter;
+attribute vec4 a_Color;
+attribute vec2 a_Size;
+attribute vec3 a_Normal;
+attribute vec3 a_Position;
+attribute vec2 a_iconMapUV;
+
+attribute float a_Total_Distance;
+attribute float a_Distance;
+
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ];
+uniform float u_icon_step: 100;
+uniform float u_heightfixed;
+
+#pragma include "projection"
+#pragma include "light"
+#pragma include "picking"
+
+varying vec4 v_color;
+varying float v_blur;
+
+// texV 线图层 - 贴图部分的 v 坐标（线的宽度方向）
+varying vec2 v_iconMapUV;
+
+uniform float u_linearColor: 0;
+
+uniform float u_opacity: 1.0;
+varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
+
+#pragma include "styleMapping"
+#pragma include "light"
+#pragma include "styleMappingCalOpacity"
+
+void main() {
+  // cal style mapping - 数据纹理映射部分的计算
+  styleMappingMat = mat4(
+    0.0, 0.0, 0.0, 0.0, // opacity - strokeOpacity - strokeWidth - empty
+    0.0, 0.0, 0.0, 0.0, // strokeR - strokeG - strokeB - strokeA
+    0.0, 0.0, 0.0, 0.0, // offsets[0] - offsets[1]
+    0.0, 0.0, 0.0, 0.0  // distance_ratio/distance/pixelLen/texV
+  );
+
+  float rowCount = u_cellTypeLayout[0][0];    // 当前的数据纹理有几行
+  float columnCount = u_cellTypeLayout[0][1]; // 当看到数据纹理有几列
+  float columnWidth = 1.0/columnCount;  // 列宽
+  float rowHeight = 1.0/rowCount;       // 行高
+  float cellCount = calCellCount(); // opacity - strokeOpacity - strokeWidth - stroke - offsets
+  float id = a_vertexId; // 第n个顶点
+  float cellCurrentRow = floor(id * cellCount / columnCount) + 1.0; // 起始点在第几行
+  float cellCurrentColumn = mod(id * cellCount, columnCount) + 1.0; // 起始点在第几列
+  
+  // cell 固定顺序 opacity -> strokeOpacity -> strokeWidth -> stroke ... 
+  // 按顺序从 cell 中取值、若没有则自动往下取值
+  float textureOffset = 0.0; // 在 cell 中取值的偏移量
+
+  vec2 opacityAndOffset = calOpacityAndOffset(cellCurrentRow, cellCurrentColumn, columnCount, textureOffset, columnWidth, rowHeight);
+  styleMappingMat[0][0] = opacityAndOffset.r;
+  textureOffset = opacityAndOffset.g;
+  // cal style mapping - 数据纹理映射部分的计算
+
+  float d_distance_ratio; // 当前点位距离占线总长的比例
+  float d_texPixelLen;    // 贴图的像素长度，根据地图层级缩放
+
+  v_iconMapUV = a_iconMapUV;
+  if(u_heightfixed < 1.0) {     // 高度随 zoom 调整
+    d_texPixelLen = project_pixel(u_icon_step);
+  } else {
+    d_texPixelLen = u_icon_step;
+  }
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
+    d_texPixelLen *= 10.0;
+  }
+
+  if(u_aimate.x == Animate || u_linearColor == 1.0) {
+      d_distance_ratio = a_Distance / a_Total_Distance;
+  }
+
+  float miter = (a_Miter + 1.0)/2.0;
+  // 设置数据集的参数
+  styleMappingMat[3][0] = d_distance_ratio; // 当前点位距离占线总长的比例
+  styleMappingMat[3][1] = a_Distance;       // 当前顶点的距离
+  styleMappingMat[3][2] = d_texPixelLen;    // 贴图的像素长度，根据地图层级缩放
+  styleMappingMat[3][3] = miter;          // 线图层贴图部分的 v 坐标值 0 - 1
+
+  vec4 project_pos = project_position(vec4(a_Position.xy, 0, 1.0));
+
+  float originSize = a_Size.x;  // 固定高度
+  if(u_heightfixed < 1.0) {     // 高度随 zoom 调整
+    originSize = project_float_pixel(a_Size.x);
+  }
+
+  float wallHeight = originSize * miter;
+  float lightWeight = calc_lighting(vec4(project_pos.xy, wallHeight, 1.0));
+
+  v_blur = min(project_float_pixel(2.0) / originSize, 0.05);
+
+  v_color = vec4(a_Color.rgb * lightWeight, a_Color.w);
+  // v_color = a_Color;
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(project_pos.xy, wallHeight, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy, wallHeight, 1.0));
+  }
+
+  setPickingColor(a_PickingColor);
+}

package/es/mask/index.d.ts

@@ -0,0 +1,18 @@
+import BaseLayer from '../core/BaseLayer';
+import { IMaskLayerStyleOptions } from '../core/interface';
+import { MaskModelType } from './models';
+export default class MaskLayer extends BaseLayer<IMaskLayerStyleOptions> {
+    type: string;
+    buildModels(): void;
+    rebuildModels(): void;
+    protected getConfigSchema(): {
+        properties: {
+            opacity: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+    };
+    protected getModelType(): MaskModelType;
+}

package/es/mask/index.js

@@ -0,0 +1,82 @@
+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";
+
+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; } }
+
+import BaseLayer from "../core/BaseLayer";
+import MaskModels from "./models";
+
+var MaskLayer = /*#__PURE__*/function (_BaseLayer) {
+  _inherits(MaskLayer, _BaseLayer);
+
+  var _super = _createSuper(MaskLayer);
+
+  function MaskLayer() {
+    var _this;
+
+    _classCallCheck(this, MaskLayer);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "type", 'MaskLayer');
+
+    return _this;
+  }
+
+  _createClass(MaskLayer, [{
+    key: "buildModels",
+    value: function buildModels() {
+      var _this2 = this;
+
+      var shape = this.getModelType();
+      this.layerModel = new MaskModels[shape](this);
+      this.layerModel.initModels(function (models) {
+        _this2.models = models;
+
+        _this2.renderLayers();
+      });
+    }
+  }, {
+    key: "rebuildModels",
+    value: function rebuildModels() {
+      var _this3 = this;
+
+      this.layerModel.buildModels(function (models) {
+        return _this3.models = models;
+      });
+    }
+  }, {
+    key: "getConfigSchema",
+    value: function getConfigSchema() {
+      return {
+        properties: {
+          opacity: {
+            type: 'number',
+            minimum: 0,
+            maximum: 1
+          }
+        }
+      };
+    }
+  }, {
+    key: "getModelType",
+    value: function getModelType() {
+      return 'fill';
+    }
+  }]);
+
+  return MaskLayer;
+}(BaseLayer);
+
+export { MaskLayer as default };

package/es/mask/models/fill.d.ts

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

package/es/mask/models/fill.js

@@ -0,0 +1,121 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+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; } }
+
+import { gl } from '@antv/l7-core';
+import { isNumber } from 'lodash';
+import BaseModel from "../../core/BaseModel";
+import { polygonTriangulation } from "../../core/triangulation";
+
+/* babel-plugin-inline-import '../shaders/mask_frag.glsl' */
+var mask_frag = "uniform float u_opacity;\nvarying vec4 v_Color;\n\nvoid main() {\n  gl_FragColor = v_Color;\n  gl_FragColor.a *= u_opacity;\n}\n";
+
+/* babel-plugin-inline-import '../shaders/mask_vert.glsl' */
+var mask_vert = "attribute vec4 a_Color;\nattribute vec3 a_Position;\nuniform mat4 u_ModelMatrix;\nuniform mat4 u_Mvp;\n\nvarying vec4 v_Color;\n\n#pragma include \"projection\"\n\nvoid main() {\n\n  v_Color = a_Color;\n  vec4 project_pos = project_position(vec4(a_Position, 1.0));\n  // gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));\n\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x\n    gl_Position = u_Mvp * (vec4(project_pos.xyz, 1.0));\n  } else {\n    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));\n  }\n}\n\n";
+
+var MaskModel = /*#__PURE__*/function (_BaseModel) {
+  _inherits(MaskModel, _BaseModel);
+
+  var _super = _createSuper(MaskModel);
+
+  function MaskModel() {
+    _classCallCheck(this, MaskModel);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(MaskModel, [{
+    key: "getUninforms",
+    value: function getUninforms() {
+      var _ref = this.layer.getLayerConfig(),
+          _ref$opacity = _ref.opacity,
+          opacity = _ref$opacity === void 0 ? 0 : _ref$opacity;
+
+      return {
+        u_opacity: isNumber(opacity) ? opacity : 0.0
+      };
+    }
+  }, {
+    key: "initModels",
+    value: function initModels(callbackModel) {
+      this.buildModels(callbackModel);
+    }
+  }, {
+    key: "buildModels",
+    value: function () {
+      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(callbackModel) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                this.layer.buildLayerModel({
+                  moduleName: 'mask',
+                  vertexShader: mask_vert,
+                  fragmentShader: mask_frag,
+                  triangulation: polygonTriangulation,
+                  depth: {
+                    enable: false
+                  },
+                  blend: this.getBlend(),
+                  stencil: {
+                    enable: true,
+                    mask: 0xff,
+                    func: {
+                      cmp: gl.ALWAYS,
+                      ref: 1,
+                      mask: 0xff
+                    },
+                    opFront: {
+                      fail: gl.REPLACE,
+                      zfail: gl.REPLACE,
+                      zpass: gl.REPLACE
+                    }
+                  }
+                }).then(function (model) {
+                  callbackModel([model]);
+                }).catch(function (err) {
+                  console.warn(err);
+                  callbackModel([]);
+                });
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function buildModels(_x) {
+        return _buildModels.apply(this, arguments);
+      }
+
+      return buildModels;
+    }()
+  }, {
+    key: "clearModels",
+    value: function clearModels() {
+      var _this$dataTexture;
+
+      (_this$dataTexture = this.dataTexture) === null || _this$dataTexture === void 0 ? void 0 : _this$dataTexture.destroy();
+      this.layerService.clear();
+    }
+  }, {
+    key: "registerBuiltinAttributes",
+    value: function registerBuiltinAttributes() {
+      return '';
+    }
+  }]);
+
+  return MaskModel;
+}(BaseModel);
+
+export { MaskModel as default };

package/es/mask/models/index.d.ts

@@ -0,0 +1,5 @@
+export declare type MaskModelType = 'fill';
+declare const MaskModels: {
+    [key in MaskModelType]: any;
+};
+export default MaskModels;

package/es/mask/models/index.js

@@ -0,0 +1,5 @@
+import FillModel from "./fill";
+var MaskModels = {
+  fill: FillModel
+};
+export default MaskModels;

package/es/mask/shaders/mask_frag.glsl

@@ -0,0 +1,7 @@
+uniform float u_opacity;
+varying vec4 v_Color;
+
+void main() {
+  gl_FragColor = v_Color;
+  gl_FragColor.a *= u_opacity;
+}

package/es/mask/shaders/mask_vert.glsl

@@ -0,0 +1,22 @@
+attribute vec4 a_Color;
+attribute vec3 a_Position;
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+
+varying vec4 v_Color;
+
+#pragma include "projection"
+
+void main() {
+
+  v_Color = a_Color;
+  vec4 project_pos = project_position(vec4(a_Position, 1.0));
+  // gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(project_pos.xyz, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+  }
+}
+

package/es/plugins/DataMappingPlugin.d.ts

@@ -0,0 +1,18 @@
+import { ILayer, ILayerPlugin, IStyleAttributeService } from '@antv/l7-core';
+import 'reflect-metadata';
+export default class DataMappingPlugin implements ILayerPlugin {
+    private readonly configService;
+    private readonly mapService;
+    private readonly fontService;
+    apply(layer: ILayer, { styleAttributeService, }: {
+        styleAttributeService: IStyleAttributeService;
+    }): void;
+    private generateMaping;
+    private getArrowPoints;
+    private mapping;
+    private adjustData2Amap2Coordinates;
+    private getLayerCenter;
+    private adjustData2SimpleCoordinates;
+    private unProjectCoordinates;
+    private applyAttributeMapping;
+}