@antv/l7-layers 2.9.24 → 2.9.26-alpha.0

package/lib/core/triangulation.js

@@ -1,373 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/core/triangulation.ts
-var triangulation_exports = {};
-__export(triangulation_exports, {
-  GlobelPointFillTriangulation: () => GlobelPointFillTriangulation,
-  HeatmapGridTriangulation: () => HeatmapGridTriangulation,
-  HeatmapTriangulation: () => HeatmapTriangulation,
-  LineArcTriangulation: () => LineArcTriangulation,
-  LineTriangulation: () => LineTriangulation,
-  PointExtrudeTriangulation: () => PointExtrudeTriangulation,
-  PointFillTriangulation: () => PointFillTriangulation,
-  PointImageTriangulation: () => PointImageTriangulation,
-  PolygonExtrudeTriangulation: () => PolygonExtrudeTriangulation,
-  RasterImageTriangulation: () => RasterImageTriangulation,
-  SimpleLineTriangulation: () => SimpleLineTriangulation,
-  earthOuterTriangulation: () => earthOuterTriangulation,
-  earthTriangulation: () => earthTriangulation,
-  polygonTriangulation: () => polygonTriangulation,
-  polygonTriangulationWithCenter: () => polygonTriangulationWithCenter
-});
-module.exports = __toCommonJS(triangulation_exports);
-var import_l7_utils = require("@antv/l7-utils");
-var import_earcut = __toESM(require("earcut"));
-var import_gl_matrix = require("gl-matrix");
-var import_utils = require("../earth/utils");
-var import_extrude_polyline = __toESM(require("../utils/extrude_polyline"));
-var import_extrude = __toESM(require("./shape/extrude"));
-var import_Path = require("./shape/Path");
-var GeometryCache = {};
-function PointFillTriangulation(feature) {
-  const coordinates = (0, import_l7_utils.calculateCentroid)(feature.coordinates);
-  return {
-    vertices: [...coordinates, ...coordinates, ...coordinates, ...coordinates],
-    indices: [0, 1, 2, 2, 3, 0],
-    size: coordinates.length
-  };
-}
-function GlobelPointFillTriangulation(feature) {
-  const coordinates = (0, import_l7_utils.calculateCentroid)(feature.coordinates);
-  const xyz = (0, import_utils.lglt2xyz)(coordinates);
-  return {
-    vertices: [...xyz, ...xyz, ...xyz, ...xyz],
-    indices: [0, 1, 2, 2, 3, 0],
-    size: xyz.length
-  };
-}
-function PointExtrudeTriangulation(feature) {
-  const { shape } = feature;
-  const { positions, index, normals } = getGeometry(shape, false);
-  return {
-    vertices: positions,
-    indices: index,
-    normals,
-    size: 5
-  };
-}
-function PointImageTriangulation(feature) {
-  const coordinates = (0, import_l7_utils.calculateCentroid)(feature.coordinates);
-  return {
-    vertices: [...coordinates],
-    indices: [0],
-    size: coordinates.length
-  };
-}
-function LineTriangulation(feature) {
-  const { coordinates, originCoordinates, version } = feature;
-  const line = new import_extrude_polyline.default({
-    dash: true,
-    join: "bevel"
-  });
-  if (version === "GAODE2.x") {
-    let path1 = coordinates;
-    if (!Array.isArray(path1[0][0])) {
-      path1 = [coordinates];
-    }
-    let path2 = originCoordinates;
-    if (!Array.isArray(path2[0][0])) {
-      path2 = [originCoordinates];
-    }
-    for (let i = 0; i < path1.length; i++) {
-      const item1 = path1[i];
-      const item2 = path2[i];
-      line.extrude_gaode2(item1, item2);
-    }
-  } else {
-    let path = coordinates;
-    if (path[0] && !Array.isArray(path[0][0])) {
-      path = [coordinates];
-    }
-    path.forEach((item) => {
-      line.extrude(item);
-    });
-  }
-  const linebuffer = line.complex;
-  return {
-    vertices: linebuffer.positions,
-    indices: linebuffer.indices,
-    normals: linebuffer.normals,
-    indexes: linebuffer.indexes,
-    size: 6
-  };
-}
-function SimpleLineTriangulation(feature) {
-  const { coordinates } = feature;
-  const pos = [];
-  const { results, totalDistance } = getSimpleLineVertices(coordinates);
-  results.map((point) => {
-    pos.push(point[0], point[1], point[2], point[3], 0, totalDistance);
-  });
-  return {
-    vertices: pos,
-    indices: [],
-    normals: [],
-    size: 6,
-    count: results.length
-  };
-}
-function lineSegmentDistance(b1, a1) {
-  const dx = a1[0] - b1[0];
-  const dy = a1[1] - b1[1];
-  return Math.sqrt(dx * dx + dy * dy);
-}
-function pushDis(point, n) {
-  if (point.length < 3) {
-    point.push(0);
-  }
-  point.push(n);
-  return point;
-}
-function getSimpleLineVertices(points) {
-  let distance = 0;
-  if (points.length < 2) {
-    return {
-      results: points,
-      totalDistance: 0
-    };
-  } else {
-    const results = [];
-    const point = pushDis(points[0], distance);
-    results.push(point);
-    for (let i = 1; i < points.length - 1; i++) {
-      const subDistance = lineSegmentDistance(points[i - 1], points[i]);
-      distance += subDistance;
-      const mulPoint = pushDis(points[i], distance);
-      results.push(mulPoint);
-      results.push(mulPoint);
-    }
-    const pointDistance = lineSegmentDistance(points[points.length - 2], points[points.length - 1]);
-    distance += pointDistance;
-    results.push(pushDis(points[points.length - 1], distance));
-    return {
-      results,
-      totalDistance: distance
-    };
-  }
-}
-function polygonTriangulation(feature) {
-  const { coordinates } = feature;
-  const flattengeo = import_earcut.default.flatten(coordinates);
-  const { vertices, dimensions, holes } = flattengeo;
-  return {
-    indices: (0, import_earcut.default)(vertices, holes, dimensions),
-    vertices,
-    size: dimensions
-  };
-}
-function polygonTriangulationWithCenter(feature) {
-  const { coordinates } = feature;
-  const flattengeo = import_earcut.default.flatten(coordinates);
-  const { vertices, dimensions, holes } = flattengeo;
-  return {
-    indices: (0, import_earcut.default)(vertices, holes, dimensions),
-    vertices: getVerticesWithCenter(vertices),
-    size: dimensions + 4
-  };
-}
-function getVerticesWithCenter(vertices) {
-  const verticesWithCenter = [];
-  const { center, radius } = (0, import_l7_utils.calculatePointsCenterAndRadius)(vertices);
-  for (let i = 0; i < vertices.length; i += 2) {
-    const lng = vertices[i];
-    const lat = vertices[i + 1];
-    verticesWithCenter.push(lng, lat, 0, ...center, radius);
-  }
-  return verticesWithCenter;
-}
-function PolygonExtrudeTriangulation(feature) {
-  const coordinates = feature.coordinates;
-  const { positions, index, normals } = (0, import_extrude.extrude_PolygonNormal)(coordinates, true);
-  return {
-    vertices: positions,
-    indices: index,
-    normals,
-    size: 5
-  };
-}
-function HeatmapGridTriangulation(feature) {
-  const { shape } = feature;
-  const { positions, index } = getHeatmapGeometry(shape);
-  return {
-    vertices: positions,
-    indices: index,
-    size: 3
-  };
-}
-function RasterImageTriangulation(feature) {
-  const coordinates = feature.coordinates;
-  const positions = [
-    ...coordinates[0],
-    0,
-    0,
-    1,
-    coordinates[1][0],
-    coordinates[0][1],
-    0,
-    1,
-    1,
-    ...coordinates[1],
-    0,
-    1,
-    0,
-    ...coordinates[0],
-    0,
-    0,
-    1,
-    ...coordinates[1],
-    0,
-    1,
-    0,
-    coordinates[0][0],
-    coordinates[1][1],
-    0,
-    0,
-    0
-  ];
-  const indexs = [0, 1, 2, 3, 4, 5];
-  return {
-    vertices: positions,
-    indices: indexs,
-    size: 5
-  };
-}
-function LineArcTriangulation(feature, segmentNumber) {
-  const segNum = segmentNumber ? segmentNumber : 30;
-  const coordinates = feature.coordinates;
-  const positions = [];
-  const indexArray = [];
-  for (let i = 0; i < segNum; i++) {
-    positions.push(i, 1, i, coordinates[0][0], coordinates[0][1], coordinates[1][0], coordinates[1][1], i, -1, i, coordinates[0][0], coordinates[0][1], coordinates[1][0], coordinates[1][1]);
-    if (i !== segNum - 1) {
-      indexArray.push(...[0, 1, 2, 1, 3, 2].map((v) => {
-        return i * 2 + v;
-      }));
-    }
-  }
-  return {
-    vertices: positions,
-    indices: indexArray,
-    size: 7
-  };
-}
-function HeatmapTriangulation(feature) {
-  const coordinates = feature.coordinates;
-  if (coordinates.length === 2) {
-    coordinates.push(0);
-  }
-  const size = feature.size;
-  const dir = addDir(-1, 1);
-  const dir1 = addDir(1, 1);
-  const dir2 = addDir(-1, -1);
-  const dir3 = addDir(1, -1);
-  const positions = [
-    ...coordinates,
-    ...dir,
-    ...coordinates,
-    ...dir2,
-    ...coordinates,
-    ...dir3,
-    ...coordinates,
-    ...dir1
-  ];
-  const indexArray = [0, 1, 2, 3, 0, 2];
-  return {
-    vertices: positions,
-    indices: indexArray,
-    size: 5
-  };
-}
-function getGeometry(shape, needFlat = false) {
-  if (GeometryCache && GeometryCache[shape]) {
-    return GeometryCache[shape];
-  }
-  const path = import_Path.geometryShape[shape] ? import_Path.geometryShape[shape]() : import_Path.geometryShape.cylinder();
-  const geometry = (0, import_extrude.extrude_PolygonNormal)([path], needFlat);
-  GeometryCache[shape] = geometry;
-  return geometry;
-}
-function getHeatmapGeometry(shape) {
-  const shape3d = [
-    "cylinder",
-    "triangleColumn",
-    "hexagonColumn",
-    "squareColumn"
-  ];
-  const path = import_Path.geometryShape[shape] ? import_Path.geometryShape[shape]() : import_Path.geometryShape.circle();
-  const geometry = shape3d.indexOf(shape) === -1 ? (0, import_extrude.fillPolygon)([path]) : (0, import_extrude.default)([path]);
-  return geometry;
-}
-function addDir(dirX, dirY) {
-  const x = (dirX + 1) / 2;
-  const y = (dirY + 1) / 2;
-  return [x, y];
-}
-function earthTriangulation() {
-  const earthmesh = (0, import_utils.primitiveSphere)(import_utils.EARTH_RADIUS, { segments: import_utils.EARTH_SEGMENTS });
-  const { positionsArr, indicesArr, normalArr } = earthmesh;
-  return {
-    vertices: positionsArr,
-    indices: indicesArr,
-    size: 5,
-    normals: normalArr
-  };
-}
-function earthOuterTriangulation() {
-  const earthmesh = (0, import_utils.primitiveSphere)(import_utils.EARTH_RADIUS + import_utils.EARTH_RADIUS_OUTER, {
-    segments: import_utils.EARTH_SEGMENTS
-  });
-  const { positionsArr, indicesArr, normalArr } = earthmesh;
-  return {
-    vertices: positionsArr,
-    indices: indicesArr,
-    size: 5,
-    normals: normalArr
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GlobelPointFillTriangulation,
-  HeatmapGridTriangulation,
-  HeatmapTriangulation,
-  LineArcTriangulation,
-  LineTriangulation,
-  PointExtrudeTriangulation,
-  PointFillTriangulation,
-  PointImageTriangulation,
-  PolygonExtrudeTriangulation,
-  RasterImageTriangulation,
-  SimpleLineTriangulation,
-  earthOuterTriangulation,
-  earthTriangulation,
-  polygonTriangulation,
-  polygonTriangulationWithCenter
-});

package/lib/earth/index.js

@@ -1,69 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/earth/index.ts
-var earth_exports = {};
-__export(earth_exports, {
-  default: () => EarthLayer
-});
-module.exports = __toCommonJS(earth_exports);
-var import_BaseLayer = __toESM(require("../core/BaseLayer"));
-var import_atmosphere = __toESM(require("./models/atmosphere"));
-var import_base = __toESM(require("./models/base"));
-var import_bloomsphere = __toESM(require("./models/bloomsphere"));
-var EarthModels = {
-  base: import_base.default,
-  atomSphere: import_atmosphere.default,
-  bloomSphere: import_bloomsphere.default
-};
-var earthLayerTypes = ["base", "atomSphere", "bloomSphere"];
-var EarthLayer = class extends import_BaseLayer.default {
-  constructor() {
-    super(...arguments);
-    this.type = "EarthLayer";
-  }
-  buildModels() {
-    const shape = this.getModelType();
-    this.layerModel = new EarthModels[shape](this);
-    this.layerModel.initModels((models) => {
-      this.models = models;
-      this.renderLayers();
-    });
-  }
-  setEarthTime(time) {
-    if (this.layerModel && this.layerModel.setEarthTime) {
-      this.layerModel.setEarthTime(time);
-    } else {
-      console.warn("\u8BF7\u5728 scene loaded \u4E4B\u540E\u6267\u884C\u8BE5\u65B9\u6CD5\uFF01");
-    }
-  }
-  getModelType() {
-    var _a;
-    const shapeAttribute = this.styleAttributeService.getLayerStyleAttribute("shape");
-    let shape = ((_a = shapeAttribute == null ? void 0 : shapeAttribute.scale) == null ? void 0 : _a.field) || "base";
-    if (earthLayerTypes.indexOf(shape) < 0) {
-      shape = "base";
-    }
-    return shape;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});

package/lib/earth/models/atmosphere.js

@@ -1,118 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/earth/models/atmosphere.ts
-var atmosphere_exports = {};
-__export(atmosphere_exports, {
-  default: () => EarthAtomSphereModel
-});
-module.exports = __toCommonJS(atmosphere_exports);
-var import_l7_core = require("@antv/l7-core");
-var import_lodash = require("lodash");
-var import_BaseModel = __toESM(require("../../core/BaseModel"));
-var import_triangulation = require("../../core/triangulation");
-var import_atmosphere_frag = __toESM(require("../shaders/atmosphere_frag.glsl"));
-var import_atmosphere_vert = __toESM(require("../shaders/atmosphere_vert.glsl"));
-var EarthAtomSphereModel = class extends import_BaseModel.default {
-  getUninforms() {
-    const {
-      opacity = 1
-    } = this.layer.getLayerConfig();
-    return {
-      u_opacity: (0, import_lodash.isNumber)(opacity) ? opacity : 1
-    };
-  }
-  initModels(callbackModel) {
-    this.buildModels(callbackModel);
-  }
-  clearModels() {
-    return "";
-  }
-  buildModels(callbackModel) {
-    this.layer.zIndex = -997;
-    this.layer.buildLayerModel({
-      moduleName: "earthAtmo",
-      vertexShader: import_atmosphere_vert.default,
-      fragmentShader: import_atmosphere_frag.default,
-      triangulation: import_triangulation.earthTriangulation,
-      depth: { enable: false },
-      blend: this.getBlend()
-    }).then((model) => {
-      callbackModel([model]);
-    }).catch((err) => {
-      console.warn(err);
-      callbackModel([]);
-    });
-  }
-  registerBuiltinAttributes() {
-    this.styleAttributeService.registerStyleAttribute({
-      name: "size",
-      type: import_l7_core.AttributeType.Attribute,
-      descriptor: {
-        name: "a_Size",
-        buffer: {
-          usage: import_l7_core.gl.DYNAMIC_DRAW,
-          data: [],
-          type: import_l7_core.gl.FLOAT
-        },
-        size: 1,
-        update: (feature, featureIdx, vertex, attributeIdx) => {
-          const { size = 1 } = feature;
-          return Array.isArray(size) ? [size[0]] : [size];
-        }
-      }
-    });
-    this.styleAttributeService.registerStyleAttribute({
-      name: "normal",
-      type: import_l7_core.AttributeType.Attribute,
-      descriptor: {
-        name: "a_Normal",
-        buffer: {
-          usage: import_l7_core.gl.STATIC_DRAW,
-          data: [],
-          type: import_l7_core.gl.FLOAT
-        },
-        size: 3,
-        update: (feature, featureIdx, vertex, attributeIdx, normal) => {
-          return normal;
-        }
-      }
-    });
-    this.styleAttributeService.registerStyleAttribute({
-      name: "uv",
-      type: import_l7_core.AttributeType.Attribute,
-      descriptor: {
-        name: "a_Uv",
-        buffer: {
-          usage: import_l7_core.gl.DYNAMIC_DRAW,
-          data: [],
-          type: import_l7_core.gl.FLOAT
-        },
-        size: 2,
-        update: (feature, featureIdx, vertex, attributeIdx) => {
-          return [vertex[3], vertex[4]];
-        }
-      }
-    });
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});