@antv/l7-layers 2.9.20 → 2.9.22

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

@@ -0,0 +1,138 @@
+
+attribute vec4 a_Color;
+attribute vec3 a_Position;
+attribute vec4 a_Instance;
+attribute float a_Size;
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+uniform float segmentNumber;
+varying vec4 v_color;
+
+uniform float u_lineDir: 1.0;
+
+uniform float u_thetaOffset: 0.314;
+
+uniform float u_opacity: 1.0;
+varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
+
+#pragma include "styleMapping"
+#pragma include "styleMappingCalOpacity"
+#pragma include "styleMappingCalThetaOffset"
+
+#pragma include "projection"
+#pragma include "project"
+#pragma include "picking"
+
+float bezier3(vec3 arr, float t) {
+  float ut = 1. - t;
+  return (arr.x * ut + arr.y * t) * ut + (arr.y * ut + arr.z * t) * t;
+}
+vec2 midPoint(vec2 source, vec2 target, float arcThetaOffset) {
+  vec2 center = target - source;
+  float r = length(center);
+  float theta = atan(center.y, center.x);
+  float thetaOffset = arcThetaOffset;
+  float r2 = r / 2.0 / cos(thetaOffset);
+  float theta2 = theta + thetaOffset;
+  vec2 mid = vec2(r2*cos(theta2) + source.x, r2*sin(theta2) + source.y);
+  if(u_lineDir == 1.0) { // 正向
+    return mid;
+  } else { // 逆向
+    // (mid + vmin)/2 = (s + t)/2
+    vec2 vmid = source + target - mid;
+    return vmid;
+  }
+  // return mid;
+}
+float getSegmentRatio(float index) {
+    return smoothstep(0.0, 1.0, index / (segmentNumber - 1.));
+}
+vec2 interpolate (vec2 source, vec2 target, float t, float arcThetaOffset) {
+  // if the angularDist is PI, linear interpolation is applied. otherwise, use spherical interpolation
+  vec2 mid = midPoint(source, target, arcThetaOffset);
+  vec3 x = vec3(source.x, mid.x, target.x);
+  vec3 y = vec3(source.y, mid.y, target.y);
+  return vec2(bezier3(x ,t), bezier3(y,t));
+}
+vec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction) {
+  // normalized direction of the line
+  vec2 dir_screenspace = normalize(line_clipspace);
+  // rotate by 90 degrees
+   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);
+  vec2 offset = dir_screenspace * offset_direction * setPickingSize(a_Size) / 2.0;
+  return offset;
+}
+vec2 getNormal(vec2 line_clipspace, float offset_direction) {
+  // normalized direction of the line
+  vec2 dir_screenspace = normalize(line_clipspace);
+  // rotate by 90 degrees
+   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);
+   return reverse_offset_normal(vec3(dir_screenspace,1.0)).xy * sign(offset_direction);
+}
+
+void main() {
+  v_color = a_Color;
+
+  // 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  // dataset 数据集
+  );
+
+  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 -> thetaOffset... 
+  // 按顺序从 cell 中取值、若没有则自动往下取值
+  float textureOffset = 0.0; // 在 cell 中取值的偏移量
+
+  vec2 opacityAndOffset = calOpacityAndOffset(cellCurrentRow, cellCurrentColumn, columnCount, textureOffset, columnWidth, rowHeight);
+  styleMappingMat[0][0] = opacityAndOffset.r;
+  textureOffset = opacityAndOffset.g;
+
+  vec2 thetaOffsetAndOffset = calThetaOffsetAndOffset(cellCurrentRow, cellCurrentColumn, columnCount, textureOffset, columnWidth, rowHeight);
+  styleMappingMat[0][1] = thetaOffsetAndOffset.r;
+  textureOffset = thetaOffsetAndOffset.g;
+  // cal style mapping - 数据纹理映射部分的计算
+
+  
+  vec2 source = a_Instance.rg;  // 起始点
+  vec2 target =  a_Instance.ba; // 终点
+  float segmentIndex = a_Position.x;
+  float segmentRatio = getSegmentRatio(segmentIndex);
+
+  float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));
+  float nextSegmentRatio = getSegmentRatio(segmentIndex + indexDir);
+  float d_distance_ratio;
+
+   styleMappingMat[3].b = d_distance_ratio;
+
+  // styleMappingMat[0][1] - arcThetaOffset
+  vec4 curr = project_position(vec4(interpolate(source, target, segmentRatio, styleMappingMat[0][1]), 0.0, 1.0));
+  vec4 next = project_position(vec4(interpolate(source, target, nextSegmentRatio, styleMappingMat[0][1]), 0.0, 1.0));
+  // v_normal = getNormal((next.xy - curr.xy) * indexDir, a_Position.y);
+  //unProjCustomCoord
+  
+  vec2 offset = project_pixel(getExtrusionOffset((next.xy - curr.xy) * indexDir, a_Position.y));
+
+
+  float d_segmentIndex = a_Position.x + 1.0; // 当前顶点在弧线中所处的分段位置
+  styleMappingMat[3].r = d_segmentIndex;
+
+  // gl_Position = project_common_position_to_clipspace(vec4(curr.xy + offset, 0, 1.0));
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    // gl_Position = u_Mvp * (vec4(curr.xy + offset, 0, 1.0));
+    gl_Position = u_Mvp * (vec4(curr.xy + offset, 0, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(curr.xy + offset, 0, 1.0));
+  }
+  setPickingColor(a_PickingColor);
+}

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

@@ -0,0 +1,27 @@
+varying vec4 v_color;
+uniform float u_linearDir: 1.0;
+uniform float u_linearColor: 0;
+uniform vec4 u_sourceColor;
+uniform vec4 u_targetColor;
+
+#pragma include "picking"
+
+
+varying mat4 styleMappingMat;
+
+void main() {
+  float opacity = styleMappingMat[0][0];
+  float linearRadio = styleMappingMat[3][0]; // 当前点位距离占线总长的比例
+  if(u_linearDir < 1.0) {
+    linearRadio = styleMappingMat[3][3];
+  }
+
+  if(u_linearColor == 1.0) { // 使用渐变颜色
+    gl_FragColor = mix(u_sourceColor, u_targetColor, linearRadio);
+  } else { // 使用 color 方法传入的颜色
+     gl_FragColor = v_color;
+  }
+
+  gl_FragColor.a *= opacity; // 全局透明度
+  gl_FragColor = filterColor(gl_FragColor);
+}

package/es/line/shaders/linearLine/line_linear_frag.glsl

@@ -0,0 +1,20 @@
+uniform float u_opacity : 1.0;
+uniform sampler2D u_texture;
+uniform float u_linearDir: 1.0;
+
+#pragma include "picking"
+
+varying mat4 styleMappingMat;
+
+void main() {
+  float opacity = styleMappingMat[0][0];
+  float linearRadio = styleMappingMat[3].r; // 当前点位距离占线总长的比例
+  if(u_linearDir < 1.0) {
+    linearRadio = styleMappingMat[3][3];
+  }
+
+  gl_FragColor = texture2D(u_texture, vec2(linearRadio, 0.5));
+
+  gl_FragColor.a *= opacity; // 全局透明度
+  gl_FragColor = filterColor(gl_FragColor);
+}

package/es/line/shaders/linearLine/line_linear_vert.glsl

@@ -0,0 +1,112 @@
+
+attribute float a_Miter;
+attribute vec2 a_Size;
+attribute vec3 a_Normal;
+attribute vec3 a_Position;
+
+// dash line
+attribute float a_Total_Distance;
+attribute vec2 a_DistanceAndIndex;
+
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+
+uniform float u_heightfixed: 0.0;
+uniform float u_vertexScale: 1.0;
+uniform float u_raisingHeight: 0.0;
+
+uniform float u_opacity: 1.0;
+
+#pragma include "projection"
+#pragma include "picking"
+
+varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
+
+#pragma include "styleMapping"
+#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 - 数据纹理映射部分的计算
+
+  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;
+ 
+
+  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][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_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 + u_raisingHeight, 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;
+      h += u_raisingHeight * mapboxZoomScale;
+      if(u_heightfixed > 0.0) {
+        lineHeight *= mapboxZoomScale;
+      }
+      
+    } else {
+      // amap
+      h += u_raisingHeight;
+      // 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, lineHeight + h, 1.0));
+  }
+
+  setPickingColor(a_PickingColor);
+}

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

@@ -0,0 +1,10 @@
+
+varying vec4 v_color;
+varying mat4 styleMappingMat;
+void main() {
+  float opacity = styleMappingMat[0][0];
+  float d_distance_ratio = styleMappingMat[3].r; // 当前点位距离占线总长的比例
+
+  gl_FragColor = v_color;
+  gl_FragColor.a *= opacity; // 全局透明度
+}

package/es/line/shaders/simple/simpleline_linear_frag.glsl

@@ -0,0 +1,11 @@
+uniform vec4 u_sourceColor;
+uniform vec4 u_targetColor;
+
+varying mat4 styleMappingMat;
+void main() {
+  float opacity = styleMappingMat[0][0];
+
+  // styleMappingMat[3][0] 当前点位距离占线总长的比例
+  gl_FragColor = mix(u_sourceColor, u_targetColor, styleMappingMat[3][0]);
+  gl_FragColor.a *= opacity; // 全局透明度
+}

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

@@ -0,0 +1,78 @@
+attribute vec4 a_Color;
+attribute vec2 a_Size;
+attribute vec3 a_Position;
+
+attribute float a_Total_Distance;
+attribute float a_Distance;
+
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+
+uniform float u_opacity: 1.0;
+uniform float u_vertexScale: 1.0;
+
+#pragma include "projection"
+
+varying vec4 v_color;
+
+varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
+
+#pragma include "styleMapping"
+#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 - 数据纹理映射部分的计算
+
+  
+  v_color = a_Color; 
+  styleMappingMat[3][0] = a_Distance / a_Total_Distance;
+
+  vec4 project_pos = project_position(vec4(a_Position.xy, 0, 1.0));
+
+  float h = float(a_Position.z) * u_vertexScale; // 线顶点的高度 - 兼容不存在第三个数值的情况
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(project_pos.xy, project_pixel(a_Size.y) + h * 0.2, 1.0));
+  } else {
+    float lineHeight = a_Size.y;
+    // 兼容 mapbox 在线高度上的效果表现基本一致
+    if(u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+      // 保持高度相对不变
+      h *= 2.0/pow(2.0, 20.0 - u_Zoom);
+    }
+
+    // #define COORDINATE_SYSTEM_P20 5.0
+    // #define COORDINATE_SYSTEM_P20_OFFSET 6.0
+    // amap1.x
+    if(u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+      // 保持高度相对不变
+      lineHeight *= pow(2.0, 20.0 - u_Zoom);
+    }
+
+    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy, lineHeight + h, 1.0));
+  }
+}

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

@@ -0,0 +1,79 @@
+#define LineTexture 1.0
+uniform float u_blur : 0.99;
+uniform float u_opacity : 1.0;
+uniform float u_textureBlend;
+
+uniform float u_borderWidth: 0.0;
+uniform vec4 u_borderColor;
+varying vec4 v_color;
+
+// line texture
+uniform float u_line_texture;
+uniform sampler2D u_texture;
+uniform vec2 u_textSize;
+
+varying vec2 v_iconMapUV;
+
+#pragma include "picking"
+
+varying mat4 styleMappingMat;
+
+void main() {
+  float opacity = styleMappingMat[0][0];
+  float d_distance_ratio = styleMappingMat[3].r; // 当前点位距离占线总长的比例
+  gl_FragColor = v_color;
+  // anti-alias
+  // float blur = 1.0 - smoothstep(u_blur, 1., length(v_normal.xy));
+  gl_FragColor.a *= opacity; // 全局透明度
+
+
+  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);
+    float v = styleMappingMat[3].a;  // 线图层贴图部分的 v 坐标值
+
+    // v = max(smoothstep(0.95, 1.0, v), v);
+    vec2 uv= v_iconMapUV / u_textSize + vec2(u, v) / u_textSize * 64.;
+    
+    // gl_FragColor = filterColor(gl_FragColor + texture2D(u_texture, vec2(u, v)));
+    // gl_FragColor = filterColor(gl_FragColor + texture2D(u_texture, uv));
+     vec4 pattern = texture2D(u_texture, uv);
+
+    if(u_textureBlend == 0.0) { // normal
+      pattern.a = 0.0;
+      gl_FragColor += pattern;
+    } else { // replace
+        pattern.a *= opacity;
+        if(gl_FragColor.a <= 0.0) {
+          pattern.a = 0.0;
+        }
+        gl_FragColor = pattern;
+    }
+  } 
+
+  float v = styleMappingMat[3].a;
+  float borderWidth = min(0.5, u_borderWidth);
+  // 绘制 border
+  if(borderWidth > 0.01) {
+    float borderOuterWidth = borderWidth/2.0;
+
+    if(v >= 1.0 - borderWidth || v <= borderWidth) {
+      if(v > borderWidth) {
+        float linear = smoothstep(0.0, 1.0, (v - (1.0 - borderWidth))/borderWidth);
+        gl_FragColor.rgb = mix(gl_FragColor.rgb, u_borderColor.rgb, linear);
+      } else if(v <= borderWidth) {
+        float linear = smoothstep(0.0, 1.0, v/borderWidth);
+        gl_FragColor.rgb = mix(u_borderColor.rgb, gl_FragColor.rgb, linear);
+      }
+    }
+
+    if(v < borderOuterWidth) {
+      gl_FragColor.a = mix(0.0, gl_FragColor.a, v/borderOuterWidth);
+    } else if(v > 1.0 - borderOuterWidth) {
+      gl_FragColor.a = mix(gl_FragColor.a, 0.0, (v - (1.0 - borderOuterWidth))/borderOuterWidth);
+    }
+  }
+
+  gl_FragColor = filterColor(gl_FragColor);
+}

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

@@ -0,0 +1,210 @@
+
+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 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;
+      }
+      
+    } 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, 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;
+  }
+
+  gl_Position = u_ViewProjectionMatrix * tileWorld + u_ViewportCenterProjection;
+}
+
+
+  setPickingColor(a_PickingColor);
+
+
+}