@antv/l7-layers 2.9.20 → 2.9.22

package/es/line/shaders/half/line_half_frag.glsl

@@ -0,0 +1,53 @@
+#define COORDINATE_SYSTEM_LNGLAT 1.0        // mapbox
+#define COORDINATE_SYSTEM_LNGLAT_OFFSET 2.0 // mapbox offset
+#define COORDINATE_SYSTEM_VECTOR_TILE 3.0
+#define COORDINATE_SYSTEM_IDENTITY 4.0
+#define COORDINATE_SYSTEM_P20 5.0           // amap
+#define COORDINATE_SYSTEM_P20_OFFSET 6.0    // amap offset
+#define COORDINATE_SYSTEM_METER_OFFSET 7.0
+
+#define COORDINATE_SYSTEM_P20_2 8.0         // amap2.0
+uniform float u_CoordinateSystem;
+varying vec4 v_color;
+uniform float u_arrow: 0.0;
+uniform float u_linearColor: 0;
+uniform vec4 u_sourceColor;
+uniform vec4 u_targetColor;
+
+#pragma include "picking"
+
+varying mat4 styleMappingMat;
+void main() {
+  float distanceAndIndex = styleMappingMat[0][3];
+  float miter = styleMappingMat[0][2];
+
+  float opacity = styleMappingMat[0][0];
+  float d_distance_ratio = styleMappingMat[3].r; // 当前点位距离占线总长的比例
+
+
+  if(u_arrow > 0.0 && distanceAndIndex < 2.0) { // arrow
+    if(u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) { 
+      if(cross(vec3(styleMappingMat[1].rg, 0.0), vec3(styleMappingMat[1].ba, 0.0)).z < 0.0) { // amap
+        discard;
+      }
+    } else { // amap2 mapbox map
+      if(cross(vec3(styleMappingMat[1].rg, 0.0), vec3(styleMappingMat[1].ba, 0.0)).z > 0.0) { 
+        discard;
+      }
+    }
+  } else { // line body
+    if(miter < 0.0) {
+      discard;
+    }
+  }
+
+
+  if(u_linearColor == 1.0) { // 使用渐变颜色
+    gl_FragColor = mix(u_sourceColor, u_targetColor, d_distance_ratio);
+  } else { // 使用 color 方法传入的颜色
+    gl_FragColor = v_color;
+  }
+
+  gl_FragColor.a *= opacity; // 全局透明度
+  gl_FragColor = filterColor(gl_FragColor);
+}

package/es/line/shaders/half/line_half_vert.glsl

@@ -0,0 +1,169 @@
+attribute float a_Miter;
+attribute vec4 a_Color;
+attribute vec2 a_Size;
+attribute vec3 a_Normal;
+attribute vec3 a_Position;
+
+// dash line
+attribute vec4 a_dirPoints;
+attribute vec3 a_DistanceAndIndex;
+
+uniform vec4 u_lineDir;
+
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+
+#pragma include "projection"
+#pragma include "picking"
+
+varying vec4 v_color;
+
+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 - a_Miter - a_DistanceAndIndex
+    0.0, 0.0, 0.0, 0.0, // originX - originY - vectorX - vectorY
+    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
+  );
+  styleMappingMat[0][3] = a_DistanceAndIndex.y;
+  styleMappingMat[0][2] = a_Miter;
+
+  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;
+
+  vec3 size = a_Miter * setPickingSize(a_Size.x) * reverse_offset_normal(a_Normal);
+  
+  vec2 offset = project_pixel(size.xy);
+
+  // styleMappingMat[1].rg = a_Position.xy + offset;
+
+  vec2 copyOffset = vec2(offset.x, offset.y);
+
+  float lineDistance = a_DistanceAndIndex.x;
+  float total_Distance = a_DistanceAndIndex.z;
+  float currentLinePointRatio = lineDistance / 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
+
+  // 设置数据集的参数
+  styleMappingMat[3][0] = currentLinePointRatio; // 当前点位距离占线总长的比例
+  styleMappingMat[3][1] = lineDistance;       // 当前顶点的距离
+
+  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); // 线顶点的高度 - 兼容不存在第三个数值的情况 vertex height
+  float lineHeight = a_Size.y; // size 第二个参数代表的高度 [linewidth, lineheight]
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    lineHeight *= 0.2; // 保持和 amap/mapbox 一致的效果
+    gl_Position = u_Mvp * (vec4(project_pos.xy + offset, lineHeight, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy + offset, lineHeight, 1.0));
+  }
+  
+  if(u_arrow > 0.0 && a_DistanceAndIndex.y < 2.0) {
+    vec2 startPoint = a_dirPoints.rg;
+    vec2 endPoint = a_dirPoints.ba;
+    vec4 t1 = project_position(vec4(startPoint, 0, 1.0));
+    vec4 t2 = project_position(vec4(endPoint, 0, 1.0));
+    // TODO： 后续优化可以把位置计算放在 cpu 中完成
+    if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+      vec2 p1 = (u_Mvp * vec4(t1.xy, 0.0, 1.0)).xy;
+      vec2 p2 = (u_Mvp * vec4(t2.xy, 0.0, 1.0)).xy;
+      styleMappingMat[1].rg = normalize(p1 - p2);
+      styleMappingMat[1].ba = normalize(gl_Position.xy - p2);
+    } else {
+      vec2 p1 = project_common_position_to_clipspace(vec4(t1.xy, 0.0, 1.0)).xy;
+      vec2 p2 = project_common_position_to_clipspace(vec4(t2.xy, 0.0, 1.0)).xy;
+      styleMappingMat[1].rg = normalize(p1 - p2);
+      styleMappingMat[1].ba = normalize(gl_Position.xy - p2);
+    }
+  }
+
+  setPickingColor(a_PickingColor);
+}

package/es/line/shaders/line_arc2d_vert.glsl

@@ -0,0 +1,114 @@
+#define LineTypeSolid 0.0
+#define LineTypeDash 1.0
+#define Animate 0.0
+attribute vec4 a_Color;
+attribute vec3 a_Position;
+attribute vec4 a_Instance;
+attribute float a_Size;
+uniform mat4 u_ModelMatrix;
+uniform float segmentNumber;
+uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ];
+varying vec4 v_color;
+varying vec2 v_normal;
+
+varying float v_distance_ratio;
+uniform float u_line_type: 0.0;
+uniform vec4 u_dash_array: [10.0, 5., 0, 0];
+varying vec4 v_dash_array;
+
+#pragma include "projection"
+#pragma include "project"
+#pragma include "picking"
+
+float maps (float value, float start1, float stop1, float start2, float stop2) {
+    return start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
+}
+
+float getSegmentRatio(float index) {
+    return smoothstep(0.0, 1.0, index / (segmentNumber - 1.));
+}
+
+float paraboloid(vec2 source, vec2 target, float ratio) {
+    vec2 x = mix(source, target, ratio);
+    vec2 center = mix(source, target, 0.5);
+    float dSourceCenter = distance(source, center);
+    float dXCenter = distance(x, center);
+    return (dSourceCenter + dXCenter) * (dSourceCenter - dXCenter);
+}
+
+vec3 getPos(vec2 source, vec2 target, float segmentRatio) {
+     float vertex_height = paraboloid(source, target, segmentRatio);
+
+    return vec3(
+    mix(source, target, segmentRatio),
+    sqrt(max(0.0, vertex_height))
+    );
+}
+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(1.0, -1.0);
+}
+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);
+}
+float getAngularDist (vec2 source, vec2 target) {
+  vec2 delta = source - target;
+  vec2 sin_half_delta = sin(delta / 2.0);
+  float a =
+    sin_half_delta.y * sin_half_delta.y +
+    cos(source.y) * cos(target.y) *
+    sin_half_delta.x * sin_half_delta.x;
+  return 2.0 * atan(sqrt(a), sqrt(1.0 - a));
+}
+vec2 interpolate (vec2 source, vec2 target, float angularDist, float t) {
+  // if the angularDist is PI, linear interpolation is applied. otherwise, use spherical interpolation
+  if(abs(angularDist - PI) < 0.001) {
+    return (1.0 - t) * source + t * target;
+  }
+  float a = sin((1.0 - t) * angularDist) / sin(angularDist);
+  float b = sin(t * angularDist) / sin(angularDist);
+  vec2 sin_source = sin(source);
+  vec2 cos_source = cos(source);
+  vec2 sin_target = sin(target);
+  vec2 cos_target = cos(target);
+  float x = a * cos_source.y * cos_source.x + b * cos_target.y * cos_target.x;
+  float y = a * cos_source.y * sin_source.x + b * cos_target.y * sin_target.x;
+  float z = a * sin_source.y + b * sin_target.y;
+  return vec2(atan(y, x), atan(z, sqrt(x * x + y * y)));
+}
+
+void main() {
+  v_color = a_Color;
+  vec2 source = radians(a_Instance.rg);
+  vec2 target = radians(a_Instance.ba);
+  float angularDist = getAngularDist(source, target);
+  float segmentIndex = a_Position.x;
+  float segmentRatio = getSegmentRatio(segmentIndex);
+  float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));
+  if(u_line_type == LineTypeDash) {
+    v_distance_ratio = segmentIndex / segmentNumber;
+    float total_Distance = pixelDistance(a_Instance.rg, a_Instance.ba);
+    v_dash_array = pow(2.0, 20.0 - u_Zoom) * u_dash_array / (total_Distance / segmentNumber * segmentIndex);
+  }
+  if(u_aimate.x == Animate) {
+      v_distance_ratio = segmentIndex / segmentNumber;
+  }
+  float nextSegmentRatio = getSegmentRatio(segmentIndex + indexDir);
+  v_distance_ratio = segmentIndex / segmentNumber;
+  vec4 curr = project_position(vec4(degrees(interpolate(source, target, angularDist, segmentRatio)), 0.0, 1.0));
+  vec4 next = project_position(vec4(degrees(interpolate(source, target, angularDist, nextSegmentRatio)), 0.0, 1.0));
+  v_normal = getNormal((next.xy - curr.xy) * indexDir, a_Position.y);
+  vec2 offset = project_pixel(getExtrusionOffset((next.xy - curr.xy) * indexDir, a_Position.y));
+  //  vec4 project_pos = project_position(vec4(curr.xy, 0, 1.0));
+  gl_Position = project_common_position_to_clipspace(vec4(curr.xy + offset, curr.z, 1.0));
+  setPickingColor(a_PickingColor);
+}
+

package/es/line/shaders/line_arc_3d_frag.glsl

@@ -0,0 +1,103 @@
+#define LineTypeSolid 0.0
+#define LineTypeDash 1.0
+#define Animate 0.0
+#define LineTexture 1.0
+
+uniform float u_opacity;
+uniform float u_textureBlend;
+uniform float u_blur : 0.9;
+uniform float u_line_type: 0.0;
+// varying vec2 v_normal;
+varying vec4 v_dash_array;
+varying vec4 v_color;
+
+uniform float u_line_texture: 0.0;
+uniform sampler2D u_texture;
+uniform vec2 u_textSize;
+varying float v_segmentIndex;
+uniform float segmentNumber;
+
+varying vec2 v_iconMapUV;
+
+uniform float u_time;
+uniform vec4 u_aimate: [ 0, 2., 1.0, 0.2 ];
+
+varying mat4 styleMappingMat;
+
+#pragma include "picking"
+
+void main() {
+  float opacity = styleMappingMat[0][0];
+  float animateSpeed = 0.0; // 运动速度
+  float d_distance_ratio = styleMappingMat[3].g; // 当前点位距离占线总长的比例
+  gl_FragColor = v_color;
+
+  gl_FragColor.a *= opacity;
+  if(u_line_type == LineTypeDash) {
+    float flag = 0.;
+    float dashLength = mod(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)) {
+      flag = 1.;
+    }
+    gl_FragColor.a *=flag;
+  }
+
+  if(u_aimate.x == Animate && u_line_texture != LineTexture) {
+      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) + u_time / u_aimate.y);
+
+      alpha = (alpha + u_aimate.w -1.0) / u_aimate.w;
+      // alpha = smoothstep(0., 1., alpha);
+      alpha = clamp(alpha, 0.0, 1.0);
+      gl_FragColor.a *= alpha;
+
+      // u_aimate 
+      // x enable
+      // y duration
+      // z interval
+      // w trailLength
+  }
+
+  if(u_line_texture == LineTexture && u_line_type != LineTypeDash) { // while load texture
+    // float arcRadio = smoothstep( 0.0, 1.0, (v_segmentIndex / segmentNumber));
+    float arcRadio = v_segmentIndex / (segmentNumber - 1.0);
+    float count = styleMappingMat[3].b; // // 贴图在弧线上重复的数量
+
+    float time = 0.0;
+    if(u_aimate.x == Animate) {
+      time = u_time / u_aimate.y;
+    }
+    float redioCount = arcRadio * count;
+
+    float u = fract(redioCount - time);
+
+    float v = styleMappingMat[3].a;  // 线图层贴图部分的 v 坐标值
+    vec2 uv= v_iconMapUV / u_textSize + vec2(u, v) / u_textSize * 64.;
+    vec4 pattern = texture2D(u_texture, uv);
+
+    if(u_aimate.x == Animate) {
+      float currentPlane = floor(redioCount - time);
+      float textureStep = floor(count * u_aimate.z);
+      float a = mod(currentPlane, textureStep);
+      if(a < textureStep - 1.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;
+          discard;
+        } else {
+          gl_FragColor = filterColor(pattern);
+        }
+    }
+
+  } else {
+    gl_FragColor = filterColor(gl_FragColor);
+  }
+}

package/es/line/shaders/line_arc_3d_vert.glsl

@@ -0,0 +1,207 @@
+#define LineTypeSolid 0.0
+#define LineTypeDash 1.0
+#define Animate 0.0
+#define LineTexture 1.0
+attribute vec3 a_Position;
+attribute vec4 a_Instance;
+attribute vec4 a_Color;
+attribute float a_Size;
+
+uniform float u_globel;
+uniform float u_globel_radius;
+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 ];
+varying vec4 v_color;
+// varying vec2 v_normal;
+uniform float u_line_type: 0.0;
+uniform vec4 u_dash_array: [10.0, 5., 0, 0];
+varying vec4 v_dash_array;
+
+uniform float u_icon_step: 100;
+uniform float u_line_texture: 0.0;
+varying float v_segmentIndex;
+
+attribute vec2 a_iconMapUV;
+varying vec2 v_iconMapUV;
+
+uniform float u_opacity: 1.0;
+varying mat4 styleMappingMat; // 用于将在顶点着色器中计算好的样式值传递给片元
+
+#pragma include "styleMapping"
+#pragma include "styleMappingCalOpacity"
+
+#pragma include "projection"
+#pragma include "project"
+#pragma include "picking"
+
+float maps (float value, float start1, float stop1, float start2, float stop2) {
+  return start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
+}
+
+float getSegmentRatio(float index) {
+  return smoothstep(0.0, 1.0, index / (segmentNumber - 1.0));
+}
+
+float paraboloid(vec2 source, vec2 target, float ratio) {
+  vec2 x = mix(source, target, ratio);
+  vec2 center = mix(source, target, 0.5);
+  float dSourceCenter = distance(source, center);
+  float dXCenter = distance(x, center);
+  return (dSourceCenter + dXCenter) * (dSourceCenter - dXCenter);
+}
+
+vec3 getPos(vec2 source, vec2 target, float segmentRatio) {
+  float vertex_height = paraboloid(source, target, segmentRatio);
+
+  return vec3(
+    mix(source, target, segmentRatio),
+    sqrt(max(0.0, vertex_height))
+  );
+}
+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);
+}
+
+float torad(float deg) {
+  return (deg / 180.0) * acos(-1.0);
+}
+
+vec3 lglt2xyz(vec2 lnglat) {
+  float pi = 3.1415926;
+  // TODO: + 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);
+  float x = radius * cos(lat) * sin(lng);
+  float y = radius * sin(lat);
+  return vec3(x, y, z);
+}
+
+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  // 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 ... 
+  // 按顺序从 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;
+  vec2 source = project_position(vec4(a_Instance.rg, 0, 0)).xy;
+  vec2 target = project_position(vec4(a_Instance.ba, 0, 0)).xy;
+  float segmentIndex = a_Position.x;
+  float segmentRatio = getSegmentRatio(segmentIndex);
+  float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));
+
+  float d_distance_ratio;
+   if(u_line_type == LineTypeDash) {
+    d_distance_ratio = segmentIndex / segmentNumber;
+    // float total_Distance = pixelDistance(a_Instance.rg, a_Instance.ba) / 2.0 * PI;
+    vec2 s = source;
+    vec2 t = target;
+    
+    if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+      s = unProjCustomCoord(source);
+      t = unProjCustomCoord(target);
+    }
+    float total_Distance = pixelDistance(s, t) / 2.0 * PI;
+    v_dash_array = pow(2.0, 20.0 - u_Zoom) * u_dash_array / (total_Distance / segmentNumber * segmentIndex);
+  }
+    if(u_aimate.x == Animate) {
+      d_distance_ratio = segmentIndex / segmentNumber;
+  }
+  styleMappingMat[3].g = d_distance_ratio; // 当前点位距离占线总长的比例
+
+  float nextSegmentRatio = getSegmentRatio(segmentIndex + indexDir);
+  vec3 curr = getPos(source, target, segmentRatio);
+  vec3 next = getPos(source, target, nextSegmentRatio);
+  vec2 offset = getExtrusionOffset((next.xy - curr.xy) * indexDir, a_Position.y);
+  // v_normal = getNormal((next.xy - curr.xy) * indexDir, a_Position.y);
+
+
+  v_segmentIndex = a_Position.x;
+  if(LineTexture == u_line_texture && u_line_type != LineTypeDash) { // 开启贴图模式  
+
+    float arcDistrance = length(source - target);
+    float pixelLen =  project_pixel_texture(u_icon_step);
+    styleMappingMat[3].b = floor(arcDistrance/pixelLen); // 贴图在弧线上重复的数量
+
+    vec2 projectOffset = project_pixel(offset);
+    float lineOffsetWidth = length(projectOffset + projectOffset * sign(a_Position.y)); // 线横向偏移的距离
+    float linePixelSize = project_pixel(a_Size);  // 定点位置偏移，按地图等级缩放后的距离
+    styleMappingMat[3].a = lineOffsetWidth/linePixelSize;  // 线图层贴图部分的 v 坐标值
+
+    v_iconMapUV = a_iconMapUV;
+  }
+  
+
+  // gl_Position = project_common_position_to_clipspace(vec4(curr.xy + project_pixel(offset), curr.z, 1.0));
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(curr.xy + project_pixel(offset), curr.z, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(curr.xy + project_pixel(offset), curr.z, 1.0));
+  }
+
+  // 地球模式
+  if(u_globel > 0.0) {
+    vec3 startLngLat = lglt2xyz(a_Instance.rg);
+    vec3 endLngLat = lglt2xyz(a_Instance.ba);
+    float globalRadius = length(startLngLat);
+
+    vec3 lineDir = normalize(endLngLat - startLngLat);
+    vec3 midPointDir = normalize((startLngLat + endLngLat)/2.0);
+
+    // 线的偏移
+    vec3 lnglatOffset = cross(lineDir, midPointDir) * a_Position.y;
+    // 计算起始点和终止点的距离
+    float lnglatLength = length(a_Instance.rg - a_Instance.ba)/50.0;
+    // 计算飞线各个节点相应的高度
+    float lineHeight = u_global_height * (-4.0*segmentRatio*segmentRatio + 4.0 * segmentRatio) * lnglatLength;
+    // 地球点位
+    vec3 globalPoint = normalize(mix(startLngLat, endLngLat, segmentRatio)) * (globalRadius + lineHeight) + lnglatOffset * a_Size;
+    
+    gl_Position = u_ViewProjectionMatrix * vec4(globalPoint, 1.0);
+  }
+ 
+
+  setPickingColor(a_PickingColor);
+}