@antv/l7-layers 2.9.27-alpha.1 → 2.9.27-alpha.3

package/es/line/shaders/line_frag.glsl

@@ -19,7 +19,7 @@ varying vec2 v_iconMapUV;
 #pragma include "picking"
 
 uniform float u_time;
-uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ]; // 控制运动
+uniform vec4 u_aimate: [ 1, 2., 1.0, 0.2 ]; // 控制运动
 
 varying mat4 styleMappingMat;
 // [animate, duration, interval, trailLength],
@@ -95,6 +95,5 @@ void main() {
     gl_FragColor.a *= mix(u_blur.g, u_blur.b, (blurV - 0.5)/0.5);
   }
   
-
   gl_FragColor = filterColor(gl_FragColor);
 }

package/es/line/shaders/line_vert.glsl

@@ -15,7 +15,7 @@ attribute vec2 a_DistanceAndIndex;
 
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_Mvp;
-uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ];
+uniform vec4 u_aimate: [ 1., 2., 1.0, 0.2 ];
 uniform float u_icon_step: 100;
 
 uniform float u_heightfixed: 0.0;

package/es/line/shaders/linear/arc3d_linear_frag.glsl

@@ -8,7 +8,7 @@ uniform float segmentNumber;
 
 
 uniform float u_time;
-uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ];
+uniform vec4 u_aimate: [ 1., 2., 1.0, 0.2 ];
 
 uniform float u_linearColor: 0;
 uniform vec4 u_sourceColor;

package/es/line/shaders/linear/arc3d_linear_vert.glsl

@@ -13,7 +13,7 @@ uniform float u_global_height: 10;
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_Mvp;
 uniform float segmentNumber;
-uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ];
+uniform vec4 u_aimate: [ 1., 2., 1.0, 0.2 ];
 varying vec4 v_color;
 // varying vec2 v_normal;
 uniform float u_line_type: 0.0;
@@ -85,11 +85,11 @@ float torad(float deg) {
 
 vec3 lglt2xyz(vec2 lnglat) {
   float pi = 3.1415926;
-  // TODO: + Math.PI/2 是为了对齐坐标
+  // + Math.PI/2 是为了对齐坐标
   float lng = torad(lnglat.x) + pi / 2.0;
   float lat = torad(lnglat.y);
 
-  // TODO: 手动增加一些偏移，减轻面的冲突
+  // 手动增加一些偏移，减轻面的冲突
   float radius = u_globel_radius;
 
   float z = radius * cos(lat) * cos(lng);

package/es/line/shaders/linear/arc_linear_frag.glsl

@@ -10,7 +10,7 @@ varying vec4 v_dash_array;
 varying vec4 v_color;
 
 uniform float u_time;
-uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ];
+uniform vec4 u_aimate: [ 1., 2., 1.0, 0.2 ];
 
 uniform float u_line_texture;
 uniform sampler2D u_texture;

package/es/line/shaders/tile/line_tile_map_vert.glsl

@@ -0,0 +1,25 @@
+attribute float a_Miter;
+attribute vec4 a_Color;
+attribute vec3 a_Normal;
+attribute vec3 a_Position;
+
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+uniform float u_size;
+
+#pragma include "projection"
+
+void main() {
+
+  vec3 size = a_Miter * u_size * reverse_offset_normal(a_Normal);
+  
+  vec2 offset = project_pixel(size.xy);
+
+  vec4 project_pos = project_position(vec4(a_Position.xy, 0, 1.0));
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(project_pos.xy + offset, 0.0, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy + offset, 0.0, 1.0));
+  }
+}

package/es/line/shaders/tile/line_tile_vert.glsl

@@ -1,210 +1,52 @@
-
 attribute float a_Miter;
 attribute vec4 a_Color;
 attribute vec2 a_Size;
 attribute vec3 a_Normal;
 attribute vec3 a_Position;
 
-attribute vec2 a_iconMapUV;
-
-// dash line
-attribute float a_Total_Distance;
-attribute vec2 a_DistanceAndIndex;
-
-uniform vec2 u_tileOrigin;
-uniform float u_coord;
+// uniform vec2 u_tileOrigin;
+// uniform float u_coord;
 
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_Mvp;
-uniform float u_icon_step: 100;
 
-uniform float u_heightfixed: 0.0;
-uniform float u_vertexScale: 1.0;
 
 #pragma include "projection"
 #pragma include "picking"
 
 varying vec4 v_color;
 
-// texV 线图层 - 贴图部分的 v 坐标（线的宽度方向）
-varying vec2 v_iconMapUV;
-
-
-uniform float u_linearColor: 0;
-uniform float u_arrow: 0.0;
-uniform float u_arrowHeight: 3.0;
-uniform float u_arrowWidth: 2.0;
-uniform float u_tailWidth: 1.0;
-
-uniform float u_opacity: 1.0;
-varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
-
-#pragma include "styleMapping"
-#pragma include "styleMappingCalOpacity"
-
-vec2 calculateArrow(vec2 offset) {
-  /*
-  * 在支持箭头的时候，第二、第三组顶点是额外插入用于构建顶点的
-  */
-  float arrowFlag = -1.0;
-  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
-    // 高德 2.0 的旋转角度不同
-    arrowFlag = 1.0;
-  }
-  float pi = arrowFlag * 3.1415926/2.;
-  if(a_Miter < 0.) {
-    // 根据线的两侧偏移不同、旋转的方向相反
-    pi = -pi;
-  }
-  highp float angle_sin = sin(pi);
-  highp float angle_cos = cos(pi);
-  // 计算垂直与线方向的旋转矩阵
-  mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);
-  float arrowWidth = u_arrowWidth;
-  float arrowHeight = u_arrowHeight;
-
-  vec2 arrowOffset = vec2(0.0);
-  /*
-  * a_DistanceAndIndex.y 用于标记当前顶点属于哪一组（两个顶点一组，构成线的其实是矩形，最简需要四个顶点、两组顶点构成）
-  */
-  if(a_DistanceAndIndex.y == 0.0) {
-    // 箭头尖部
-    offset = vec2(0.0);
-  } else if(a_DistanceAndIndex.y == 1.0) {
-    // 箭头两侧
-    arrowOffset = rotation_matrix*(offset * arrowHeight);
-    offset += arrowOffset; // 沿线偏移
-    offset = offset * arrowWidth; // 垂直线向外偏移（是构建箭头两侧的顶点）
-  } else if(a_DistanceAndIndex.y == 2.0 || a_DistanceAndIndex.y == 3.0 || a_DistanceAndIndex.y == 4.0) {
-    // 偏移其余的点位（将长度让位给箭头）
-    arrowOffset = rotation_matrix*(offset * arrowHeight) * arrowWidth;
-    offset += arrowOffset;// 沿线偏移
-  }
-
-  return offset;
-}
-
 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_texPixelLen;    // 贴图的像素长度，根据地图层级缩放
-
-  v_iconMapUV = a_iconMapUV;
-  d_texPixelLen = project_float_pixel(u_icon_step);
-  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
-    d_texPixelLen *= 10.0;
-  }
-
   v_color = a_Color;
 
   vec3 size = a_Miter * setPickingSize(a_Size.x) * reverse_offset_normal(a_Normal);
   
   vec2 offset = project_pixel(size.xy);
 
-  float lineDistance = a_DistanceAndIndex.x;
-  float currentLinePointRatio = lineDistance / a_Total_Distance;
- 
-  if(u_arrow > 0.0) {
-      //  计算箭头
-    offset = calculateArrow(offset);
-
-    if(a_DistanceAndIndex.y > 4.0) {
-      offset *= mix(1.0, u_tailWidth, currentLinePointRatio);
-    }
-  }
-
-  float lineOffsetWidth = length(offset + offset * sign(a_Miter)); // 线横向偏移的距离（向两侧偏移的和）
-  float linePixelSize = project_pixel(a_Size.x) * 2.0;  // 定点位置偏移，按地图等级缩放后的距离 单侧 * 2
-  float texV = lineOffsetWidth/linePixelSize; // 线图层贴图部分的 v 坐标值
-
-  // 设置数据集的参数
-  styleMappingMat[3][0] = currentLinePointRatio; // 当前点位距离占线总长的比例
-  styleMappingMat[3][1] = lineDistance;       // 当前顶点的距离
-  styleMappingMat[3][2] = d_texPixelLen;    // 贴图的像素长度，根据地图层级缩放
-  styleMappingMat[3][3] = texV;             // 线图层贴图部分的 v 坐标值
-
   vec4 project_pos = project_position(vec4(a_Position.xy, 0, 1.0));
 
-  // 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]
-
-if(u_coord > 0.0) {
-    if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
-    lineHeight *= 0.2; // 保持和 amap/mapbox 一致的效果
-    h *= 0.2;
-    if(u_heightfixed < 1.0) {
-      lineHeight = project_pixel(a_Size.y);
-    }
-    gl_Position = u_Mvp * (vec4(project_pos.xy + offset, lineHeight + h, 1.0));
-  } else {
-    // mapbox -  amap
-    
-    // 兼容 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;
-      if(u_heightfixed > 0.0) {
-        lineHeight *= mapboxZoomScale;
-      }
-      
+  // if(u_coord > 0.0) { // 使用经纬度坐标
+      if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+      gl_Position = u_Mvp * (vec4(project_pos.xy + offset, 0.0, 1.0));
     } else {
-      // amap
-      // lineHeight 顶点偏移高度
-      if(u_heightfixed < 1.0) {
-        lineHeight *= pow(2.0, 20.0 - u_Zoom);
-      }
+      gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy + offset, 0.0, 1.0));
     }
+  // } else { // 使用偏移坐标
+  //   vec2 pointPos = a_Position.xy;
+  //   vec4 tileWorld = vec4(project_mvt_offset_position(vec4(u_tileOrigin, 0.0, 1.0)).xyz, 1.0); // 瓦片起始点的世界坐标
 
-    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy + offset, lineHeight + h, 1.0));
-  }
-} else {
-  vec2 pointPos = a_Position.xy;
-  vec4 tileWorld = vec4(project_mvt_offset_position(vec4(u_tileOrigin, 0.0, 1.0)).xyz, 1.0); // 瓦片起始点的世界坐标
-
-  vec2 pointOffset =  pointPos *  pow(2.0, u_Zoom); // 瓦片内的点的偏移坐标
-  
-  tileWorld.xy += pointOffset;
-
-  tileWorld.xy += offset;
-
-  if (u_CoordinateSystem == COORDINATE_SYSTEM_METER_OFFSET || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
-    // Needs to be divided with project_uCommonUnitsPerMeter
-    tileWorld.w *= u_PixelsPerMeter.z;
-  }
+  //   vec2 pointOffset =  pointPos *  pow(2.0, u_Zoom); // 瓦片内的点的偏移坐标
+    
+  //   tileWorld.xy += pointOffset;
 
-  gl_Position = u_ViewProjectionMatrix * tileWorld + u_ViewportCenterProjection;
-}
+  //   tileWorld.xy += offset;
 
+  //   if (u_CoordinateSystem == COORDINATE_SYSTEM_METER_OFFSET || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+  //     // Needs to be divided with project_uCommonUnitsPerMeter
+  //     tileWorld.w *= u_PixelsPerMeter.z;
+  //   }
+  //   gl_Position = u_ViewProjectionMatrix * tileWorld + u_ViewportCenterProjection;
+  // }
 
   setPickingColor(a_PickingColor);
-
-
 }

package/es/line/shaders/tile/simpleline_map_vert.glsl

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

package/es/line/shaders/tile/simpleline_vert.glsl

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

package/es/line/shaders/{wall_frag.glsl → wall/wall_frag.glsl}

@@ -1,36 +1,32 @@
 #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;
+uniform float u_opacity : 1.0;
+uniform float u_textureBlend;
+uniform float u_iconStepCount;
+uniform float u_time;
+uniform vec4 u_aimate: [ 1., 2., 1.0, 0.2 ]; // 控制运动
 
-#pragma include "picking"
+varying vec2 v_iconMapUV;
+varying float v_blur;
+varying float v_radio;
+varying vec4 v_color;
+varying vec4 v_dataset;
 
-uniform float u_time;
-uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ]; // 控制运动
+#pragma include "picking"
 
-varying mat4 styleMappingMat;
-// [animate, duration, interval, trailLength],
 void main() {
-  float opacity = styleMappingMat[0][0];
+  float opacity = u_opacity;
   float animateSpeed = 0.0; // 运动速度
-  float d_distance_ratio = styleMappingMat[3].r; // 当前点位距离占线总长的比例
-  float v = styleMappingMat[3].a;
+  float d_distance_ratio = v_dataset.r; // 当前点位距离占线总长的比例
+  float v = v_dataset.a;
 
   if(u_linearColor == 1.0) { // 使用渐变颜色
     gl_FragColor = mix(u_sourceColor, u_targetColor, v);
@@ -48,10 +44,10 @@ void main() {
   }
 
   if(u_line_texture == LineTexture) { // while load texture
-    float aDistance = styleMappingMat[3].g;      // 当前顶点的距离
-    float d_texPixelLen = styleMappingMat[3].b;  // 贴图的像素长度，根据地图层级缩放
+    float aDistance = v_dataset.g;      // 当前顶点的距离
+    float d_texPixelLen = v_dataset.b;  // 贴图的像素长度，根据地图层级缩放
     float u = fract(mod(aDistance, d_texPixelLen)/d_texPixelLen - animateSpeed);
-    float v = styleMappingMat[3].a;  // 线图层贴图部分的 v 坐标值
+    float v = v_dataset.a;  // 线图层贴图部分的 v 坐标值
 
     // 计算纹理间隔 start
     float flag = 0.0;

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

@@ -0,0 +1,77 @@
+#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: [ 1., 2., 1.0, 0.2 ];
+uniform float u_icon_step: 100;
+uniform float u_heightfixed;
+uniform float u_linearColor: 0;
+
+#pragma include "projection"
+#pragma include "light"
+#pragma include "picking"
+
+// texV 线图层 - 贴图部分的 v 坐标（线的宽度方向）
+varying vec2 v_iconMapUV;
+varying vec4 v_color;
+varying float v_blur;
+varying float v_radio;
+varying vec4 v_dataset;
+
+void main() {
+
+
+  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;
+  // 设置数据集的参数
+  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));
+
+  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);
+
+  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

@@ -11,6 +11,7 @@ export default class MaskLayer extends BaseLayer<IMaskLayerStyleOptions> {
             };
         };
     };
+    init(): this;
     buildModels(): void;
     rebuildModels(): void;
     protected getConfigSchema(): {

package/es/mask/index.js

@@ -1,3 +1,4 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
@@ -6,12 +7,19 @@ import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstruct
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
+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; } }
 
 import BaseLayer from "../core/BaseLayer";
 import MaskModels from "./models";
+import { TYPES } from '@antv/l7-core';
 
 var MaskLayer = /*#__PURE__*/function (_BaseLayer) {
   _inherits(MaskLayer, _BaseLayer);
@@ -35,25 +43,92 @@ var MaskLayer = /*#__PURE__*/function (_BaseLayer) {
   }
 
   _createClass(MaskLayer, [{
+    key: "init",
+    value: function init() {
+      var _this2 = this;
+
+      // 设置配置项
+      var sceneId = this.container.get(TYPES.SceneID);
+      this.configService.setLayerConfig(sceneId, this.id, this.rawConfig);
+      this.layerType = this.rawConfig.layerType;
+      this.rendererService = this.container.get(TYPES.IRendererService);
+      this.layerService = this.container.get(TYPES.ILayerService);
+      this.mapService = this.container.get(TYPES.IMapService);
+      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.pendingStyleAttributes.forEach(function (_ref) {
+        var attributeName = _ref.attributeName,
+            attributeField = _ref.attributeField,
+            attributeValues = _ref.attributeValues,
+            updateOptions = _ref.updateOptions;
+
+        _this2.styleAttributeService.updateStyleAttribute(attributeName, {
+          // @ts-ignore
+          scale: _objectSpread({
+            field: attributeField
+          }, _this2.splitValuesAndCallbackInAttribute( // @ts-ignore
+          attributeValues, // @ts-ignore
+          _this2.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.hooks.afterInit.call();
+      return this;
+    }
+  }, {
     key: "buildModels",
     value: function buildModels() {
-      var _this2 = this;
+      var _this3 = this;
 
       var shape = this.getModelType();
       this.layerModel = new MaskModels[shape](this);
       this.layerModel.initModels(function (models) {
-        _this2.models = models;
+        _this3.models = models;
 
-        _this2.renderLayers();
+        _this3.emit('modelLoaded', null);
       });
     }
   }, {
     key: "rebuildModels",
     value: function rebuildModels() {
-      var _this3 = this;
+      var _this4 = this;
 
       this.layerModel.buildModels(function (models) {
-        return _this3.models = models;
+        _this4.models = models;
+
+        _this4.emit('modelLoaded', null);
       });
     }
   }, {

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

@@ -3,9 +3,10 @@ import BaseModel from '../../core/BaseModel';
 export default class MaskModel extends BaseModel {
     getUninforms(): {
         u_opacity: number;
+        u_color: number[];
     };
     initModels(callbackModel: (models: IModel[]) => void): void;
     buildModels(callbackModel: (models: IModel[]) => void): Promise<void>;
-    clearModels(): void;
+    clearModels(refresh?: boolean): void;
     protected registerBuiltinAttributes(): string;
 }