@antv/l7-layers 2.25.7 → 2.25.9

package/es/point/shaders/image/image_vert.glsl

@@ -0,0 +1,47 @@
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_POSITION_64LOW) in vec2 a_Position64Low;
+layout(location = ATTRIBUTE_LOCATION_COLOR) in vec4 a_Color;
+layout(location = ATTRIBUTE_LOCATION_SIZE) in float a_Size;
+layout(location = ATTRIBUTE_LOCATION_UV) in vec2 a_Uv;
+
+layout(std140) uniform commonUniforms {
+  vec2 u_textSize;
+  float u_raisingHeight;
+  float u_heightfixed;
+};
+
+out vec4 v_color;
+out vec2 v_uv;
+out float v_opacity;
+
+#pragma include "projection"
+#pragma include "picking"
+
+void main() {
+  // cal style mapping - 数据纹理映射部分的计算
+  v_color = a_Color;
+  v_opacity = opacity;
+  v_uv = a_Uv;
+  vec4 project_pos = project_position(vec4(a_Position, 1.0), a_Position64Low);
+
+  vec2 offset = project_pixel(offsets);
+
+  float raisingHeight = u_raisingHeight;
+  if (u_heightfixed < 1.0) {
+    // false
+    raisingHeight = project_pixel(u_raisingHeight);
+  } else {
+    if (
+      u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+      u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET
+    ) {
+      float mapboxZoomScale = 4.0 / pow(2.0, 21.0 - u_Zoom);
+      raisingHeight = u_raisingHeight * mapboxZoomScale;
+    }
+  }
+
+  gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy + offset, raisingHeight, 1.0));
+
+  gl_PointSize = a_Size * 2.0 * u_DevicePixelRatio;
+  setPickingColor(a_PickingColor);
+}

package/es/point/shaders/normal/normal_frag.glsl

@@ -0,0 +1,5 @@
+in vec4 v_color;
+out vec4 outputColor;
+void main() {
+  outputColor = v_color;
+}

package/es/point/shaders/normal/normal_vert.glsl

@@ -0,0 +1,22 @@
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_POSITION_64LOW) in vec2 a_Position64Low;
+layout(location = ATTRIBUTE_LOCATION_COLOR) in vec4 a_Color;
+layout(location = ATTRIBUTE_LOCATION_SIZE) in float a_Size;
+
+layout(std140) uniform u_Common {
+  float u_size_scale;
+};
+
+out vec4 v_color;
+
+#pragma include "projection"
+#pragma include "project"
+
+void main() {
+  v_color = vec4(a_Color.xyz, a_Color.w * opacity);
+
+  vec4 project_pos = project_position(vec4(a_Position, 1.0), a_Position64Low);
+  gl_Position = project_common_position_to_clipspace(project_pos);
+
+  gl_PointSize = a_Size * u_size_scale * 2.0 * u_DevicePixelRatio;
+}

package/es/point/shaders/radar/radar_frag.glsl

@@ -0,0 +1,52 @@
+
+layout(std140) uniform commonUniorm{
+  float u_additive;
+  float u_size_unit;
+  float u_speed: 1.0;
+  float u_time;
+};
+in vec4 v_data;
+in vec4 v_color;
+in float v_radius;
+in vec2 v_extrude;
+#pragma include "sdf_2d"
+#pragma include "picking"
+
+out vec4 outputColor;
+
+void main() {
+
+  lowp float antialiasblur = v_data.z;
+  float r = v_radius / (v_radius);
+
+  float outer_df = sdCircle(v_data.xy, 1.0);
+  float inner_df = sdCircle(v_data.xy, r);
+
+  float opacity_t = smoothstep(0.0, antialiasblur, outer_df);
+
+  outputColor = vec4(v_color.rgb, v_color.a);
+
+  if(u_additive > 0.0) {
+    outputColor *= opacity_t;
+  } else {
+    outputColor.a *= opacity_t;
+  }
+
+  if(outputColor.a > 0.0) {
+    outputColor = filterColor(outputColor);
+  }
+
+  vec2 extrude =  v_extrude;
+  vec2 dir = normalize(extrude);
+  vec2 baseDir = vec2(1.0, 0.0);
+  float pi = 3.14159265359;
+  float flag = sign(dir.y);
+  float rades = dot(dir, baseDir);
+  float radar_v = (flag - 1.0) * -0.5 * acos(rades)/pi;
+  // simple AA
+  if(radar_v > 0.99) {
+    radar_v = 1.0 - (radar_v - 0.99)/0.01;
+  }
+
+  outputColor.a *= radar_v;
+}

package/es/point/shaders/radar/radar_vert.glsl

@@ -0,0 +1,53 @@
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_POSITION_64LOW) in vec2 a_Position64Low;
+layout(location = ATTRIBUTE_LOCATION_COLOR) in vec4 a_Color;
+layout(location = ATTRIBUTE_LOCATION_SIZE) in float a_Size;
+layout(location = ATTRIBUTE_LOCATION_EXTRUDE) in vec3 a_Extrude;
+
+layout(std140) uniform commonUniorm {
+  float u_additive;
+  float u_size_unit;
+  float u_speed: 1.0;
+  float u_time;
+};
+
+out vec4 v_data;
+out vec4 v_color;
+out float v_radius;
+out vec2 v_extrude;
+
+#pragma include "projection"
+#pragma include "picking"
+
+void main() {
+  float newSize = setPickingSize(a_Size);
+
+  float time = u_time * u_speed;
+  mat2 rotateMatrix = mat2(
+    cos(time), sin(time),
+    -sin(time), cos(time)
+  );
+  v_extrude = rotateMatrix * a_Extrude.xy;
+
+  v_color = a_Color;
+  v_color.a *= opacity;
+
+  float blur = 0.0;
+  float antialiasblur = -max(2.0 / u_DevicePixelRatio / a_Size, blur);
+
+  if(u_size_unit == 1.) {
+    newSize = newSize  * u_PixelsPerMeter.z;
+  }
+  v_radius = newSize;
+
+  vec2 offset = (a_Extrude.xy * (newSize));
+
+  offset = project_pixel(offset);
+
+  v_data = vec4(a_Extrude.x, a_Extrude.y, antialiasblur, -1.0);
+
+  vec4 project_pos = project_position(vec4(a_Position.xy, 0.0, 1.0), a_Position64Low);
+  gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy + offset, project_pixel(setPickingOrder(0.0)), 1.0));
+
+  setPickingColor(a_PickingColor);
+}

package/es/point/shaders/text/text_frag.glsl

@@ -0,0 +1,47 @@
+#define SDF_PX 8.0
+#define EDGE_GAMMA 0.105
+#define FONT_SIZE 48.0
+
+uniform sampler2D u_sdf_map;
+layout(std140) uniform commonUniforms {
+  vec4 u_stroke_color : [0.0, 0.0, 0.0, 0.0];
+  vec2 u_sdf_map_size;
+  float u_raisingHeight: 0.0;
+  float u_stroke_width : 2;
+  float u_gamma_scale : 0.5;
+  float u_halo_blur : 0.5;
+};
+
+in vec2 v_uv;
+in float v_gamma_scale;
+in vec4 v_color;
+in vec4 v_stroke_color;
+in float v_fontScale;
+
+out vec4 outputColor;
+
+#pragma include "picking"
+void main() {
+  // get style data mapping
+
+  // get sdf from atlas
+  float dist = texture(SAMPLER_2D(u_sdf_map), v_uv).a;
+
+  lowp float buff = (6.0 - u_stroke_width / v_fontScale) / SDF_PX;
+  highp float gamma = (u_halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (v_fontScale * u_gamma_scale) / 1.0;
+
+  highp float gamma_scaled = gamma * v_gamma_scale;
+
+  highp float alpha = smoothstep(buff - gamma_scaled, buff + gamma_scaled, dist);
+
+  // 根据 stroke 的 alpha 值调整混合权重，避免透明 stroke 影响文本颜色
+  float stroke_mix_factor = smoothstep(0., 0.5, 1.- dist) * v_stroke_color.a;
+  outputColor = mix(v_color, v_stroke_color, stroke_mix_factor);
+
+  outputColor.a *= alpha;
+   // 作为 mask 模板时需要丢弃透明的像素
+  if (outputColor.a < 0.01) {
+    discard;
+  }
+  outputColor = filterColor(outputColor);
+}

package/es/point/shaders/text/text_vert.glsl

@@ -0,0 +1,65 @@
+#define SDF_PX 8.0
+#define EDGE_GAMMA 0.105
+#define FONT_SIZE 24.0
+
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_POSITION_64LOW) in vec2 a_Position64Low;
+layout(location = ATTRIBUTE_LOCATION_COLOR) in vec4 a_Color;
+layout(location = ATTRIBUTE_LOCATION_SIZE) in float a_Size;
+layout(location = ATTRIBUTE_LOCATION_TEXT_OFFSETS) in vec2 a_textOffsets;
+layout(location = ATTRIBUTE_LOCATION_UV) in vec2 a_tex;
+
+layout(std140) uniform commonUniforms {
+  vec4 u_stroke_color : [0.0, 0.0, 0.0, 0.0];
+  vec2 u_sdf_map_size;
+  float u_raisingHeight: 0.0;
+  float u_stroke_width : 2;
+  float u_gamma_scale : 0.5;
+  float u_halo_blur : 0.5;
+};
+
+out vec2 v_uv;
+out float v_gamma_scale;
+out vec4 v_color;
+out vec4 v_stroke_color;
+out float v_fontScale;
+
+#pragma include "projection"
+#pragma include "picking"
+#pragma include "rotation_2d"
+
+void main() {
+  // cal style mapping - 数据纹理映射部分的计算
+
+  v_uv = a_tex / u_sdf_map_size;
+
+
+
+  v_color = vec4(a_Color.xyz, a_Color.w * opacity);
+  v_stroke_color = vec4(u_stroke_color.xyz, u_stroke_color.w * opacity);
+
+  // 文本缩放比例
+  float fontScale = a_Size / FONT_SIZE;
+  v_fontScale = fontScale;
+
+  vec4 project_pos = project_position(vec4(a_Position, 1.0), a_Position64Low);
+  // vec4 projected_position  = project_common_position_to_clipspace(vec4(project_pos.xyz, 1.0));
+
+  vec2 offset = rotate_matrix(a_textOffsets,rotation);
+
+  // gl_Position = vec4(projected_position.xy / projected_position.w + rotation_matrix * a_textOffsets * fontScale / u_ViewportSize * 2.0 * u_DevicePixelRatio, 0.0, 1.0);
+
+  float raiseHeight = u_raisingHeight;
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {
+    float mapboxZoomScale = 4.0/pow(2.0, 21.0 - u_Zoom);
+    raiseHeight = u_raisingHeight * mapboxZoomScale;
+  }
+
+  vec4 projected_position = project_common_position_to_clipspace(vec4(project_pos.xyz + vec3(0.0, 0.0, raiseHeight), 1.0));
+
+  gl_Position = vec4(
+    projected_position.xy / projected_position.w + offset * fontScale / u_ViewportSize * 2.0 * u_DevicePixelRatio, 0.0, 1.0);
+  v_gamma_scale = gl_Position.w;
+  setPickingColor(a_PickingColor);
+
+}

package/es/point/shape/extrude.d.ts

@@ -0,0 +1,15 @@
+import type { IPath } from '../../core/shape/Path';
+export interface IExtrudeGeomety {
+    positions: number[];
+    index: number[];
+}
+/**
+ * 拉伸多边形顶点，返回拉伸后的顶点信息
+ * @param paths 路径数据组
+ * @param extrude 是否拉伸
+ */
+export default function extrudePolygon(path: IPath[]): IExtrudeGeomety;
+export declare function fillPolygon(points: IPath[]): {
+    positions: number[];
+    index: number[];
+};

package/es/point/shape/extrude.js

@@ -0,0 +1,48 @@
+import earcut from 'earcut';
+/**
+ * 拉伸多边形顶点，返回拉伸后的顶点信息
+ * @param paths 路径数据组
+ * @param extrude 是否拉伸
+ */
+export default function extrudePolygon(path) {
+  const p1 = path[0][0];
+  const p2 = path[0][path[0].length - 1];
+  if (p1[0] === p2[0] && p1[1] === p2[1]) {
+    path[0] = path[0].slice(0, path[0].length - 1);
+  }
+  const n = path[0].length;
+  const flattengeo = earcut.flatten(path);
+  const positions = [];
+  const indexArray = [];
+  const normals = [];
+  // 设置顶部z值
+  for (let j = 0; j < flattengeo.vertices.length / 3; j++) {
+    flattengeo.vertices[j * 3 + 2] = 1;
+    normals.push(0, 0, 1);
+  }
+  positions.push(...flattengeo.vertices);
+  const triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  indexArray.push(...triangles);
+  for (let i = 0; i < n; i++) {
+    const prePoint = flattengeo.vertices.slice(i * 3, i * 3 + 3);
+    let nextPoint = flattengeo.vertices.slice(i * 3 + 3, i * 3 + 6);
+    if (nextPoint.length === 0) {
+      nextPoint = flattengeo.vertices.slice(0, 3);
+    }
+    const indexOffset = positions.length / 3;
+    positions.push(prePoint[0], prePoint[1], 1, nextPoint[0], nextPoint[1], 1, prePoint[0], prePoint[1], 0, nextPoint[0], nextPoint[1], 0);
+    indexArray.push(...[1, 2, 0, 3, 2, 1].map(v => v + indexOffset));
+  }
+  return {
+    positions,
+    index: indexArray
+  };
+}
+export function fillPolygon(points) {
+  const flattengeo = earcut.flatten(points);
+  const triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  return {
+    positions: flattengeo.vertices,
+    index: triangles
+  };
+}

package/es/polygon/index.d.ts

@@ -0,0 +1,18 @@
+import BaseLayer from '../core/BaseLayer';
+import type { IPolygonLayerStyleOptions } from '../core/interface';
+import type { PolygonModelType } from './models/';
+export default class PolygonLayer extends BaseLayer<IPolygonLayerStyleOptions> {
+    type: string;
+    enableShaderEncodeStyles: string[];
+    defaultSourceConfig: {
+        data: [];
+        options: {
+            parser: {
+                type: 'geojson';
+            };
+        };
+    };
+    buildModels(): Promise<void>;
+    getModelType(): PolygonModelType;
+    protected getPointModelType(): PolygonModelType;
+}

package/es/polygon/index.js

@@ -0,0 +1,71 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import BaseLayer from "../core/BaseLayer";
+import PolygonModels from "./models/";
+export default class PolygonLayer extends BaseLayer {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "type", 'PolygonLayer');
+    _defineProperty(this, "enableShaderEncodeStyles", ['opacity', 'extrusionBase',
+    // shape 为文本时
+    'rotation', 'offsets', 'stroke']);
+  }
+  buildModels() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const shape = _this.getModelType();
+      _this.layerModel = new PolygonModels[shape](_this);
+      yield _this.initLayerModels();
+    })();
+  }
+  getModelType() {
+    var _this$shapeOption;
+    const shape = (_this$shapeOption = this.shapeOption) === null || _this$shapeOption === void 0 ? void 0 : _this$shapeOption.field;
+    if (shape === 'fill' || !shape) {
+      return 'fill';
+    } else if (shape === 'extrude') {
+      return 'extrude';
+    } else if (shape === 'extrusion') {
+      return 'extrusion';
+    } else if (shape === 'water') {
+      return 'water';
+    } else if (shape === 'ocean') {
+      return 'ocean';
+    } else if (shape === 'line') {
+      return 'line';
+    } else {
+      return this.getPointModelType();
+    }
+  }
+  getPointModelType() {
+    // pointlayer
+    //  2D、 3d、 shape、image、text、normal、
+    const layerData = this.getEncodedData();
+    const {
+      shape2d,
+      shape3d
+    } = this.getLayerConfig();
+    const iconMap = this.iconService.getIconMap();
+    const item = layerData.find(fe => {
+      return fe.hasOwnProperty('shape');
+    });
+    if (!item) {
+      return 'fill';
+    } else {
+      const shape = item.shape;
+      if (shape === 'dot') {
+        return 'point_normal';
+      }
+      if ((shape2d === null || shape2d === void 0 ? void 0 : shape2d.indexOf(shape)) !== -1) {
+        return 'point_fill';
+      }
+      if ((shape3d === null || shape3d === void 0 ? void 0 : shape3d.indexOf(shape)) !== -1) {
+        return 'point_extrude';
+      }
+      if (iconMap.hasOwnProperty(shape)) {
+        return 'point_image';
+      }
+      return 'text';
+    }
+  }
+}

package/es/polygon/models/extrude.d.ts

@@ -0,0 +1,41 @@
+import type { IModel, ITexture2D } from '@antv/l7-core';
+import BaseModel from '../../core/BaseModel';
+export default class ExtrudeModel extends BaseModel {
+    protected get attributeLocation(): {
+        readonly POSITION: 0;
+        readonly POSITION_64LOW: 1;
+        readonly COLOR: 2;
+        readonly PICKING_COLOR: 3;
+        readonly STROKE: 4;
+        readonly OPACITY: 5;
+        readonly OFFSETS: 6;
+        readonly ROTATION: 7;
+        readonly MAX: 8;
+    } & Record<string, number> & {
+        MAX: 8;
+        SIZE: number;
+        NORMAL: number;
+        UV: number;
+    };
+    protected texture: ITexture2D;
+    getUninforms(): {
+        [x: string]: any;
+    };
+    protected getCommonUniformsInfo(): {
+        uniformsArray: number[];
+        uniformsLength: number;
+        uniformsOption: {
+            [key: string]: any;
+        };
+    };
+    initModels(): Promise<IModel[]>;
+    buildModels(): Promise<IModel[]>;
+    getShaders(): {
+        frag: string;
+        vert: string;
+        type: string;
+    };
+    clearModels(): void;
+    protected registerBuiltinAttributes(): void;
+    private loadTexture;
+}