@antv/l7-layers 2.20.3 → 2.20.6

package/es/line/shaders/{line_arc_great_circle_frag.glsl → greatCircle/line_arc_great_circle_frag.glsl}

@@ -3,29 +3,29 @@
 #define Animate 0.0
 #define LineTexture 1.0
 
-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 float v_distance_ratio;
-varying vec4 v_color;
-
-uniform float u_time;
-uniform vec4 u_animate: [ 1., 2., 1.0, 0.2 ];
-
-uniform float u_line_texture: 0.0;
 uniform sampler2D u_texture;
-uniform vec2 u_textSize;
-uniform float segmentNumber;
-
-varying vec2 v_iconMapUV;
+layout(std140) uniform commonUniorm {
+  vec4 u_animate: [ 1., 2., 1.0, 0.2 ];
+  vec4 u_dash_array: [10.0, 5., 0, 0];
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec2 u_textSize;
+  float segmentNumber;
+  float u_line_type: 0.0;
+  float u_icon_step: 100;
+  float u_line_texture: 0.0;
+  float u_textureBlend;
+  float u_time;
+  float u_linearColor: 0;
+};
 
-uniform float u_linearColor: 0;
-uniform vec4 u_sourceColor;
-uniform vec4 u_targetColor;
-varying vec4 v_line_data;
+in vec4 v_line_data;
+in vec2 v_iconMapUV;
+in vec4 v_dash_array;
+in float v_distance_ratio;
+in vec4 v_color;
 
+out vec4 outputColor;
 #pragma include "picking"
 #pragma include "project"
 #pragma include "projection"
@@ -37,10 +37,10 @@ void main() {
   
   // 设置弧线的底色
   if(u_linearColor == 1.0) { // 使用渐变颜色
-    gl_FragColor = mix(u_sourceColor, u_targetColor, d_segmentIndex/segmentNumber);
-     gl_FragColor.a *= v_color.a;
+    outputColor = mix(u_sourceColor, u_targetColor, d_segmentIndex/segmentNumber);
+    outputColor.a *= v_color.a;
   } else { // 使用 color 方法传入的颜色
-     gl_FragColor = v_color;
+    outputColor = v_color;
   }
 
   // float blur = 1.- smoothstep(u_blur, 1., length(v_normal.xy));
@@ -61,7 +61,7 @@ void main() {
       float alpha =1.0 - fract( mod(1.0- v_distance_ratio, u_animate.z)* (1.0/ u_animate.z) + u_time / u_animate.y);
       alpha = (alpha + u_animate.w -1.0) / u_animate.w;
       alpha = smoothstep(0., 1., alpha);
-      gl_FragColor.a *= alpha;
+      outputColor.a *= alpha;
   }
 
   // 设置弧线的贴图
@@ -72,27 +72,27 @@ void main() {
     float u = fract(arcRadio * count - animateSpeed * count);
     // float u = fract(arcRadio * count - animateSpeed);
     if(u_animate.x == Animate) {
-      u = gl_FragColor.a/v_color.a;
+      u = outputColor.a/v_color.a;
     }
 
     float v = v_line_data.a; // 线图层贴图部分的 v 坐标值
 
     vec2 uv= v_iconMapUV / u_textSize + vec2(u, v) / u_textSize * 64.;
-    vec4 pattern = texture2D(u_texture, uv);
+    vec4 pattern = texture(SAMPLER_2D(u_texture), uv);
     
     // 设置贴图和底色的叠加模式
     if(u_textureBlend == 0.0) { // normal
       pattern.a = 0.0;
-      gl_FragColor = filterColor(gl_FragColor + pattern);
+      outputColor = filterColor(outputColor + pattern);
     } else { // replace
         pattern.a *= v_color.a;
-        if(gl_FragColor.a <= 0.0) {
+        if(outputColor.a <= 0.0) {
           pattern.a = 0.0;
         }
-        gl_FragColor = filterColor(pattern);
+        outputColor = filterColor(pattern);
     }
   } else {
-    gl_FragColor = filterColor(gl_FragColor);
+    outputColor = filterColor(outputColor);
   }
 
   // gl_FragColor = filterColor(gl_FragColor);

package/{lib/line/shaders → es/line/shaders/greatCircle}/line_arc_great_circle_vert.glsl

@@ -3,56 +3,60 @@
 #define Animate 0.0
 #define LineTexture 1.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_animate: [ 1., 2., 1.0, 0.2 ];
-varying vec4 v_color;
-
-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;
-
-uniform float u_icon_step: 100;
-uniform float u_line_texture: 0.0;
-
-attribute vec2 a_iconMapUV;
-varying vec2 v_iconMapUV;
-varying vec4 v_line_data;
-
+layout(location = 0) in vec3 a_Position;
+layout(location = 1) in vec4 a_Color;
+layout(location = 9) in float a_Size;
+layout(location = 12) in vec4 a_Instance;
+layout(location = 14) in vec2 a_iconMapUV;
+
+layout(std140) uniform commonUniorm {
+  vec4 u_animate: [ 1., 2., 1.0, 0.2 ];
+  vec4 u_dash_array: [10.0, 5., 0, 0];
+  vec4 u_sourceColor;
+  vec4 u_targetColor;
+  vec2 u_textSize;
+  float segmentNumber;
+  float u_line_type: 0.0;
+  float u_icon_step: 100;
+  float u_line_texture: 0.0;
+  float u_textureBlend;
+  float u_time;
+  float u_linearColor: 0;
+};
+
+out vec4 v_dash_array;
+out vec4 v_color;
+out vec2 v_iconMapUV;
+out vec4 v_line_data;
+out float v_distance_ratio;
 
 #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));
+  return start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
 }
 
 float getSegmentRatio(float index) {
-    return index / (segmentNumber - 1.);
+  return 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);
+  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);
+  float vertex_height = paraboloid(source, target, segmentRatio);
 
-    return vec3(
-    mix(source, target, segmentRatio),
-    sqrt(max(0.0, vertex_height))
-    );
+  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
@@ -101,7 +105,8 @@ vec2 interpolate (vec2 source, vec2 target, float angularDist, float t) {
     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));
-  }else {
+  }
+  else {
     if(abs(angularDist - PI) < 0.001) {
       return (1.0 - t) * source + t * target;
     }
@@ -155,7 +160,7 @@ void main() {
   //  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));
 
-v_line_data.g = a_Position.x; // 该顶点在弧线上的分段排序
+  v_line_data.g = a_Position.x; // 该顶点在弧线上的分段排序
   if(LineTexture == u_line_texture) { // 开启贴图模式  
     // float mapZoomScale = u_CoordinateSystem !== COORDINATE_SYSTEM_P20_2?10000000.0:1.0;
     float d_arcDistrance = length(source - target);
@@ -166,17 +171,15 @@ v_line_data.g = a_Position.x; // 该顶点在弧线上的分段排序
       d_arcDistrance = project_pixel_allmap(d_arcDistrance);
     }
     float d_pixelLen = project_pixel(u_icon_step)/8.0;
-v_line_data.b = floor(d_arcDistrance/d_pixelLen); // 贴图在弧线上重复的数量
+    v_line_data.b = floor(d_arcDistrance/d_pixelLen); // 贴图在弧线上重复的数量
 
     float lineOffsetWidth = length(offset + offset * sign(a_Position.y)); // 线横向偏移的距离
     float linePixelSize = project_pixel(a_Size);  // 定点位置偏移，按地图等级缩放后的距离
-v_line_data.a = lineOffsetWidth/linePixelSize;  // 线图层贴图部分的 v 坐标值
+    v_line_data.a = lineOffsetWidth/linePixelSize;  // 线图层贴图部分的 v 坐标值
 
     v_iconMapUV = a_iconMapUV;
   }
 
-
-
   gl_Position = project_common_position_to_clipspace_v2(vec4(curr.xy + offset, 0, 1.0));
   setPickingColor(a_PickingColor);
 }

package/es/line/shaders/{line_frag.glsl → line/line_frag.glsl}

@@ -1,31 +1,58 @@
-#extension GL_OES_standard_derivatives : enable
+// #extension GL_OES_standard_derivatives : enable
 #define Animate 0.0
 #define LineTexture 1.0
-uniform float u_textureBlend;
 
-uniform float u_strokeWidth: 0.0;
-
-uniform vec3 u_blur;
-varying vec4 v_color;
-varying vec4 v_stroke;
-
-// line texture
-uniform float u_line_texture;
 uniform sampler2D u_texture;
-uniform vec2 u_textSize;
-varying vec2 v_iconMapUV;
-varying vec4 v_texture_data;
+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;
+in vec2 v_iconMapUV;
+in vec4 v_texture_data;
+// dash
+in vec4 v_dash_array;
+in float v_d_distance_ratio;
 
+out vec4 outputColor;
 #pragma include "picking"
 
-uniform float u_time;
-uniform vec4 u_animate: [ 1, 2., 1.0, 0.2 ]; // 控制运动
 // [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; // 当前点位距离占线总长的比例
-  gl_FragColor = v_color;
+  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) {
@@ -33,7 +60,7 @@ void main() {
        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);
-      gl_FragColor.a *= alpha;
+      outputColor.a *= alpha;
   }
 
   if(u_line_texture == LineTexture) { // while load texture
@@ -44,17 +71,17 @@ void main() {
 
     // v = max(smoothstep(0.95, 1.0, v), v);
     vec2 uv= v_iconMapUV / u_textSize + vec2(u, v) / u_textSize * 64.;
-     vec4 pattern = texture2D(u_texture, uv);
+     vec4 pattern = texture(SAMPLER_2D(u_texture), uv);
 
     if(u_textureBlend == 0.0) { // normal
       pattern.a = 0.0;
-      gl_FragColor += pattern;
+      outputColor += pattern;
     } else { // replace
         pattern.a *= v_color.a;
-        if(gl_FragColor.a <= 0.0) {
+        if(outputColor.a <= 0.0) {
           pattern.a = 0.0;
         }
-        gl_FragColor = pattern;
+        outputColor = pattern;
     }
   } 
 
@@ -69,27 +96,27 @@ void main() {
       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);
-        gl_FragColor.rgb = mix(gl_FragColor.rgb, v_stroke.rgb, linear);
+        outputColor.rgb = mix(outputColor.rgb, v_stroke.rgb, linear);
       } else if(v <= strokeWidth) {
         float linear = smoothstep(0.0, 1.0, v/strokeWidth);
-        gl_FragColor.rgb = mix(v_stroke.rgb, gl_FragColor.rgb, linear);
+        outputColor.rgb = mix(v_stroke.rgb, outputColor.rgb, linear);
       }
     }
 
     if(v < borderOuterWidth) {
-      gl_FragColor.a = mix(0.0, gl_FragColor.a, v/borderOuterWidth);
+      outputColor.a = mix(0.0, outputColor.a, v/borderOuterWidth);
     } else if(v > 1.0 - borderOuterWidth) {
-      gl_FragColor.a = mix(gl_FragColor.a, 0.0, (v - (1.0 - borderOuterWidth))/borderOuterWidth);
+      outputColor.a = mix(outputColor.a, 0.0, (v - (1.0 - borderOuterWidth))/borderOuterWidth);
     }
   }
 
   // blur
   float blurV = v_texture_data.a;
   if(blurV < 0.5) {
-    gl_FragColor.a *= mix(u_blur.r, u_blur.g, blurV/0.5);
+    outputColor.a *= mix(u_blur.r, u_blur.g, blurV/0.5);
   } else {
-    gl_FragColor.a *= mix(u_blur.g, u_blur.b, (blurV - 0.5)/0.5);
+    outputColor.a *= mix(u_blur.g, u_blur.b, (blurV - 0.5)/0.5);
   }
   
-  gl_FragColor = filterColor(gl_FragColor);
+  outputColor = filterColor(outputColor);
 }

package/es/line/shaders/line/line_vert.glsl

@@ -0,0 +1,114 @@
+
+#define Animate 0.0
+
+layout(location = 0) in vec3 a_Position;
+layout(location = 1) in vec4 a_Color;
+layout(location = 9) in vec4 a_SizeDistanceAndTotalDistance;
+layout(location = 13) in vec4 a_NormalAndMiter;
+layout(location = 14) 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;
+};
+#pragma include "projection"
+#pragma include "picking"
+
+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;
+
+void main() {
+  //dash输出
+  v_dash_array = pow(2.0, 20.0 - u_Zoom) * u_dash_array / a_SizeDistanceAndTotalDistance.a;
+  v_d_distance_ratio = a_SizeDistanceAndTotalDistance.b / a_SizeDistanceAndTotalDistance.a;
+
+  // 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;
+  v_color.a *= opacity;
+  v_stroke = stroke;
+
+  vec3 size = a_NormalAndMiter.w * setPickingSize(a_SizeDistanceAndTotalDistance.x) * reverse_offset_normal(a_NormalAndMiter.xyz);
+  
+  vec2 offset = project_pixel(size.xy);
+
+  float lineDistance = a_SizeDistanceAndTotalDistance.b;
+  float currentLinePointRatio = lineDistance / a_SizeDistanceAndTotalDistance.a;
+ 
+
+  float lineOffsetWidth = length(offset + offset * sign(a_NormalAndMiter.w)); // 线横向偏移的距离（向两侧偏移的和）
+  float linePixelSize = project_pixel(a_SizeDistanceAndTotalDistance.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));
+
+  // 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_SizeDistanceAndTotalDistance.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_SizeDistanceAndTotalDistance.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

@@ -1,6 +1,30 @@
 
-varying vec4 v_color;
-void main() {
-  gl_FragColor = v_color;
+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/es/line/shaders/simple/simpleline_vert.glsl

@@ -1,37 +1,37 @@
-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 float u_vertexScale: 1.0;
-uniform vec4 u_sourceColor;
-uniform vec4 u_targetColor;
-
-
+layout(location = 0) in vec3 a_Position;
+layout(location = 1) in vec4 a_Color;
+layout(location = 9) 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"
 
-varying vec4 v_color;
-varying float v_distanceScale;
+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_Distance / a_Total_Distance;
+  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));
 
   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));
+    gl_Position = u_Mvp * (vec4(project_pos.xy, project_pixel(a_SizeDistanceAndTotalDistance.y) + h * 0.2, 1.0));
   } else {
-    float lineHeight = a_Size.y;
+    float lineHeight = a_SizeDistanceAndTotalDistance.y;
     // 兼容 mapbox 在线高度上的效果表现基本一致
     if(u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
       // 保持高度相对不变