@antv/l7-layers 2.25.7 → 2.25.10

package/lib/line/shaders/line/line_frag.glsl

@@ -0,0 +1,122 @@
+// #extension GL_OES_standard_derivatives : enable
+#define Animate 0.0
+#define LineTexture 1.0
+
+uniform sampler2D u_texture;
+layout(std140) uniform commonUniorm {
+  vec4 u_animate: [ 1., 2., 1.0, 0.2 ];
+  vec4 u_dash_array;
+  vec4 u_blur;
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec2 u_textSize;
+  float u_icon_step: 100;
+  float u_heightfixed: 0.0;
+  float u_vertexScale: 1.0;
+  float u_raisingHeight: 0.0;
+  float u_strokeWidth: 0.0;
+  float u_textureBlend;
+  float u_line_texture;
+  float u_linearDir: 1.0;
+  float u_linearColor: 0;
+  float u_time;
+};
+
+in vec4 v_color;
+in vec4 v_stroke;
+// dash
+in vec4 v_dash_array;
+in float v_d_distance_ratio;
+in vec2 v_iconMapUV;
+in vec4 v_texture_data;
+
+out vec4 outputColor;
+#pragma include "picking"
+
+// [animate, duration, interval, trailLength],
+void main() {
+  if(u_dash_array!=vec4(0.0)){
+    float dashLength = mod(v_d_distance_ratio, v_dash_array.x + v_dash_array.y + v_dash_array.z + v_dash_array.w);
+    if(!(dashLength < v_dash_array.x || (dashLength > (v_dash_array.x + v_dash_array.y) && dashLength <  v_dash_array.x + v_dash_array.y + v_dash_array.z))) {
+      // 虚线部分
+      discard;
+    };
+  }
+  float animateSpeed = 0.0; // 运动速度
+  float d_distance_ratio = v_texture_data.r; // 当前点位距离占线总长的比例
+  if(u_linearDir < 1.0) {
+    d_distance_ratio = v_texture_data.a;
+  }
+  if(u_linearColor == 1.0) { // 使用渐变颜色
+    outputColor = mix(u_sourceColor, u_targetColor, d_distance_ratio);
+    outputColor.a *= v_color.a;
+  } else { // 使用 color 方法传入的颜色
+     outputColor = v_color;
+  }
+  // anti-alias
+  // float blur = 1.0 - smoothstep(u_blur, 1., length(v_normal.xy));
+  if(u_animate.x == Animate) {
+      animateSpeed = u_time / u_animate.y;
+       float alpha =1.0 - fract( mod(1.0- d_distance_ratio, u_animate.z)* (1.0/ u_animate.z) + animateSpeed);
+      alpha = (alpha + u_animate.w -1.0) / u_animate.w;
+      alpha = smoothstep(0., 1., alpha);
+      outputColor.a *= alpha;
+  }
+
+  if(u_line_texture == LineTexture) { // while load texture
+    float aDistance = v_texture_data.g;      // 当前顶点的距离
+    float d_texPixelLen = v_texture_data.b;  // 贴图的像素长度，根据地图层级缩放
+    float u = fract(mod(aDistance, d_texPixelLen)/d_texPixelLen - animateSpeed);
+    float v = v_texture_data.a;  // 线图层贴图部分的 v 坐标值
+
+    // v = max(smoothstep(0.95, 1.0, v), v);
+    vec2 uv= v_iconMapUV / u_textSize + vec2(u, v) / u_textSize * 64.;
+     vec4 pattern = texture(SAMPLER_2D(u_texture), uv);
+
+    if(u_textureBlend == 0.0) { // normal
+      pattern.a = 0.0;
+      outputColor += pattern;
+    } else { // replace
+        pattern.a *= v_color.a;
+        if(outputColor.a <= 0.0) {
+          pattern.a = 0.0;
+        }
+        outputColor = pattern;
+    }
+  } 
+
+  float v = v_texture_data.a;
+  float strokeWidth = min(0.5, u_strokeWidth);
+  // 绘制 border
+  if(strokeWidth > 0.01) {
+    float borderOuterWidth = strokeWidth / 2.0;
+
+
+    if(v >= 1.0 - strokeWidth || v <= strokeWidth) {
+      if(v > strokeWidth) { // 外侧
+        float linear = smoothstep(0.0, 1.0, (v - (1.0 - strokeWidth))/strokeWidth);
+        //  float linear = step(0.0, (v - (1.0 - borderWidth))/borderWidth);
+        outputColor.rgb = mix(outputColor.rgb, v_stroke.rgb, linear);
+      } else if(v <= strokeWidth) {
+        float linear = smoothstep(0.0, 1.0, v/strokeWidth);
+        outputColor.rgb = mix(v_stroke.rgb, outputColor.rgb, linear);
+      }
+    }
+
+    if(v < borderOuterWidth) {
+      outputColor.a = mix(0.0, outputColor.a, v/borderOuterWidth);
+    } else if(v > 1.0 - borderOuterWidth) {
+      outputColor.a = mix(outputColor.a, 0.0, (v - (1.0 - borderOuterWidth))/borderOuterWidth);
+    }
+  }
+
+  // blur
+  float blurV = v_texture_data.a;
+  if(blurV < 0.5) {
+    outputColor.a *= mix(u_blur.r, u_blur.g, blurV/0.5);
+  } else {
+    outputColor.a *= mix(u_blur.g, u_blur.b, (blurV - 0.5)/0.5);
+  }
+  
+  outputColor = filterColor(outputColor);
+}

package/lib/line/shaders/line/line_vert.glsl

@@ -0,0 +1,101 @@
+#define Animate (0.0)
+
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_POSITION_64LOW) in vec2 a_Position64Low;
+layout(location = ATTRIBUTE_LOCATION_COLOR) in vec4 a_Color;
+layout(location = ATTRIBUTE_LOCATION_SIZE) in vec2 a_Size;
+layout(location = ATTRIBUTE_LOCATION_DISTANCE_INDEX) in vec3 a_DistanceAndIndexAndMiter;
+layout(location = ATTRIBUTE_LOCATION_NORMAL) in vec4 a_Normal_Total_Distance;
+layout(location = ATTRIBUTE_LOCATION_UV) in vec2 a_iconMapUV;
+
+layout(std140) uniform commonUniorm {
+  vec4 u_animate: [ 1., 2., 1.0, 0.2 ];
+  vec4 u_dash_array;
+  vec4 u_blur;
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec2 u_textSize;
+  float u_icon_step: 100;
+  float u_heightfixed: 0.0;
+  float u_vertexScale: 1.0;
+  float u_raisingHeight: 0.0;
+  float u_strokeWidth: 0.0;
+  float u_textureBlend;
+  float u_line_texture;
+  float u_linearDir: 1.0;
+  float u_linearColor: 0;
+  float u_time;
+};
+
+out vec4 v_color;
+out vec4 v_stroke;
+//dash
+out vec4 v_dash_array;
+out float v_d_distance_ratio;
+// texV 线图层 - 贴图部分的 v 坐标（线的宽度方向）
+out vec2 v_iconMapUV;
+out vec4 v_texture_data;
+
+#pragma include "projection"
+#pragma include "picking"
+
+void main() {
+  vec2 a_DistanceAndIndex = a_DistanceAndIndexAndMiter.xy;
+  float a_Miter = a_DistanceAndIndexAndMiter.z;
+  vec3 a_Normal = a_Normal_Total_Distance.xyz;
+  float a_Total_Distance = a_Normal_Total_Distance.w;
+  //dash输出
+  v_dash_array = pow(2.0, 20.0 - u_Zoom) * u_dash_array / a_Total_Distance;
+  v_d_distance_ratio = a_DistanceAndIndex.x / a_Total_Distance;
+
+  // cal style mapping - 数据纹理映射部分的计算
+  float d_texPixelLen; // 贴图的像素长度，根据地图层级缩放
+  v_iconMapUV = a_iconMapUV;
+  d_texPixelLen = project_float_pixel(u_icon_step);
+
+  v_color = a_Color;
+  v_color.a *= opacity;
+  v_stroke = stroke;
+
+  vec3 size = a_Miter * setPickingSize(a_Size.x) * a_Normal;
+
+  vec2 offset = project_pixel(size.xy);
+
+  float lineDistance = a_DistanceAndIndex.x;
+  float currentLinePointRatio = lineDistance / a_Total_Distance;
+
+  float lineOffsetWidth = length(offset + offset * sign(a_Miter)); // 线横向偏移的距离（向两侧偏移的和）
+  float linePixelSize = project_pixel(a_Size.x) * 2.0; // 定点位置偏移，按地图等级缩放后的距离 单侧 * 2
+  float texV = lineOffsetWidth / linePixelSize; // 线图层贴图部分的 v 坐标值
+
+  v_texture_data = vec4(currentLinePointRatio, lineDistance, d_texPixelLen, texV);
+  // 设置数据集的参数
+
+  vec4 project_pos = project_position(vec4(a_Position.xy, 0, 1.0), a_Position64Low);
+
+  // gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy + offset, a_Size.y, 1.0));
+
+  float h = float(a_Position.z) * u_vertexScale; // 线顶点的高度 - 兼容不存在第三个数值的情况 vertex height
+  float lineHeight = a_Size.y; // size 第二个参数代表的高度 [linewidth, lineheight]
+
+  // 兼容 mapbox 在线高度上的效果表现基本一致
+  if (
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET
+  ) {
+    // mapbox
+    // 保持高度相对不变
+    float mapboxZoomScale = 4.0 / pow(2.0, 21.0 - u_Zoom);
+    h *= mapboxZoomScale;
+    h += u_raisingHeight * mapboxZoomScale;
+    if (u_heightfixed > 0.0) {
+      lineHeight *= mapboxZoomScale;
+    }
+  }
+
+  gl_Position = project_common_position_to_clipspace(
+    vec4(project_pos.xy + offset, lineHeight + h, 1.0)
+  );
+
+  setPickingColor(a_PickingColor);
+}

package/lib/line/shaders/simple/simpleline_frag.glsl

@@ -0,0 +1,30 @@
+
+layout(std140) uniform commonUniorm {
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec4 u_dash_array;
+  float u_vertexScale: 1.0;
+  float u_linearColor: 0;
+};
+in float v_distanceScale;
+in vec4 v_color;
+//dash
+in vec4 v_dash_array;
+
+out vec4 outputColor;
+void main() {
+  if(u_dash_array!=vec4(0.0)){
+    float dashLength = mod(v_distanceScale, v_dash_array.x + v_dash_array.y + v_dash_array.z + v_dash_array.w);
+    if(!(dashLength < v_dash_array.x || (dashLength > (v_dash_array.x + v_dash_array.y) && dashLength <  v_dash_array.x + v_dash_array.y + v_dash_array.z))) {
+      // 虚线部分
+      discard;
+    };
+  }
+  if(u_linearColor==1.0){
+    outputColor = mix(u_sourceColor, u_targetColor, v_distanceScale);
+    outputColor.a *= v_color.a; // 全局透明度
+  }
+  else{
+    outputColor = v_color;
+  }
+}

package/lib/line/shaders/simple/simpleline_vert.glsl

@@ -0,0 +1,45 @@
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_POSITION_64LOW) in vec2 a_Position64Low;
+layout(location = ATTRIBUTE_LOCATION_COLOR) in vec4 a_Color;
+layout(location = ATTRIBUTE_LOCATION_SIZE) in vec4 a_SizeDistanceAndTotalDistance;
+
+layout(std140) uniform commonUniorm {
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec4 u_dash_array;
+  float u_vertexScale: 1.0;
+  float u_linearColor: 0;
+};
+
+#pragma include "projection"
+#pragma include "picking"
+
+out vec4 v_color;
+out float v_distanceScale;
+out vec4 v_dash_array;
+
+void main() {
+  //dash输出
+  v_dash_array = pow(2.0, 20.0 - u_Zoom) * u_dash_array / a_SizeDistanceAndTotalDistance.a;
+
+  v_color = a_Color;
+  v_distanceScale = a_SizeDistanceAndTotalDistance.b / a_SizeDistanceAndTotalDistance.a;
+  v_color.a = v_color.a * opacity;
+  vec4 project_pos = project_position(vec4(a_Position.xy, 0, 1.0), a_Position64Low);
+
+  float h = float(a_Position.z) * u_vertexScale; // 线顶点的高度 - 兼容不存在第三个数值的情况
+
+  float lineHeight = a_SizeDistanceAndTotalDistance.y;
+  // 兼容 mapbox 在线高度上的效果表现基本一致
+  if (
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET
+  ) {
+    // 保持高度相对不变
+    h *= 2.0 / pow(2.0, 20.0 - u_Zoom);
+  }
+
+  gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy, lineHeight + h, 1.0));
+  gl_PointSize = 10.0;
+
+}

package/lib/line/shaders/wall/wall_frag.glsl

@@ -0,0 +1,94 @@
+#define Animate 0.0
+#define LineTexture 1.0
+
+// line texture
+
+uniform sampler2D u_texture;
+layout(std140) uniform commonUniorm {
+  vec4 u_animate: [ 1., 2., 1.0, 0.2 ];
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec2 u_textSize;
+  float u_icon_step: 100;
+  float u_heightfixed;
+  float u_linearColor: 0;
+  float u_line_texture;
+  float u_textureBlend;
+  float u_iconStepCount;
+  float u_time;
+};
+
+
+in vec2 v_iconMapUV;
+in vec4 v_color;
+in float v_blur;
+in vec4 v_dataset;
+
+out vec4 outputColor;
+
+#pragma include "picking"
+
+void main() {
+  float animateSpeed = 0.0; // 运动速度
+  float d_distance_ratio = v_dataset.r; // 当前点位距离占线总长的比例
+  float v = v_dataset.a;
+
+  if(u_linearColor == 1.0) { // 使用渐变颜色
+    outputColor = mix(u_sourceColor, u_targetColor, v);
+  } else { // 使用 color 方法传入的颜色
+     outputColor = v_color;
+  }
+
+  outputColor.a *= v_color.a; // 全局透明度
+  if(u_animate.x == Animate) {
+      animateSpeed = u_time / u_animate.y;
+       float alpha =1.0 - fract( mod(1.0- d_distance_ratio, u_animate.z)* (1.0/ u_animate.z) + animateSpeed);
+      alpha = (alpha + u_animate.w -1.0) / u_animate.w;
+      alpha = smoothstep(0., 1., alpha);
+      outputColor.a *= alpha;
+  }
+
+  if(u_line_texture == LineTexture) { // while load texture
+    float aDistance = v_dataset.g;      // 当前顶点的距离
+    float d_texPixelLen = v_dataset.b;  // 贴图的像素长度，根据地图层级缩放
+    float u = fract(mod(aDistance, d_texPixelLen)/d_texPixelLen - animateSpeed);
+    float v = v_dataset.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 = texture(SAMPLER_2D(u_texture), uv);
+
+    // Tip: 判断纹理间隔
+    if(flag > 0.0) {
+      pattern = vec4(0.0);
+    }
+
+    if(u_textureBlend == 0.0) { // normal
+      pattern.a = 0.0;
+      outputColor = filterColor(outputColor + pattern);
+    } else { // replace
+        pattern.a *= v_color.a;
+        if(outputColor.a <= 0.0) {
+          pattern.a = 0.0;
+        }
+        outputColor = filterColor(pattern);
+    }
+  }
+
+
+  // blur - AA
+  if(v < v_blur) {
+    outputColor.a = mix(0.0, outputColor.a, v/v_blur);
+  } else if(v > 1.0 - v_blur) {
+    outputColor.a = mix(outputColor.a, 0.0, (v - (1.0 - v_blur))/v_blur);
+  }
+
+  outputColor = filterColor(outputColor);
+}

package/lib/line/shaders/wall/wall_vert.glsl

@@ -0,0 +1,90 @@
+#define Animate 0.0
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_POSITION_64LOW) in vec2 a_Position64Low;
+layout(location = ATTRIBUTE_LOCATION_COLOR) in vec4 a_Color;
+layout(location = ATTRIBUTE_LOCATION_SIZE) in vec2 a_Size;
+layout(location = ATTRIBUTE_LOCATION_NORMAL) in vec3 a_Normal;
+layout(location = ATTRIBUTE_LOCATION_UV) in vec2 a_iconMapUV;
+layout(location = ATTRIBUTE_LOCATION_DISTANCE_MITER_TOTAL) in vec3 a_Distance_Total_Miter;
+
+layout(std140) uniform commonUniorm {
+  vec4 u_animate: [ 1., 2., 1.0, 0.2 ];
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec2 u_textSize;
+  float u_icon_step: 100;
+  float u_heightfixed;
+  float u_linearColor: 0;
+  float u_line_texture;
+  float u_textureBlend;
+  float u_iconStepCount;
+  float u_time;
+};
+
+// texV 线图层 - 贴图部分的 v 坐标（线的宽度方向）
+out vec2 v_iconMapUV;
+out vec4 v_color;
+out float v_blur;
+out vec4 v_dataset;
+
+#pragma include "projection"
+#pragma include "light"
+#pragma include "picking"
+
+void main() {
+  float a_Distance = a_Distance_Total_Miter.x;
+  float a_Miter = a_Distance_Total_Miter.y;
+  float a_Total_Distance = a_Distance_Total_Miter.z;
+
+  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_animate.x == Animate || u_linearColor == 1.0) {
+    d_distance_ratio = a_Distance / a_Total_Distance;
+  }
+
+  float miter = (a_Miter + 1.0) / 2.0;
+  // 设置数据集的参数
+  v_dataset[0] = d_distance_ratio; // 当前点位距离占线总长的比例
+  v_dataset[1] = a_Distance; // 当前顶点的距离
+  v_dataset[2] = d_texPixelLen; // 贴图的像素长度，根据地图层级缩放
+  v_dataset[3] = miter; // 线图层贴图部分的 v 坐标值 0 - 1
+
+  vec4 project_pos = project_position(vec4(a_Position.xy, 0, 1.0), a_Position64Low);
+
+  float originSize = a_Size.x; // 固定高度
+  if (u_heightfixed < 1.0) {
+    originSize = project_float_meter(a_Size.x); // 高度随 zoom 调整
+  }
+
+  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 * opacity);
+
+  // 兼容 mapbox 在线高度上的效果表现基本一致
+  if (
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET
+  ) {
+    // mapbox
+    // 保持高度相对不变
+    float mapboxZoomScale = 4.0 / pow(2.0, 21.0 - u_Zoom);
+    if (u_heightfixed > 0.0) {
+      wallHeight *= mapboxZoomScale;
+    }
+  }
+
+  gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy, wallHeight, 1.0));
+
+  setPickingColor(a_PickingColor);
+}

package/lib/mask/index.d.ts

@@ -0,0 +1,16 @@
+import BaseLayer from '../core/BaseLayer';
+import type { IMaskLayerStyleOptions } from '../core/interface';
+import type { MaskModelType } from './models';
+export default class MaskLayer extends BaseLayer<IMaskLayerStyleOptions> {
+    type: string;
+    defaultSourceConfig: {
+        data: [];
+        options: {
+            parser: {
+                type: 'geojson';
+            };
+        };
+    };
+    buildModels(): Promise<void>;
+    getModelType(): MaskModelType;
+}

package/lib/mask/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _BaseLayer = _interopRequireDefault(require("../core/BaseLayer"));
+var _models = _interopRequireDefault(require("./models"));
+class MaskLayer extends _BaseLayer.default {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "type", 'MaskLayer');
+  }
+  buildModels() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      const shape = _this.getModelType();
+      _this.layerModel = new _models.default[shape](_this);
+      yield _this.initLayerModels();
+    })();
+  }
+  getModelType() {
+    return 'fill';
+  }
+}
+exports.default = MaskLayer;

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

@@ -0,0 +1,18 @@
+import type { IModel } from '@antv/l7-core';
+import BaseModel from '../../core/BaseModel';
+export default class MaskModel extends BaseModel {
+    getUninforms(): {
+        [x: string]: any;
+    };
+    protected getCommonUniformsInfo(): {
+        uniformsArray: number[];
+        uniformsLength: number;
+        uniformsOption: {
+            [key: string]: any;
+        };
+    };
+    initModels(): Promise<IModel[]>;
+    buildModels(): Promise<IModel[]>;
+    clearModels(refresh?: boolean): void;
+    protected registerBuiltinAttributes(): string;
+}

package/lib/mask/models/fill.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _l7Utils = require("@antv/l7-utils");
+var _BaseModel = _interopRequireDefault(require("../../core/BaseModel"));
+var _triangulation = require("../../core/triangulation");
+/* babel-plugin-inline-import '../../shader/minify_frag.glsl' */
+const mask_frag = "layout(std140) uniform commonUniorm {\n  vec4 u_color;\n  float u_opacity;\n};\n\nout vec4 outputColor;\n\nvoid main() {\n  outputColor = u_color;\n  outputColor.a *= u_opacity;\n}\n";
+/* babel-plugin-inline-import '../shaders/mask_vert.glsl' */
+const mask_vert = "layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;\n\nlayout(std140) uniform commonUniorm {\n  vec4 u_color;\n  float u_opacity;\n};\n\n#pragma include \"projection\"\n\nvoid main() {\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\n";
+class MaskModel extends _BaseModel.default {
+  getUninforms() {
+    const commoninfo = this.getCommonUniformsInfo();
+    const attributeInfo = this.getUniformsBufferInfo(this.getStyleAttribute());
+    this.updateStyleUnifoms();
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, commoninfo.uniformsOption), attributeInfo.uniformsOption);
+  }
+  getCommonUniformsInfo() {
+    const {
+      opacity = 1,
+      color = '#000'
+    } = this.layer.getLayerConfig();
+    const commonOptions = {
+      u_color: (0, _l7Utils.rgb2arr)(color),
+      u_opacity: opacity || 1
+    };
+    const commonBufferInfo = this.getUniformsBufferInfo(commonOptions);
+    return commonBufferInfo;
+  }
+  initModels() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      return _this.buildModels();
+    })();
+  }
+  buildModels() {
+    var _this2 = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      _this2.initUniformsBuffer();
+      const model = yield _this2.layer.buildLayerModel({
+        moduleName: 'mask',
+        vertexShader: mask_vert,
+        fragmentShader: mask_frag,
+        defines: _this2.getDefines(),
+        triangulation: _triangulation.polygonTriangulation,
+        depth: {
+          enable: false
+        },
+        pick: false
+      });
+      return [model];
+    })();
+  }
+  clearModels(refresh = true) {
+    if (refresh) {
+      this.layerService.clear();
+    }
+  }
+  registerBuiltinAttributes() {
+    return '';
+  }
+}
+exports.default = MaskModel;

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

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

package/lib/mask/models/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fill = _interopRequireDefault(require("./fill"));
+const MaskModels = {
+  fill: _fill.default
+};
+var _default = exports.default = MaskModels;

package/lib/mask/shaders/mask_vert.glsl

@@ -0,0 +1,14 @@
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+
+layout(std140) uniform commonUniorm {
+  vec4 u_color;
+  float u_opacity;
+};
+
+#pragma include "projection"
+
+void main() {
+  vec4 project_pos = project_position(vec4(a_Position, 1.0));
+  gl_Position = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+}
+

package/lib/plugins/DataMappingPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { ILayer, ILayerPlugin, L7Container } from '@antv/l7-core';
+export default class DataMappingPlugin implements ILayerPlugin {
+    private mapService;
+    private fontService;
+    apply(layer: ILayer, { styleAttributeService, mapService, fontService }: L7Container): void;
+    private generateMaping;
+    private mapping;
+    private adjustData2SimpleCoordinates;
+    private unProjectCoordinates;
+    private applyAttributeMapping;
+    private getArrowPoints;
+}