@ohuoy/easymap 1.0.0 → 1.0.2

package/lib/@antv/l7-core/lib/shaders/picking.vert.glsl

@@ -0,0 +1,58 @@
+layout(location = 3) in vec3 a_PickingColor;
+out vec4 v_PickingResult;
+
+#pragma include "picking_uniforms"
+
+#define PICKING_NONE 0.0
+#define PICKING_ENCODE 1.0
+#define PICKING_HIGHLIGHT 2.0
+#define COLOR_SCALE 1. / 255.
+
+#define NORMAL 0.0
+#define HIGHLIGHT 1.0
+#define SELECT 2.0
+
+bool isVertexPicked(vec3 vertexColor) {
+  return distance(vertexColor,u_PickingColor.rgb) < 0.01;
+}
+
+// 判断当前点是否已经被 select 选中
+bool isVertexSelected(vec3 vertexColor) {
+  return distance(vertexColor,u_CurrentSelectedId.rgb) < 0.01;
+}
+
+void setPickingColor(vec3 pickingColor) {
+  if(u_shaderPick < 0.5) {
+    return;
+  }
+  // compares only in highlight stage
+
+  if(u_PickingStage == PICKING_HIGHLIGHT) {
+    if(isVertexPicked(pickingColor)) {
+       v_PickingResult = vec4(pickingColor.rgb * COLOR_SCALE,HIGHLIGHT);
+       return;
+    }
+    if(isVertexSelected(pickingColor)) {
+     v_PickingResult = vec4(u_CurrentSelectedId.rgb * COLOR_SCALE,SELECT);
+      return;
+    }
+
+  } else {
+      v_PickingResult= vec4(pickingColor.rgb * COLOR_SCALE,NORMAL);
+      return;
+  }
+
+  // // v_PickingResult.a = float((u_PickingStage == PICKING_HIGHLIGHT) && (isVertexPicked(pickingColor) || isVertexPicked(u_CurrentSelectedId)));
+
+  // // Stores the picking color so that the fragment shader can render it during picking
+  // v_PickingResult.rgb = pickingColor * COLOR_SCALE;
+}
+
+float setPickingSize(float x) {
+   return u_PickingStage == PICKING_ENCODE ? x + u_PickingBuffer : x;
+}
+
+float setPickingOrder(float z) {
+   bool selected = bool(v_PickingResult.a);
+   return selected ? z + 1. : 0.;
+}

package/lib/@antv/l7-core/lib/shaders/picking_uniforms.glsl

@@ -0,0 +1,11 @@
+layout(std140) uniform PickingUniforms {
+  vec4 u_HighlightColor;
+  vec4 u_SelectColor;
+  vec3 u_PickingColor;
+  float u_PickingStage;
+  vec3 u_CurrentSelectedId;
+  float u_PickingThreshold;
+  float u_PickingBuffer;
+  float u_shaderPick;
+  float u_activeMix;
+};

package/lib/@antv/l7-core/lib/shaders/post-processing/blend.glsl

@@ -0,0 +1,13 @@
+uniform float u_opacity : 1.0;
+uniform float u_MixRatio : 0.5;
+
+uniform sampler2D u_Diffuse1;
+uniform sampler2D u_Diffuse2;
+
+varying vec2 v_UV;
+
+void main() {
+  vec4 texel1 = texture2D(u_Diffuse1, v_UV);
+  vec4 texel2 = texture2D(u_Diffuse2, v_UV);
+  gl_FragColor = u_opacity * mix(texel1, texel2, u_MixRatio);
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/bloom.glsl

@@ -0,0 +1,57 @@
+varying vec2 v_UV;
+
+uniform float u_BloomFinal: 0.0;
+uniform sampler2D u_Texture;
+uniform sampler2D u_Texture2;
+
+uniform vec2 u_ViewportSize: [1.0, 1.0];
+uniform float u_radius: 5.0;
+uniform float u_intensity: 0.3;
+uniform float u_baseRadio: 0.5;
+
+// https://github.com/Jam3/glsl-fast-gaussian-blur/blob/master/9.glsl
+vec4 blur9(sampler2D image, vec2 uv, vec2 resolution, vec2 direction) {
+  vec4 color = vec4(0.0);
+  vec2 off1 = vec2(1.3846153846) * direction;
+  vec2 off2 = vec2(3.2307692308) * direction;
+  color += texture2D(image, uv) * 0.2270270270;
+  color += texture2D(image, uv + (off1 / resolution)) * 0.3162162162;
+  color += texture2D(image, uv - (off1 / resolution)) * 0.3162162162;
+  color += texture2D(image, uv + (off2 / resolution)) * 0.0702702703;
+  color += texture2D(image, uv - (off2 / resolution)) * 0.0702702703;
+  return color;
+}
+
+float luminance(vec4 color) {
+  return  0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b;
+}
+
+void main() {
+  // vec4 baseColor = texture2D(u_Texture, v_UV);
+
+  float r = sqrt(u_radius);
+
+  vec4 c1 = blur9(u_Texture, v_UV, u_ViewportSize, vec2(u_radius, 0.0));
+  // c1 *= luminance(c1);
+  vec4 c2 = blur9(u_Texture, v_UV, u_ViewportSize, vec2(0.0, u_radius));
+  // c2 *= luminance(c2);
+  vec4 c3 = blur9(u_Texture, v_UV, u_ViewportSize, vec2(r, r));
+  // c3 *= luminance(c3);
+  vec4 c4 = blur9(u_Texture, v_UV, u_ViewportSize, vec2(r, -r));
+  // c4 *= luminance(c4);
+  vec4 inbloomColor = (c1 + c2 + c3 + c4) * 0.25;
+
+  // float lum = luminance(inbloomColor);
+  // inbloomColor.rgb *= lum;
+
+  if(u_BloomFinal > 0.0) {
+    vec4 baseColor = texture2D(u_Texture2, v_UV);
+    float baselum = luminance(baseColor);
+    gl_FragColor = mix(inbloomColor, baseColor, u_baseRadio);
+    if(baselum <= 0.2) {
+      gl_FragColor = inbloomColor * u_intensity;
+    }
+  } else {
+    gl_FragColor = inbloomColor;
+  }
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/blur.glsl

@@ -0,0 +1,23 @@
+varying vec2 v_UV;
+
+uniform sampler2D u_Texture;
+
+uniform vec2 u_ViewportSize: [1.0, 1.0];
+uniform vec2 u_BlurDir: [1.0, 0.0];
+
+// https://github.com/Jam3/glsl-fast-gaussian-blur/blob/master/9.glsl
+vec4 blur9(sampler2D image, vec2 uv, vec2 resolution, vec2 direction) {
+  vec4 color = vec4(0.0);
+  vec2 off1 = vec2(1.3846153846) * direction;
+  vec2 off2 = vec2(3.2307692308) * direction;
+  color += texture2D(image, uv) * 0.2270270270;
+  color += texture2D(image, uv + (off1 / resolution)) * 0.3162162162;
+  color += texture2D(image, uv - (off1 / resolution)) * 0.3162162162;
+  color += texture2D(image, uv + (off2 / resolution)) * 0.0702702703;
+  color += texture2D(image, uv - (off2 / resolution)) * 0.0702702703;
+  return color;
+}
+
+void main() {
+  gl_FragColor = blur9(u_Texture, v_UV, u_ViewportSize, u_BlurDir);
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/colorhalftone.glsl

@@ -0,0 +1,44 @@
+varying vec2 v_UV;
+
+uniform sampler2D u_Texture;
+uniform vec2 u_ViewportSize: [1.0, 1.0];
+uniform vec2 u_Center : [0.5, 0.5];
+uniform float u_Angle : 0;
+uniform float u_Size : 8;
+
+#pragma include "common"
+
+float scale = PI / u_Size;
+
+float pattern(float u_Angle, vec2 texSize, vec2 texCoord) {
+  float s = sin(u_Angle), c = cos(u_Angle);
+  vec2 tex = texCoord * texSize - u_Center * texSize;
+  vec2 point = vec2(
+    c * tex.x - s * tex.y,
+    s * tex.x + c * tex.y
+  ) * scale;
+  return (sin(point.x) * sin(point.y)) * 4.0;
+}
+
+// https://github.com/evanw/glfx.js/blob/master/src/filters/fun/colorhalftone.js
+vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+  vec3 cmy = 1.0 - color.rgb;
+  float k = min(cmy.x, min(cmy.y, cmy.z));
+  cmy = (cmy - k) / (1.0 - k);
+  cmy = clamp(
+    cmy * 10.0 - 3.0 + vec3(
+      pattern(u_Angle + 0.26179, texSize, texCoord),
+      pattern(u_Angle + 1.30899, texSize, texCoord),
+      pattern(u_Angle, texSize, texCoord)
+    ),
+    0.0,
+    1.0
+  );
+  k = clamp(k * 10.0 - 5.0 + pattern(u_Angle + 0.78539, texSize, texCoord), 0.0, 1.0);
+  return vec4(1.0 - cmy - k, color.a);
+}
+
+void main() {
+  gl_FragColor = vec4(texture2D(u_Texture, v_UV));
+  gl_FragColor = colorHalftone_filterColor(gl_FragColor, u_ViewportSize, v_UV);
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/copy.glsl

@@ -0,0 +1,7 @@
+varying vec2 v_UV;
+
+uniform sampler2D u_Texture;
+
+void main() {
+  gl_FragColor = vec4(texture2D(u_Texture, v_UV));
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/hexagonalpixelate.glsl

@@ -0,0 +1,44 @@
+varying vec2 v_UV;
+
+uniform sampler2D u_Texture;
+uniform vec2 u_ViewportSize: [1.0, 1.0];
+uniform vec2 u_Center : [0.5, 0.5];
+uniform float u_Scale : 10;
+
+// https://github.com/evanw/glfx.js/blob/master/src/filters/fun/hexagonalpixelate.js
+vec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+  vec2 tex = (texCoord * texSize - u_Center * texSize) / u_Scale;
+  tex.y /= 0.866025404;
+  tex.x -= tex.y * 0.5;
+  vec2 a;
+  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
+    a = vec2(floor(tex.x), floor(tex.y));
+  }
+  else a = vec2(ceil(tex.x), ceil(tex.y));
+  vec2 b = vec2(ceil(tex.x), floor(tex.y));
+  vec2 c = vec2(floor(tex.x), ceil(tex.y));
+  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
+  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
+  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
+  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
+  float alen = length(TEX - A);
+  float blen = length(TEX - B);
+  float clen = length(TEX - C);
+  vec2 choice;
+  if (alen < blen) {
+    if (alen < clen) choice = a;
+    else choice = c;
+  } else {
+    if (blen < clen) choice = b;
+    else choice = c;
+  }
+  choice.x += choice.y * 0.5;
+  choice.y *= 0.866025404;
+  choice *= u_Scale / texSize;
+  return texture2D(texture, choice + u_Center);
+}
+
+void main() {
+  gl_FragColor = vec4(texture2D(u_Texture, v_UV));
+  gl_FragColor = hexagonalPixelate_sampleColor(u_Texture, u_ViewportSize, v_UV);
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/ink.glsl

@@ -0,0 +1,34 @@
+varying vec2 v_UV;
+
+uniform sampler2D u_Texture;
+uniform vec2 u_ViewportSize: [1.0, 1.0];
+uniform float u_Strength : 0.6;
+
+vec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {
+  vec2 dx = vec2(1.0 / texSize.x, 0.0);
+  vec2 dy = vec2(0.0, 1.0 / texSize.y);
+  vec4 color = texture2D(texture, texCoord);
+  float bigTotal = 0.0;
+  float smallTotal = 0.0;
+  vec3 bigAverage = vec3(0.0);
+  vec3 smallAverage = vec3(0.0);
+  for (float x = -2.0; x <= 2.0; x += 1.0) {
+    for (float y = -2.0; y <= 2.0; y += 1.0) {
+      vec3 sample = texture2D(texture, texCoord + dx * x + dy * y).rgb;
+      bigAverage += sample;
+      bigTotal += 1.0;
+      if (abs(x) + abs(y) < 2.0) {
+        smallAverage += sample;
+        smallTotal += 1.0;
+      }
+    }
+  }
+  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
+  float power = u_Strength * u_Strength * u_Strength * u_Strength * u_Strength;
+  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
+}
+
+void main() {
+  gl_FragColor = vec4(texture2D(u_Texture, v_UV));
+  gl_FragColor = ink_sampleColor(u_Texture, u_ViewportSize, v_UV);
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/noise.glsl

@@ -0,0 +1,22 @@
+varying vec2 v_UV;
+
+uniform sampler2D u_Texture;
+uniform float u_Amount : 0.5;
+
+float rand(vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+// https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/noise.js
+vec4 noise_filterColor(vec4 color, vec2 texCoord) {
+  float diff = (rand(texCoord) - 0.5) * u_Amount;
+  color.r += diff;
+  color.g += diff;
+  color.b += diff;
+  return color;
+}
+
+void main() {
+  gl_FragColor = vec4(texture2D(u_Texture, v_UV));
+  gl_FragColor = noise_filterColor(gl_FragColor, v_UV);
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/quad.glsl

@@ -0,0 +1,8 @@
+attribute vec2 a_Position;
+
+varying vec2 v_UV;
+
+void main() {
+  v_UV = 0.5 * (a_Position + 1.0);
+  gl_Position = vec4(a_Position, 0., 1.);
+}

package/lib/@antv/l7-core/lib/shaders/post-processing/sepia.glsl

@@ -0,0 +1,22 @@
+varying vec2 v_UV;
+
+uniform sampler2D u_Texture;
+
+uniform float u_Amount : 0.5;
+
+// https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/sepia.js
+vec4 sepia_filterColor(vec4 color) {
+  float r = color.r;
+  float g = color.g;
+  float b = color.b;
+  color.r =
+    min(1.0, (r * (1.0 - (0.607 * u_Amount))) + (g * (0.769 * u_Amount)) + (b * (0.189 * u_Amount)));
+  color.g = min(1.0, (r * 0.349 * u_Amount) + (g * (1.0 - (0.314 * u_Amount))) + (b * 0.168 * u_Amount));
+  color.b = min(1.0, (r * 0.272 * u_Amount) + (g * 0.534 * u_Amount) + (b * (1.0 - (0.869 * u_Amount))));
+  return color;
+}
+
+void main() {
+  gl_FragColor = vec4(texture2D(u_Texture, v_UV));
+  gl_FragColor = sepia_filterColor(gl_FragColor);
+}

package/lib/@antv/l7-core/lib/shaders/project.glsl

@@ -0,0 +1,70 @@
+
+#define E 2.718281828459045
+vec2 ProjectFlat(vec2 lnglat){
+  float maxs=85.0511287798;
+  float lat=max(min(maxs,lnglat.y),-maxs);
+  float scale= 268435456.;
+  float d=PI/180.;
+  float x=lnglat.x*d;
+  float y=lat*d;
+  y=log(tan((PI/4.)+(y/2.)));
+
+  float a=.5/PI,
+  b=.5,
+  c=-.5/PI;
+  d=.5;
+  x=scale*(a*x+b);
+  y=scale*(c*y+d);
+  return vec2(x,y);
+}
+
+vec2 unProjectFlat(vec2 px){
+  float a=.5/PI;
+  float b=.5;
+  float c=-.5/PI;
+  float d=.5;
+  float scale = 268435456.;
+  float x=(px.x/scale-b)/a;
+  float y=(px.y/scale-d)/c;
+  y=(atan(pow(E,y))-(PI/4.))*2.;
+  d=PI/180.;
+  float lat=y/d;
+  float lng=x/d;
+  return vec2(lng,lat);
+}
+
+float pixelDistance(vec2 from, vec2 to) {
+ vec2 a1 = ProjectFlat(from);
+ vec2 b1 = ProjectFlat(to);
+ return distance(a1, b1);
+}
+
+// gaode2.0
+vec2 customProject(vec2 lnglat) { // 经纬度 => 平面坐标
+  float t = lnglat.x;
+  float e = lnglat.y;
+  float Sm = 180.0 / PI;
+  float Tm = 6378137.0;
+  float Rm = PI / 180.0;
+  float r = 85.0511287798;
+  e = max(min(r, e), -r);
+  t *= Rm;
+  e *= Rm;
+  e = log(tan(PI / 4.0 + e / 2.0));
+  return vec2(t * Tm, e * Tm);
+}
+
+vec2 unProjCustomCoord(vec2 point) { // 平面坐标 => 经纬度
+  float Sm = 57.29577951308232; //180 / Math.PI
+  float Tm = 6378137.0;
+  float t = point.x;
+  float e = point.y;
+  return vec2(t / Tm * Sm, (2.0 * atan(exp(e / Tm)) - PI / 2.0) * Sm);
+}
+
+
+float customPixelDistance(vec2 from, vec2 to) {
+ vec2 a1 = ProjectFlat(from);
+ vec2 b1 = ProjectFlat(to);
+ return distance(a1, b1);
+}

package/lib/@antv/l7-core/lib/shaders/projection.glsl

@@ -0,0 +1,268 @@
+#define TILE_SIZE 512.0
+#define PI 3.1415926536
+#define WORLD_SCALE TILE_SIZE / (PI * 2.0)
+#define EARTH_CIRCUMFERENCE 40.03e6
+
+#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
+#pragma include "scene_uniforms"
+
+
+// web mercator coords -> world coords
+vec2 project_mercator(vec2 lnglat) {
+   if (u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.0
+    return lnglat;
+  }
+  float x = lnglat.x;
+  return vec2(
+    radians(x) + PI,
+    PI - log(tan(PI * 0.25 + radians(lnglat.y) * 0.5))
+  );
+}
+
+float project_scale(float meters) {
+  return meters * u_PixelsPerMeter.z;
+}
+
+
+// offset coords -> world coords
+vec4 project_offset(vec4 offset) {
+  float dy = offset.y;
+  dy = clamp(dy, -1., 1.);
+  vec3 pixels_per_unit = u_PixelsPerDegree + u_PixelsPerDegree2 * dy;
+  return vec4(offset.xyz * pixels_per_unit, offset.w);
+}
+
+vec3 project_normal(vec3 normal) {
+  vec4 normal_modelspace = u_ModelMatrix * vec4(normal, 0.0);
+  return normalize(normal_modelspace.xyz * u_PixelsPerMeter);
+}
+
+vec3 project_offset_normal(vec3 vector) {
+  if (u_CoordinateSystem < COORDINATE_SYSTEM_LNGLAT + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_LNGLAT - 0.01
+    || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+    // normals generated by the polygon tesselator are in lnglat offsets instead of meters
+    return normalize(vector * u_PixelsPerDegree);
+  }
+  return project_normal(vector);
+}
+// || u_CoordinateSystem < COORDINATE_SYSTEM_P20_OFFSET + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_P20_OFFSET - 0.01
+// reverse Y
+vec3 reverse_offset_normal(vec3 vector) {
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 ||u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET ) {
+    return vector * vec3(1.0, -1.0, 1.0);
+  }
+
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.0
+    return vector;
+  }
+  return vector;
+}
+
+vec4 project_mvt_offset_position(vec4 position) {
+  float a = COORDINATE_SYSTEM_LNGLAT_OFFSET;
+  float b = COORDINATE_SYSTEM_P20_OFFSET;
+  float c = COORDINATE_SYSTEM_LNGLAT;
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+    return project_offset(vec4(0.0, 0.0, position.z, position.w));
+  }
+  if (u_CoordinateSystem < COORDINATE_SYSTEM_LNGLAT + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_LNGLAT - 0.01) {
+    return vec4(
+      project_mercator(position.xy) * WORLD_SCALE * u_ZoomScale,
+      project_scale(position.z),
+      position.w
+    );
+  }
+  return position;
+}
+
+vec4 project_position(vec4 position) {
+  float a = COORDINATE_SYSTEM_LNGLAT_OFFSET;
+  float b = COORDINATE_SYSTEM_P20_OFFSET;
+  float c = COORDINATE_SYSTEM_LNGLAT;
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET
+    || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+    float X = position.x - u_ViewportCenter.x;
+    float Y = position.y - u_ViewportCenter.y;
+    return project_offset(vec4(X, Y, position.z, position.w));
+  }
+  if (u_CoordinateSystem < COORDINATE_SYSTEM_LNGLAT + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_LNGLAT - 0.01) {
+    return vec4(
+      project_mercator(position.xy) * WORLD_SCALE * u_ZoomScale,
+      project_scale(position.z),
+      position.w
+    );
+  }
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20) {
+    return vec4(
+      (project_mercator(position.xy) * WORLD_SCALE * u_ZoomScale - vec2(215440491., 106744817.)) * vec2(1., -1.),
+      project_scale(position.z),
+      position.w
+    );
+  }
+
+  // if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
+ 
+
+  //    return vec4(
+  //     position.xy,
+  //     project_scale(position.z),
+  //     position.w);
+  // }
+  return position;
+
+  // TODO: 瓦片坐标系 & 常规世界坐标系
+}
+vec2 project_pixel_size_to_clipspace(vec2 pixels) {
+  vec2 offset = pixels / u_ViewportSize * u_DevicePixelRatio * 2.0;
+  return offset * u_FocalDistance;
+}
+
+
+
+float project_pixel_allmap(float pixel) {
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+    return pixel * pow(2.0, u_Zoom);
+  }
+  return pixel * u_FocalDistance ;
+}
+
+// 适配纹理贴图的等像素大小
+float project_pixel_texture(float pixel) {
+  // mapbox zoom > 12
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+    return pixel * pow(0.5, u_Zoom) * u_FocalDistance ;
+  }
+
+  // amap2 zoom > 12
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
+    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom))* u_FocalDistance ;
+  }
+
+  // amap zoom > 12
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+    return pixel * pow(0.5, u_Zoom)* u_FocalDistance ;
+  }
+
+  // amap zoom < 12
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20) {
+    return pixel * pow(2.0, (20.0 - u_Zoom))* u_FocalDistance ;
+  }
+  return pixel * 2.0 *  u_FocalDistance;;
+}
+
+// 在不论什么底图下需要统一处理的时候使用
+float project_float_pixel(float pixel) {
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+    // mapbox P20 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减1
+    return pixel * pow(2.0, (19.0 - u_Zoom))  * u_FocalDistance ;
+  }
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+    // amap P20 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减1
+    return pixel * pow(2.0, (19.0 - u_Zoom));
+  }
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
+    // amap2 P20_2 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减3
+    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom))* u_FocalDistance ;
+  }
+  return pixel * u_FocalDistance;
+}
+
+// Project meter into the unit of pixel which used in the camera world space
+float project_float_meter(float meter) {
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+    // Since the zoom level uniform is updated by mapservice and it's alread been subtracted by 1
+    // Not sure if we are supposed to do that again
+   return meter;
+  } else  {
+    return project_float_pixel(meter);
+  }
+
+  // TODO: change the following code to make adaptations for amap
+  // return u_FocalDistance * TILE_SIZE * pow(2.0, u_Zoom) * meter / EARTH_CIRCUMFERENCE;
+}
+
+float project_pixel(float pixel) {
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+    // amap P20 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减1
+    return pixel * pow(2.0, (19.0 - u_Zoom)) * u_FocalDistance ;
+  }
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
+    // amap2 P20_2 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减3
+    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom)) * u_FocalDistance ;
+  }
+  return pixel * u_FocalDistance;
+}
+vec2 project_pixel(vec2 pixel) {
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+    // P20 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减1
+    return pixel * pow(2.0, (19.0 - u_Zoom)) * u_FocalDistance ;
+  }
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
+    // P20_2 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减3
+    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom)) * u_FocalDistance ;
+  }
+  return pixel * -1. * u_FocalDistance;
+}
+vec3 project_pixel(vec3 pixel) {
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {
+    // P20 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减1
+    return pixel * pow(2.0, (19.0 - u_Zoom)) *  u_FocalDistance ;
+  }
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {
+    // P20_2 坐标系下，为了和 Web 墨卡托坐标系统一，zoom 默认减3
+    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom))  * u_FocalDistance ;
+  }
+  return pixel * -1. * u_FocalDistance;
+}
+
+vec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_METER_OFFSET ||
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+    // Needs to be divided with project_uCommonUnitsPerMeter
+    position.w *= u_PixelsPerMeter.z;
+  }
+
+  return viewProjectionMatrix * position + center;
+}
+
+// Projects from common space coordinates to clip space
+vec4 project_common_position_to_clipspace(vec4 position) {
+  return project_common_position_to_clipspace(
+    position,
+    u_ViewProjectionMatrix,
+    u_ViewportCenterProjection
+  );
+}
+
+vec4 unproject_clipspace_to_position(vec4 clipspacePos, mat4 u_InverseViewProjectionMatrix) {
+  vec4 pos = u_InverseViewProjectionMatrix * (clipspacePos - u_ViewportCenterProjection);
+
+  if (u_CoordinateSystem == COORDINATE_SYSTEM_METER_OFFSET ||
+    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+    // Needs to be divided with project_uCommonUnitsPerMeter
+     pos.w = pos.w / u_PixelsPerMeter.z;
+  }
+  return pos;
+}
+
+
+bool isEqual( float a,  float b) {
+    return  a< b + 0.001 && a > b - 0.001;
+}
+
+// 支持 GaodeV2、Mapbox
+vec4 project_common_position_to_clipspace_v2(vec4 position) {
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    return u_Mvp * position;
+  } else {
+    return project_common_position_to_clipspace(position);
+  }
+}