@antv/l7-layers 2.19.10 → 2.19.11

package/es/core/BaseLayer.js

@@ -13,7 +13,7 @@ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _applyDecoratedDescriptor from "@babel/runtime/helpers/esm/applyDecoratedDescriptor";
 import _initializerWarningHelper from "@babel/runtime/helpers/esm/initializerWarningHelper";
 var _excluded = ["passes"],
-  _excluded2 = ["moduleName", "vertexShader", "fragmentShader", "inject", "triangulation", "segmentNumber"];
+  _excluded2 = ["moduleName", "vertexShader", "fragmentShader", "inject", "triangulation", "styleOption"];
 var _dec, _class, _descriptor;
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
@@ -1157,11 +1157,11 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
     value: function () {
       var _buildLayerModel = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
         var _this10 = this;
-        var moduleName, vertexShader, fragmentShader, inject, triangulation, segmentNumber, rest, _this$shaderModuleSer, vs, fs, uniforms, createModel;
+        var moduleName, vertexShader, fragmentShader, inject, triangulation, styleOption, rest, _this$shaderModuleSer, vs, fs, uniforms, createModel;
         return _regeneratorRuntime.wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              moduleName = options.moduleName, vertexShader = options.vertexShader, fragmentShader = options.fragmentShader, inject = options.inject, triangulation = options.triangulation, segmentNumber = options.segmentNumber, rest = _objectWithoutProperties(options, _excluded2);
+              moduleName = options.moduleName, vertexShader = options.vertexShader, fragmentShader = options.fragmentShader, inject = options.inject, triangulation = options.triangulation, styleOption = options.styleOption, rest = _objectWithoutProperties(options, _excluded2);
               this.shaderModuleService.registerModule(moduleName, {
                 vs: vertexShader,
                 fs: fragmentShader,
@@ -1171,7 +1171,7 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
               createModel = this.rendererService.createModel;
               return _context3.abrupt("return", new Promise(function (resolve) {
                 // console.log(this.encodedData)
-                var _this10$styleAttribut = _this10.styleAttributeService.createAttributesAndIndices(_this10.encodedData, triangulation, segmentNumber),
+                var _this10$styleAttribut = _this10.styleAttributeService.createAttributesAndIndices(_this10.encodedData, triangulation, styleOption),
                   attributes = _this10$styleAttribut.attributes,
                   elements = _this10$styleAttribut.elements,
                   count = _this10$styleAttribut.count;

package/es/core/interface.d.ts

@@ -5,12 +5,6 @@ export declare enum lineStyleType {
     'solid' = 0,
     'dash' = 1
 }
-interface ILineArrow {
-    enable: boolean;
-    arrowWidth: number;
-    arrowHeight: number;
-    tailWidth: number;
-}
 export declare enum LinearDir {
     VERTICAL = "vertical",
     HORIZONTAL = "horizontal"
@@ -31,7 +25,6 @@ export interface IBaseLayerStyleOptions {
     zIndex?: number;
     mask?: boolean;
     maskInside?: boolean;
-    usage?: string;
     color?: string;
     size?: number;
 }
@@ -57,7 +50,7 @@ export interface ILineLayerStyleOptions extends IBaseLayerStyleOptions {
     strokeWidth?: number;
     storke?: string;
     blur?: [number, number, number];
-    arrow?: ILineArrow;
+    symbol?: ILineSymbol;
     rampColors?: IColorRamp;
     featureId?: string;
     sourceLayer?: string;
@@ -233,15 +226,26 @@ export interface IRasterTerrainLayerStyleOptions extends IBaseRasterLayerStyleOp
     bScaler?: number;
     offset?: number;
 }
+export type ArrowType = 'circle' | 'triangle' | 'rect' | 'diamond' | 'classic' | 'halfTriangle' | 'none';
+export interface IArrowOptions {
+    type: ArrowType;
+    width?: number;
+    height?: number;
+    radius?: number;
+}
+export interface ILineSymbol {
+    source: ArrowType | IArrowOptions;
+    target: ArrowType | IArrowOptions;
+}
 export interface IFlowLineStyleOptions extends IBaseLayerStyleOptions {
     gapWidth?: number;
     offsets?: [number, number];
     stroke?: string;
     strokeOpacity?: number;
     strokeWidth?: number;
+    symbol?: ILineSymbol;
 }
 export interface IStyleEncodeAttributeOptions {
     field: StyleAttributeField;
     values?: StyleAttributeOption;
 }
-export {};

package/es/core/line_trangluation.d.ts

@@ -0,0 +1,19 @@
+import { IEncodeFeature } from '@antv/l7-core';
+export declare function FlowHalfArrowFillTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function FlowLineTriangulation(feature: IEncodeFeature, symbolOption?: unknown): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function ArrowLineTriangulation(feature: IEncodeFeature, symbolOption?: unknown): {
+    vertices: number[];
+    indices: number[];
+    normals: number[];
+    size: number;
+};

package/es/core/line_trangluation.js

@@ -0,0 +1,91 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { getSymbol, lineArrowPath } from "./shape/arrow";
+
+// list all arrow shape
+
+// Half Edge
+export function FlowHalfArrowFillTriangulation(feature) {
+  // @ts-ignore
+  var coord = feature.coordinates.flat();
+  var tin = 1;
+  var tout = 1.0;
+  return {
+    vertices: [1, 0, 0].concat(_toConsumableArray(coord), [
+    // 0
+    1, 2, -3], _toConsumableArray(coord), [
+    // 1
+    1, 1, -3], _toConsumableArray(coord), [
+    // 2
+    0, 1, 0], _toConsumableArray(coord), [
+    // 3
+    0, 0, 0], _toConsumableArray(coord), [
+    // 4
+    1, 0, 0], _toConsumableArray(coord), [
+    // 0
+    1, 2, -3], _toConsumableArray(coord), [
+    // 1
+    1, 1, -3], _toConsumableArray(coord), [
+    // 2
+    0, 1, 0], _toConsumableArray(coord), [
+    // 3
+    0, 0, 0], _toConsumableArray(coord)),
+    normals: [-tin, 2 * tout, 1,
+    // 0
+    2 * tout, -tout, 1,
+    // 1
+    tout, -tout, 1,
+    // 2
+    tout, -tout, 1,
+    // 3
+    -tin, -tout, 1,
+    // 4
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    indices: [0, 1, 2, 0, 2, 3, 0, 3, 4, 5, 6, 7, 5, 7, 8, 5, 8, 9],
+    size: 7
+  };
+}
+export function FlowLineTriangulation(feature, symbolOption) {
+  return symbolOption ? ArrowLineTriangulation(feature, symbolOption) : FlowHalfArrowFillTriangulation(feature);
+}
+export function ArrowLineTriangulation(feature, symbolOption) {
+  // @ts-ignore
+  var coord = feature.coordinates.flat();
+  var _ref = symbolOption,
+    _ref$target = _ref.target,
+    target = _ref$target === void 0 ? 'classic' : _ref$target,
+    _ref$source = _ref.source,
+    source = _ref$source === void 0 ? 'circle' : _ref$source;
+  var startSymbol = shape2Vertices(getSymbol(source, 'source'), coord, 0, 0);
+  var linePath = lineArrowPath(coord, startSymbol.vertices.length / 7, symbolOption);
+  var endSymbol = shape2Vertices(getSymbol(target, 'target'), coord, 1, startSymbol.vertices.length / 7 + linePath.vertices.length / 7);
+  var data = {
+    vertices: [].concat(_toConsumableArray(startSymbol.vertices), _toConsumableArray(linePath.vertices), _toConsumableArray(endSymbol.vertices)),
+    indices: [].concat(_toConsumableArray(startSymbol.outLineIndices), _toConsumableArray(linePath.outLineIndices), _toConsumableArray(endSymbol.outLineIndices), _toConsumableArray(startSymbol.indices), _toConsumableArray(linePath.indices), _toConsumableArray(endSymbol.indices)),
+    normals: [].concat(_toConsumableArray(startSymbol.normals), _toConsumableArray(linePath.normals), _toConsumableArray(endSymbol.normals)),
+    size: 7
+  };
+  return data;
+}
+// start 0,end 1;
+function shape2Vertices(shape, coord) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var indexOffset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var shapeVertices = [];
+  var vertices = shape.vertices,
+    indices = shape.indices,
+    dimensions = shape.dimensions,
+    outLineIndices = shape.outLineIndices;
+  for (var i = 0; i < vertices.length; i += dimensions) {
+    shapeVertices.push.apply(shapeVertices, [type, vertices[i + 1], vertices[i]].concat(_toConsumableArray(coord)));
+  }
+  return _objectSpread(_objectSpread({}, shape), {}, {
+    vertices: shapeVertices,
+    indices: indices.map(function (i) {
+      return i + indexOffset;
+    }),
+    outLineIndices: outLineIndices.map(function (i) {
+      return i + indexOffset;
+    })
+  });
+}

package/es/core/shape/arrow.d.ts

@@ -0,0 +1,25 @@
+import { ArrowType, IArrowOptions, ILineSymbol } from '../interface';
+export interface IArrowData {
+    vertices: number[];
+    indices: number[];
+    outLineIndices: number[];
+    dimensions: number;
+    offset?: number[];
+    normals: number[];
+}
+export type arrowPosition = -1 | 1;
+export declare function halfTriangleArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function triangleArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function rectArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function diamondArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function classicArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function circleArraw(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function lineArrowPath(coord: number[], indexOffset: number | undefined, symbol: ILineSymbol): IArrowData;
+export declare function getSymbol(type: ArrowType | IArrowOptions, position: 'source' | 'target'): IArrowData | {
+    vertices: never[];
+    indices: never[];
+    normals: never[];
+    dimensions: number;
+    outLineIndices: never[];
+    outLineNormals: never[];
+};

package/es/core/shape/arrow.js

@@ -0,0 +1,160 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { circle } from "./Path";
+import earcut from 'earcut';
+var maxArrowWidthMap = {
+  circle: 2,
+  triangle: 2,
+  diamond: 4,
+  rect: 2,
+  classic: 3,
+  halfTriangle: 2,
+  'none': 0
+};
+var PathHeight = 1 / 2;
+export function halfTriangleArrow(dir, options) {
+  var _options$width = options.width,
+    width = _options$width === void 0 ? 2 : _options$width,
+    _options$height = options.height,
+    height = _options$height === void 0 ? 1 : _options$height;
+  return {
+    vertices: [0, PathHeight * dir, 1 * dir * width, -(height + PathHeight) * dir, 1 * dir * width, (height - PathHeight) * dir, 0, PathHeight * dir, 1 * dir * width, -(height + PathHeight) * dir, 1 * dir * width, (height - PathHeight) * dir],
+    indices: [3, 4, 5],
+    outLineIndices: [0, 1, 2],
+    normals: [1 * dir, -2 * dir, 1,
+    // y,x
+    -2 * dir, 1.5 * dir, 1, 1 * dir, 1.5 * dir, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+export function triangleArrow(dir, options) {
+  var _options$width2 = options.width,
+    width = _options$width2 === void 0 ? 2 : _options$width2,
+    _options$height2 = options.height,
+    height = _options$height2 === void 0 ? 3 : _options$height2;
+  return {
+    vertices: [0, 0, 1 * dir * width, 1 * height, 1 * dir * width, -1 * height, 0, 0, 1 * dir * width, 1 * height, 1 * dir * width, -1 * height],
+    outLineIndices: [0, 1, 2],
+    indices: [3, 4, 5],
+    normals: [0, -1.5 * dir, 1, 2, 1 * dir, 1, -2, 1 * dir, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+export function rectArrow(dir, options) {
+  var _options$width3 = options.width,
+    width = _options$width3 === void 0 ? 2 : _options$width3,
+    _options$height3 = options.height,
+    height = _options$height3 === void 0 ? 2 : _options$height3;
+  return {
+    vertices: [0, height / 2, dir * width * 1, height / 2, dir * width * 1, -height / 2, 0, -height / 2, 0, height / 2, dir * width * 1, height / 2, dir * width * 1, -height / 2, 0, -height / 2],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+export function diamondArrow(dir, options) {
+  var _options$width4 = options.width,
+    width = _options$width4 === void 0 ? 2 : _options$width4,
+    _options$height4 = options.height,
+    height = _options$height4 === void 0 ? 3 : _options$height4;
+  return {
+    vertices: [0, 0, 1 * width * dir, 0.5 * height, 2 * width * dir, 0, 1 * width * dir, -0.5 * height, 0, 0, 1 * width * dir, 0.5 * height, 2 * width * dir, 0, 1 * width * dir, -0.5 * height],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+export function classicArrow(dir, options) {
+  var _options$width5 = options.width,
+    width = _options$width5 === void 0 ? 2 : _options$width5,
+    _options$height5 = options.height,
+    height = _options$height5 === void 0 ? 3 : _options$height5;
+  return {
+    vertices: [0, 0, 2 * dir * width, 1 * height, 1.5 * dir * width, 0, 2 * dir * width, -1 * height, 0, 0, 2 * dir * width, 1 * height, 1.5 * dir * width, 0, 2 * dir * width, -1 * height],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+export function circleArraw(dir, options) {
+  var _options$width6 = options.width,
+    width = _options$width6 === void 0 ? 2 : _options$width6,
+    _options$height6 = options.height,
+    height = _options$height6 === void 0 ? 2 : _options$height6;
+  var path = circle();
+  var flattengeo = earcut.flatten([path]);
+  var triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  // @ts-ignore
+  var vertice = path.map(function (t) {
+    return [t[0] * width * dir, t[1] * height];
+  }).flat();
+  return {
+    vertices: [].concat(_toConsumableArray(vertice), _toConsumableArray(vertice)),
+    dimensions: 2,
+    indices: triangles.map(function (v) {
+      return v + path.length;
+    }),
+    outLineIndices: triangles,
+    normals: [].concat(_toConsumableArray(path.map(function (t) {
+      return [t[1] * height, t[0] * width * dir, 1];
+    }).flat()), _toConsumableArray(new Array(path.length * 3).fill(0)))
+  };
+}
+export function lineArrowPath(coord) {
+  var indexOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var symbol = arguments.length > 2 ? arguments[2] : undefined;
+  var sourceType = _typeof(symbol['source']) === 'object' ? symbol['source'].type : symbol['source'];
+  var targetType = _typeof(symbol['target']) === 'object' ? symbol['target'].type : symbol['target'];
+  var _ref = _typeof(symbol['source']) === 'object' ? symbol['source'] : {},
+    _ref$width = _ref.width,
+    sourceWidth = _ref$width === void 0 ? sourceType ? maxArrowWidthMap[sourceType] : 0 : _ref$width,
+    _ref$height = _ref.height,
+    sourceHeight = _ref$height === void 0 ? 2 : _ref$height;
+  var _ref2 = _typeof(symbol['target']) === 'object' ? symbol['target'] : {},
+    _ref2$width = _ref2.width,
+    targetWidth = _ref2$width === void 0 ? targetType ? maxArrowWidthMap[targetType] : 0 : _ref2$width,
+    _ref2$height = _ref2.height,
+    targetHeight = _ref2$height === void 0 ? 2 : _ref2$height;
+  return {
+    vertices: [0, PathHeight, 1 * sourceWidth].concat(_toConsumableArray(coord), [1, PathHeight, -1 * targetWidth], _toConsumableArray(coord), [1, -PathHeight, -1 * targetWidth], _toConsumableArray(coord), [0, -PathHeight, 1 * sourceWidth], _toConsumableArray(coord), [0, PathHeight, 1 * sourceWidth], _toConsumableArray(coord), [1, PathHeight, -1 * targetWidth], _toConsumableArray(coord), [1, -PathHeight, -1 * targetWidth], _toConsumableArray(coord), [0, -PathHeight, 1 * sourceWidth], _toConsumableArray(coord)),
+    outLineIndices: [0, 1, 2, 0, 2, 3].map(function (t) {
+      return t + indexOffset;
+    }),
+    indices: [4, 5, 6, 4, 6, 7].map(function (t) {
+      return t + indexOffset;
+    }),
+    normals: [1, -1, 1, 1, 1, 1, -1, 0, 1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+export function getSymbol(type, position) {
+  var shape = _typeof(type) === 'object' ? type.type : type;
+  var dir = position === 'source' ? 1 : -1;
+  var option = _typeof(type) === 'object' ? type : {};
+  switch (shape) {
+    case 'circle':
+      return circleArraw(dir, option);
+    case 'triangle':
+      return triangleArrow(dir, option);
+    case 'diamond':
+      return diamondArrow(dir, option);
+    case 'rect':
+      return rectArrow(dir, option);
+    case 'classic':
+      return classicArrow(dir, option);
+    case 'halfTriangle':
+      return halfTriangleArrow(dir, option);
+    default:
+      return {
+        vertices: [],
+        indices: [],
+        normals: [],
+        dimensions: 2,
+        outLineIndices: [],
+        outLineNormals: []
+      };
+  }
+}

package/es/core/triangulation.d.ts

@@ -48,13 +48,7 @@ export declare function LineTriangulation(feature: IEncodeFeature): {
     size: number;
 };
 export declare function FlowLineFillTriangulation(feature: IEncodeFeature): {
-    vertices: any[];
-    normals: number[];
-    indices: number[];
-    size: number;
-};
-export declare function FlowLineStrokeTriangulation(feature: IEncodeFeature): {
-    vertices: any[];
+    vertices: number[];
     normals: number[];
     indices: number[];
     size: number;
@@ -107,7 +101,7 @@ export declare function RasterImageTriangulation(feature: IEncodeFeature): {
  * @param feature 映射数据
  * @param segNum 弧线线段数
  */
-export declare function LineArcTriangulation(feature: IEncodeFeature, segmentNumber?: number): {
+export declare function LineArcTriangulation(feature: IEncodeFeature, styleOption?: unknown): {
     vertices: number[];
     indices: number[];
     size: number;

package/es/core/triangulation.js

@@ -161,36 +161,6 @@ export function FlowLineFillTriangulation(feature) {
     size: 7
   };
 }
-export function FlowLineStrokeTriangulation(feature) {
-  // @ts-ignore
-  var coord = feature.coordinates.flat();
-  var tin = 1;
-  var tout = 1;
-  return {
-    vertices: [1, 0, 0].concat(_toConsumableArray(coord), [
-    // 0
-    1, 2, -3], _toConsumableArray(coord), [
-    // 1
-    1, 1, -3], _toConsumableArray(coord), [
-    // 2
-    0, 1, 0], _toConsumableArray(coord), [
-    // 3
-    0, 0, 0], _toConsumableArray(coord)),
-    normals: [-tin, 2 * tout, 1,
-    // 0
-    2 * tout, -tout, 1,
-    // 1
-    tout, -tout, 1,
-    // 2
-    tout, -tout, 1,
-    // 3
-    -tin, -tout, 1 // 4
-    ],
-
-    indices: [0, 1, 1, 2, 2, 3, 3, 4, 4, 0],
-    size: 7
-  };
-}
 export function SimpleLineTriangulation(feature) {
   var coordinates = feature.coordinates;
   var pos = [];
@@ -392,8 +362,10 @@ export function RasterImageTriangulation(feature) {
  * @param feature 映射数据
  * @param segNum 弧线线段数
  */
-export function LineArcTriangulation(feature, segmentNumber) {
-  var segNum = segmentNumber ? segmentNumber : 30;
+export function LineArcTriangulation(feature, styleOption) {
+  // @ts-ignore
+  var _styleOption$segmentN = styleOption.segmentNumber,
+    segmentNumber = _styleOption$segmentN === void 0 ? 30 : _styleOption$segmentN;
   var coordinates = feature.coordinates;
   var positions = [];
   var indexArray = [];
@@ -401,13 +373,13 @@ export function LineArcTriangulation(feature, segmentNumber) {
     // 上线两个顶点
     // [ x, y, z, sx,sy, tx,ty]
     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) {
+    if (i !== segmentNumber - 1) {
       indexArray.push.apply(indexArray, _toConsumableArray([0, 1, 2, 1, 3, 2].map(function (v) {
         return i * 2 + v;
       })));
     }
   };
-  for (var i = 0; i < segNum; i++) {
+  for (var i = 0; i < segmentNumber; i++) {
     _loop(i);
   }
   return {

package/es/line/index.js

@@ -87,7 +87,8 @@ var LineLayer = /*#__PURE__*/function (_BaseLayer) {
         },
         tileLine: {},
         earthArc3d: {},
-        flowline: {}
+        flowline: {},
+        arrow: {}
       };
       return defaultConfig[type];
     }

package/es/line/models/arc.js

@@ -18,7 +18,7 @@ import { LineArcTriangulation } from "../../core/triangulation";
 /* babel-plugin-inline-import '../shaders/dash/arc_dash_frag.glsl' */
 var arc_dash_frag = "varying vec4 v_dash_array;\nvarying vec4 v_color;\nvarying float v_distance_ratio;\n\nuniform float segmentNumber;\n\n\n#pragma include \"picking\"\n\nvoid main() {\n  gl_FragColor = v_color;\n\n  float flag = 0.;\n  float dashLength = mod(v_distance_ratio, v_dash_array.x + v_dash_array.y + v_dash_array.z + v_dash_array.w);\n  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)) {\n    flag = 1.;\n  };\n  gl_FragColor.a *=flag;\n  \n  gl_FragColor = filterColor(gl_FragColor);\n}";
 /* babel-plugin-inline-import '../shaders/dash/arc_dash_vert.glsl' */
-var arc_dash_vert = "\nattribute vec4 a_Color;\nattribute vec3 a_Position;\nattribute vec4 a_Instance;\nattribute float a_Size;\nuniform mat4 u_ModelMatrix;\n\nuniform float segmentNumber;\nvarying vec4 v_color;\n\n\nuniform vec4 u_dash_array: [10.0, 5., 0, 0];\nuniform float u_lineDir: 1.0;\nvarying vec4 v_dash_array;\nvarying float v_distance_ratio;\n\nuniform float u_thetaOffset: 0.314;\n\n#pragma include \"projection\"\n#pragma include \"project\"\n#pragma include \"picking\"\n\nfloat bezier3(vec3 arr, float t) {\n  float ut = 1. - t;\n  return (arr.x * ut + arr.y * t) * ut + (arr.y * ut + arr.z * t) * t;\n}\nvec2 midPoint(vec2 source, vec2 target, float arcThetaOffset) {\n  vec2 center = target - source;\n  float r = length(center);\n  float theta = atan(center.y, center.x);\n  float thetaOffset = arcThetaOffset;\n  float r2 = r / 2.0 / cos(thetaOffset);\n  float theta2 = theta + thetaOffset;\n  vec2 mid = vec2(r2*cos(theta2) + source.x, r2*sin(theta2) + source.y);\n  if(u_lineDir == 1.0) { // \u6B63\u5411\n    return mid;\n  } else { // \u9006\u5411\n    // (mid + vmin)/2 = (s + t)/2\n    vec2 vmid = source + target - mid;\n    return vmid;\n  }\n  // return mid;\n}\nfloat getSegmentRatio(float index) {\n  // dash: index / (segmentNumber - 1.);\n  // normal: smoothstep(0.0, 1.0, index / (segmentNumber - 1.));\n  return index / (segmentNumber - 1.);\n}\nvec2 interpolate (vec2 source, vec2 target, float t, float arcThetaOffset) {\n  // if the angularDist is PI, linear interpolation is applied. otherwise, use spherical interpolation\n  vec2 mid = midPoint(source, target, arcThetaOffset);\n  vec3 x = vec3(source.x, mid.x, target.x);\n  vec3 y = vec3(source.y, mid.y, target.y);\n  return vec2(bezier3(x ,t), bezier3(y,t));\n}\nvec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n  vec2 offset = dir_screenspace * offset_direction * setPickingSize(a_Size) / 2.0;\n  return offset;\n}\nvec2 getNormal(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n   return reverse_offset_normal(vec3(dir_screenspace,1.0)).xy * sign(offset_direction);\n}\n\nvoid main() {\n  v_color = vec4(a_Color.xyz, a_Color.w * opacity);\n  \n  vec2 source = a_Instance.rg;  // \u8D77\u59CB\u70B9\n  vec2 target =  a_Instance.ba; // \u7EC8\u70B9\n  float segmentIndex = a_Position.x;\n  float segmentRatio = getSegmentRatio(segmentIndex);\n\n  float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));\n  float nextSegmentRatio = getSegmentRatio(segmentIndex + indexDir);\n\n  vec2 s = source;\n  vec2 t = target;\n  \n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x\n    s = unProjCustomCoord(source);\n    t = unProjCustomCoord(target);\n  }\n  float total_Distance = pixelDistance(s, t) / 2.0 * PI;\n  v_dash_array = pow(2.0, 20.0 - u_Zoom) * u_dash_array / total_Distance;\n\n  v_distance_ratio = segmentIndex / segmentNumber;\n\n  vec4 curr = project_position(vec4(interpolate(source, target, segmentRatio, u_thetaOffset), 0.0, 1.0));\n  vec4 next = project_position(vec4(interpolate(source, target, nextSegmentRatio, u_thetaOffset), 0.0, 1.0));\n \n  \n  vec2 offset = project_pixel(getExtrusionOffset((next.xy - curr.xy) * indexDir, a_Position.y));\n\n  gl_Position = project_common_position_to_clipspace_v2(vec4(curr.xy + offset, 0, 1.0));\n\n  gl_PointSize = 5.0;\n  setPickingColor(a_PickingColor);\n}\n"; // arc normal line
+var arc_dash_vert = "\nattribute vec4 a_Color;\nattribute vec3 a_Position;\nattribute vec4 a_Instance;\nattribute float a_Size;\nuniform mat4 u_ModelMatrix;\n\nuniform float segmentNumber;\nvarying vec4 v_color;\n\n\nuniform vec4 u_dash_array: [10.0, 5., 0, 0];\nuniform float u_lineDir: 1.0;\nvarying vec4 v_dash_array;\nvarying float v_distance_ratio;\n#pragma include \"projection\"\n#pragma include \"project\"\n#pragma include \"picking\"\n\nfloat bezier3(vec3 arr, float t) {\n  float ut = 1. - t;\n  return (arr.x * ut + arr.y * t) * ut + (arr.y * ut + arr.z * t) * t;\n}\nvec2 midPoint(vec2 source, vec2 target, float arcThetaOffset) {\n  vec2 center = target - source;\n  float r = length(center);\n  float theta = atan(center.y, center.x);\n  float thetaOffset = arcThetaOffset;\n  float r2 = r / 2.0 / cos(thetaOffset);\n  float theta2 = theta + thetaOffset;\n  vec2 mid = vec2(r2*cos(theta2) + source.x, r2*sin(theta2) + source.y);\n  if(u_lineDir == 1.0) { // \u6B63\u5411\n    return mid;\n  } else { // \u9006\u5411\n    // (mid + vmin)/2 = (s + t)/2\n    vec2 vmid = source + target - mid;\n    return vmid;\n  }\n  // return mid;\n}\nfloat getSegmentRatio(float index) {\n  // dash: index / (segmentNumber - 1.);\n  // normal: smoothstep(0.0, 1.0, index / (segmentNumber - 1.));\n  return index / (segmentNumber - 1.);\n}\nvec2 interpolate (vec2 source, vec2 target, float t, float arcThetaOffset) {\n  // if the angularDist is PI, linear interpolation is applied. otherwise, use spherical interpolation\n  vec2 mid = midPoint(source, target, arcThetaOffset);\n  vec3 x = vec3(source.x, mid.x, target.x);\n  vec3 y = vec3(source.y, mid.y, target.y);\n  return vec2(bezier3(x ,t), bezier3(y,t));\n}\nvec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n  vec2 offset = dir_screenspace * offset_direction * setPickingSize(a_Size) / 2.0;\n  return offset;\n}\nvec2 getNormal(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n   return reverse_offset_normal(vec3(dir_screenspace,1.0)).xy * sign(offset_direction);\n}\n\nvoid main() {\n  v_color = vec4(a_Color.xyz, a_Color.w * opacity);\n  \n  vec2 source = a_Instance.rg;  // \u8D77\u59CB\u70B9\n  vec2 target =  a_Instance.ba; // \u7EC8\u70B9\n  float segmentIndex = a_Position.x;\n  float segmentRatio = getSegmentRatio(segmentIndex);\n\n  float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));\n  float nextSegmentRatio = getSegmentRatio(segmentIndex + indexDir);\n\n  vec2 s = source;\n  vec2 t = target;\n  \n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x\n    s = unProjCustomCoord(source);\n    t = unProjCustomCoord(target);\n  }\n  float total_Distance = pixelDistance(s, t) / 2.0 * PI;\n  v_dash_array = pow(2.0, 20.0 - u_Zoom) * u_dash_array / total_Distance;\n\n  v_distance_ratio = segmentIndex / segmentNumber;\n\n  vec4 curr = project_position(vec4(interpolate(source, target, segmentRatio, thetaOffset), 0.0, 1.0));\n  vec4 next = project_position(vec4(interpolate(source, target, nextSegmentRatio, thetaOffset), 0.0, 1.0));\n \n  \n  vec2 offset = project_pixel(getExtrusionOffset((next.xy - curr.xy) * indexDir, a_Position.y));\n\n  gl_Position = project_common_position_to_clipspace_v2(vec4(curr.xy + offset, 0, 1.0));\n\n  gl_PointSize = 5.0;\n  setPickingColor(a_PickingColor);\n}\n"; // arc normal line
 /* babel-plugin-inline-import '../shaders/line_arc_frag.glsl' */
 var arc_line_frag = "\n#define Animate 0.0\n#define LineTexture 1.0\nuniform float u_textureBlend;\nuniform float u_blur : 0.9;\nuniform float u_line_type: 0.0;\n// varying vec2 v_normal;\nvarying vec4 v_dash_array;\nvarying vec4 v_color;\n\nuniform float u_time;\nuniform vec4 u_animate: [ 1., 2., 1.0, 0.2 ];\n\nuniform float u_line_texture;\nuniform sampler2D u_texture;\nuniform vec2 u_textSize;\n\nuniform float segmentNumber;\nvarying vec2 v_iconMapUV;\nvarying vec4 v_lineData;\n\n\n#pragma include \"picking\"\n\nvoid main() {\n  float animateSpeed = 0.0; // \u8FD0\u52A8\u901F\u5EA6\n  gl_FragColor = v_color;\n  \n\n  if(u_animate.x == Animate && u_line_texture != LineTexture) {\n      animateSpeed = u_time / u_animate.y;\n      float alpha =1.0 - fract( mod(1.0- v_lineData.b, u_animate.z)* (1.0/ u_animate.z) + u_time / u_animate.y);\n      alpha = (alpha + u_animate.w -1.0) / u_animate.w;\n      // alpha = smoothstep(0., 1., alpha);\n      alpha = clamp(alpha, 0.0, 1.0);\n      gl_FragColor.a *= alpha;\n  }\n\n  // \u5F53\u5B58\u5728\u8D34\u56FE\u65F6\u5728\u5E95\u8272\u4E0A\u8D34\u4E0A\u8D34\u56FE\n  if(u_line_texture == LineTexture) { // while load texture\n    float arcRadio = smoothstep( 0.0, 1.0, (v_lineData.r / segmentNumber));\n    // float arcRadio = smoothstep( 0.0, 1.0, d_distance_ratio);\n\n    float count = v_lineData.g; // \u8D34\u56FE\u5728\u5F27\u7EBF\u4E0A\u91CD\u590D\u7684\u6570\u91CF\n\n    float time = 0.0;\n    if(u_animate.x == Animate) {\n      time = u_time / u_animate.y;\n    }\n    float redioCount = arcRadio * count;\n\n    float u = fract(redioCount - time);\n    float v = v_lineData.a; // \u6A2A\u5411 v\n    vec2 uv= v_iconMapUV / u_textSize + vec2(u, v) / u_textSize * 64.;\n\n    vec4 pattern = texture2D(u_texture, uv);\n\n    if(u_animate.x == Animate) {\n      float currentPlane = floor(redioCount - time);\n      float textureStep = floor(count * u_animate.z);\n      float a = mod(currentPlane, textureStep);\n      if(a < textureStep - 1.0) {\n        pattern = vec4(0.0);\n      }\n    }\n\n    if(u_textureBlend == 0.0) { // normal\n      pattern.a = 0.0;\n      gl_FragColor = filterColor(gl_FragColor + pattern);\n    } else { // replace\n        pattern.a *= v_color.a;\n        if(gl_FragColor.a <= 0.0) {\n          pattern.a = 0.0;\n        }\n        gl_FragColor = filterColor(pattern);\n    }\n    \n  } else {\n     gl_FragColor = filterColor(gl_FragColor);\n  }\n}";
 /* babel-plugin-inline-import '../shaders/line_arc_vert.glsl' */
@@ -26,7 +26,7 @@ var arc_line_vert = "#define Animate 0.0\n#define LineTexture 1.0\n\nattribute v
 /* babel-plugin-inline-import '../shaders/linear/arc_linear_frag.glsl' */
 var arc_linear_frag = "varying vec4 v_color;\n\n#pragma include \"picking\"\n\nvoid main() {\n// \u5F53\u524D\u9876\u70B9\u5728\u5F27\u7EBF\u4E2D\u6240\u5904\u7684\u5206\u6BB5\u4F4D\u7F6E\n\n  gl_FragColor = v_color;\n  gl_FragColor = filterColor(gl_FragColor);\n}";
 /* babel-plugin-inline-import '../shaders/linear/arc_linear_vert.glsl' */
-var arc_linear_vert = "\nattribute vec4 a_Color;\nattribute vec3 a_Position;\nattribute vec4 a_Instance;\nattribute float a_Size;\nuniform mat4 u_ModelMatrix;\n\nuniform float segmentNumber;\nvarying vec4 v_color;\nvarying float v_segmentIndex;\n\nuniform float u_lineDir: 1.0;\n\nuniform float u_thetaOffset: 0.314;\nuniform vec4 u_sourceColor;\nuniform vec4 u_targetColor;\n\n\n\n\n#pragma include \"projection\"\n#pragma include \"project\"\n#pragma include \"picking\"\n\nfloat bezier3(vec3 arr, float t) {\n  float ut = 1. - t;\n  return (arr.x * ut + arr.y * t) * ut + (arr.y * ut + arr.z * t) * t;\n}\nvec2 midPoint(vec2 source, vec2 target, float arcThetaOffset) {\n  vec2 center = target - source;\n  float r = length(center);\n  float theta = atan(center.y, center.x);\n  float thetaOffset = arcThetaOffset;\n  float r2 = r / 2.0 / cos(thetaOffset);\n  float theta2 = theta + thetaOffset;\n  vec2 mid = vec2(r2*cos(theta2) + source.x, r2*sin(theta2) + source.y);\n  if(u_lineDir == 1.0) { // \u6B63\u5411\n    return mid;\n  } else { // \u9006\u5411\n    // (mid + vmin)/2 = (s + t)/2\n    vec2 vmid = source + target - mid;\n    return vmid;\n  }\n  // return mid;\n}\nfloat getSegmentRatio(float index) {\n    return smoothstep(0.0, 1.0, index / (segmentNumber - 1.));\n}\nvec2 interpolate (vec2 source, vec2 target, float t, float arcThetaOffset) {\n  // if the angularDist is PI, linear interpolation is applied. otherwise, use spherical interpolation\n  vec2 mid = midPoint(source, target, arcThetaOffset);\n  vec3 x = vec3(source.x, mid.x, target.x);\n  vec3 y = vec3(source.y, mid.y, target.y);\n  return vec2(bezier3(x ,t), bezier3(y,t));\n}\nvec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n  vec2 offset = dir_screenspace * offset_direction * setPickingSize(a_Size) / 2.0;\n  return offset;\n}\nvec2 getNormal(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n   return reverse_offset_normal(vec3(dir_screenspace,1.0)).xy * sign(offset_direction);\n}\n\nvoid main() {\n  v_color = a_Color;\n\n  vec2 source = a_Instance.rg;  // \u8D77\u59CB\u70B9\n  vec2 target =  a_Instance.ba; // \u7EC8\u70B9\n  float segmentIndex = a_Position.x;\n  float segmentRatio = getSegmentRatio(segmentIndex);\n\n  float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));\n  float nextSegmentRatio = getSegmentRatio(segmentIndex + indexDir);\n  float d_distance_ratio;\n  vec4 curr = project_position(vec4(interpolate(source, target, segmentRatio, u_thetaOffset), 0.0, 1.0));\n  vec4 next = project_position(vec4(interpolate(source, target, nextSegmentRatio, u_thetaOffset), 0.0, 1.0));\n  // v_normal = getNormal((next.xy - curr.xy) * indexDir, a_Position.y);\n  //unProjCustomCoord\n  \n  vec2 offset = project_pixel(getExtrusionOffset((next.xy - curr.xy) * indexDir, a_Position.y));\n\n\n  float d_segmentIndex = a_Position.x + 1.0; // \u5F53\u524D\u9876\u70B9\u5728\u5F27\u7EBF\u4E2D\u6240\u5904\u7684\u5206\u6BB5\u4F4D\u7F6E\n\n  v_color = mix(u_sourceColor, u_targetColor, d_segmentIndex/segmentNumber);\n  v_color.a *= opacity;\n\n  gl_Position = project_common_position_to_clipspace_v2(vec4(curr.xy + offset, 0, 1.0));\n\n  setPickingColor(a_PickingColor);\n}\n";
+var arc_linear_vert = "\nattribute vec4 a_Color;\nattribute vec3 a_Position;\nattribute vec4 a_Instance;\nattribute float a_Size;\nuniform mat4 u_ModelMatrix;\n\nuniform float segmentNumber;\nvarying vec4 v_color;\nvarying float v_segmentIndex;\n\nuniform float u_lineDir: 1.0;\n\nuniform vec4 u_sourceColor;\nuniform vec4 u_targetColor;\n\n\n\n\n#pragma include \"projection\"\n#pragma include \"project\"\n#pragma include \"picking\"\n\nfloat bezier3(vec3 arr, float t) {\n  float ut = 1. - t;\n  return (arr.x * ut + arr.y * t) * ut + (arr.y * ut + arr.z * t) * t;\n}\nvec2 midPoint(vec2 source, vec2 target, float arcThetaOffset) {\n  vec2 center = target - source;\n  float r = length(center);\n  float theta = atan(center.y, center.x);\n  float thetaOffset = arcThetaOffset;\n  float r2 = r / 2.0 / cos(thetaOffset);\n  float theta2 = theta + thetaOffset;\n  vec2 mid = vec2(r2*cos(theta2) + source.x, r2*sin(theta2) + source.y);\n  if(u_lineDir == 1.0) { // \u6B63\u5411\n    return mid;\n  } else { // \u9006\u5411\n    // (mid + vmin)/2 = (s + t)/2\n    vec2 vmid = source + target - mid;\n    return vmid;\n  }\n  // return mid;\n}\nfloat getSegmentRatio(float index) {\n    return smoothstep(0.0, 1.0, index / (segmentNumber - 1.));\n}\nvec2 interpolate (vec2 source, vec2 target, float t, float arcThetaOffset) {\n  // if the angularDist is PI, linear interpolation is applied. otherwise, use spherical interpolation\n  vec2 mid = midPoint(source, target, arcThetaOffset);\n  vec3 x = vec3(source.x, mid.x, target.x);\n  vec3 y = vec3(source.y, mid.y, target.y);\n  return vec2(bezier3(x ,t), bezier3(y,t));\n}\nvec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n  vec2 offset = dir_screenspace * offset_direction * setPickingSize(a_Size) / 2.0;\n  return offset;\n}\nvec2 getNormal(vec2 line_clipspace, float offset_direction) {\n  // normalized direction of the line\n  vec2 dir_screenspace = normalize(line_clipspace);\n  // rotate by 90 degrees\n   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n   return reverse_offset_normal(vec3(dir_screenspace,1.0)).xy * sign(offset_direction);\n}\n\nvoid main() {\n  v_color = a_Color;\n\n  vec2 source = a_Instance.rg;  // \u8D77\u59CB\u70B9\n  vec2 target =  a_Instance.ba; // \u7EC8\u70B9\n  float segmentIndex = a_Position.x;\n  float segmentRatio = getSegmentRatio(segmentIndex);\n\n  float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));\n  float nextSegmentRatio = getSegmentRatio(segmentIndex + indexDir);\n  float d_distance_ratio;\n  vec4 curr = project_position(vec4(interpolate(source, target, segmentRatio, thetaOffset), 0.0, 1.0));\n  vec4 next = project_position(vec4(interpolate(source, target, nextSegmentRatio, thetaOffset), 0.0, 1.0));\n  // v_normal = getNormal((next.xy - curr.xy) * indexDir, a_Position.y);\n  //unProjCustomCoord\n  \n  vec2 offset = project_pixel(getExtrusionOffset((next.xy - curr.xy) * indexDir, a_Position.y));\n\n\n  float d_segmentIndex = a_Position.x + 1.0; // \u5F53\u524D\u9876\u70B9\u5728\u5F27\u7EBF\u4E2D\u6240\u5904\u7684\u5206\u6BB5\u4F4D\u7F6E\n\n  v_color = mix(u_sourceColor, u_targetColor, d_segmentIndex/segmentNumber);\n  v_color.a *= opacity;\n\n  gl_Position = project_common_position_to_clipspace_v2(vec4(curr.xy + offset, 0, 1.0));\n\n  setPickingColor(a_PickingColor);\n}\n";
 var lineStyleObj = {
   solid: 0.0,
   dash: 1.0
@@ -207,7 +207,9 @@ var ArcModel = /*#__PURE__*/function (_BaseModel) {
                 depth: {
                   enable: false
                 },
-                segmentNumber: segmentNumber
+                styleOption: {
+                  segmentNumber: segmentNumber
+                }
               });
             case 4:
               model = _context2.sent;

package/es/line/models/arc_3d.js

@@ -194,7 +194,9 @@ var Arc3DModel = /*#__PURE__*/function (_BaseModel) {
                 fragmentShader: frag,
                 inject: this.getInject(),
                 triangulation: LineArcTriangulation,
-                segmentNumber: segmentNumber
+                styleOption: {
+                  segmentNumber: segmentNumber
+                }
               });
             case 4:
               model = _context2.sent;

package/es/line/models/earthArc_3d.js

@@ -196,7 +196,9 @@ var Arc3DModel = /*#__PURE__*/function (_BaseModel) {
                 depth: {
                   enable: true
                 },
-                segmentNumber: segmentNumber
+                styleOption: {
+                  segmentNumber: segmentNumber
+                }
               });
             case 4:
               model = _context2.sent;

package/es/line/models/flow.js

@@ -11,11 +11,11 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 import { AttributeType, gl } from '@antv/l7-core';
 import { rgb2arr } from '@antv/l7-utils';
 import BaseModel from "../../core/BaseModel";
-import { FlowLineFillTriangulation } from "../../core/triangulation";
+import { FlowLineTriangulation } from "../../core/line_trangluation";
 /* babel-plugin-inline-import '../shaders/flow/flow_line_frag.glsl' */
 var flow_line_frag = "#extension GL_OES_standard_derivatives : enable\n\nvarying vec4 v_color;\n\n\n// line texture\n\n#pragma include \"picking\"\n\nvoid main() {\ngl_FragColor = v_color;\ngl_FragColor = filterColor(gl_FragColor);\n}\n"; // linear simple line shader
 /* babel-plugin-inline-import '../shaders/flow/flow_line_vert.glsl' */
-var flow_line_vert = "attribute vec4 a_Color;\nattribute vec2 a_Size;\nattribute vec4 a_Instance;\nattribute vec3 a_Normal;\nattribute vec3 a_Position;\n\nuniform mat4 u_ModelMatrix;\n\n\n#pragma include \"projection\"\n#pragma include \"picking\"\nvarying vec4 v_color;\nuniform float u_gap_width: 1.0;\nuniform float u_stroke_width: 1.0;\nuniform float u_stroke_opacity: 1.0;\n\n\nvoid main() {\n\n// \u900F\u660E\u5EA6\u8BA1\u7B97\n  vec2 source = a_Instance.rg;  // \u8D77\u59CB\u70B9\n  vec2 target =  a_Instance.ba; // \u7EC8\u70B9\n  vec2 flowlineDir = normalize(target - source);\n  vec2 perpendicularDir = vec2(-flowlineDir.y, flowlineDir.x);\n\n\n  vec2 position = mix(source, target, a_Position.x);\n  \n  float lengthCommon = length(project_position(vec4(target,0,1)) - project_position(vec4(source,0,1)));  //    \n  vec2 offsetDistances = a_Size.x * project_pixel(a_Position.yz);\n  vec2 limitedOffsetDistances = clamp(   \n   offsetDistances,\n   project_pixel(-lengthCommon*.8), project_pixel(lengthCommon*.8)\n  );\n\n\n  float startOffsetCommon = project_pixel(offsets[0]);\n  float endOffsetCommon = project_pixel(offsets[1]);\n  float endpointOffset = mix(\n    clamp(startOffsetCommon, 0.0, lengthCommon*.2),\n    -clamp(endOffsetCommon, 0.0, lengthCommon*.2),\n    a_Position.x\n  );\n\n  vec2 normalsCommon =  u_stroke_width * project_pixel(a_Normal.xy);\n\n  float gapCommon =  project_pixel(u_gap_width);\n  vec3 offsetCommon = vec3(\n    flowlineDir * (limitedOffsetDistances[1] + normalsCommon.y + endpointOffset * 1.05) -\n    perpendicularDir * (limitedOffsetDistances[0] + gapCommon + normalsCommon.x),\n    0.0\n  );\n\n\n  vec4 project_pos = project_position(vec4(position.xy, 0, 1.0));\n\n  vec4 fillColor = vec4(a_Color.rgb, a_Color.a * opacity);\n  v_color = mix(fillColor, vec4(u_stroke.xyz, u_stroke.w * fillColor.w * u_stroke_opacity), a_Normal.z);\n\n  gl_Position = project_common_position_to_clipspace_v2(vec4(project_pos.xy + offsetCommon.xy, 0., 1.0));\n\n\n\n  setPickingColor(a_PickingColor);\n}\n";
+var flow_line_vert = "attribute vec4 a_Color;\nattribute vec2 a_Size;\nattribute vec4 a_Instance;\nattribute vec3 a_Normal;\nattribute vec3 a_Position;\n\nuniform mat4 u_ModelMatrix;\n\n\n#pragma include \"projection\"\n#pragma include \"project\"\n#pragma include \"picking\"\nvarying vec4 v_color;\nuniform float u_gap_width: 1.0;\nuniform float u_stroke_width: 1.0;\nuniform float u_stroke_opacity: 1.0;\n\nvec2 project_pixel_offset(vec2 offsets) {\n\n   vec2 data = project_pixel(offsets);\n   if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    // P20_2 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF3\n    return data;\n  }\n\n  return vec2(data.x, -data.y);;\n}\n\nvec2 line_dir(vec2 target, vec2 source) {\n\n   if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    // P20_2 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF3\n     return normalize(target - source);\n  }\n  return normalize(ProjectFlat(target) - ProjectFlat(source));\n}\n\nfloat flag_gap() {\n   if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    // P20_2 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF3\n     return 1.;\n  }\n  return -1.;\n\n}\n\n\nvoid main() {\n\n// \u900F\u660E\u5EA6\u8BA1\u7B97\n  vec2 source = a_Instance.rg;  // \u8D77\u59CB\u70B9\n  vec2 target =  a_Instance.ba; // \u7EC8\u70B9\n  vec2 flowlineDir = line_dir(target,source);\n  vec2 perpendicularDir = vec2(flowlineDir.y, flowlineDir.x); // mapbox || \u9AD8\u5FB7\n\n\n  vec2 position = mix(source, target, a_Position.x);\n  \n  float lengthCommon = length(project_position(vec4(target,0,1)) - project_position(vec4(source,0,1)));  //    \n  vec2 offsetDistances = a_Size.x * project_pixel_offset(vec2(a_Position.y, a_Position.z)); // Mapbox || \u9AD8\u5FB7\n  vec2 limitedOffsetDistances = clamp(   \n   offsetDistances,\n   project_pixel(-lengthCommon*.2), project_pixel(lengthCommon*.2)\n  );\n\n\n  float startOffsetCommon = project_pixel(offsets[0]);\n  float endOffsetCommon = project_pixel(offsets[1]);\n  float endpointOffset = mix(\n    clamp(startOffsetCommon, 0.0, lengthCommon*.2),\n    -clamp(endOffsetCommon, 0.0, lengthCommon*.2),\n    a_Position.x\n  );\n\n  vec2 normalsCommon =  u_stroke_width * project_pixel_offset(vec2(a_Normal.x, a_Normal.y)); // mapbox || \u9AD8\u5FB7\n\n  float gapCommon = flag_gap() * project_pixel(u_gap_width);\n  vec3 offsetCommon = vec3(\n    flowlineDir * (limitedOffsetDistances[1] + normalsCommon.y + endpointOffset * 1.05) -\n    perpendicularDir * (limitedOffsetDistances[0] + gapCommon + normalsCommon.x),\n    0.0\n  );\n\n\n  vec4 project_pos = project_position(vec4(position.xy, 0, 1.0));\n\n  vec4 fillColor = vec4(a_Color.rgb, a_Color.a * opacity);\n  v_color = mix(fillColor, vec4(u_stroke.xyz, u_stroke.w * fillColor.w * u_stroke_opacity), a_Normal.z);\n\n  gl_Position = project_common_position_to_clipspace_v2(vec4(project_pos.xy + offsetCommon.xy, 0., 1.0));\n\n\n\n  setPickingColor(a_PickingColor);\n}\n";
 var FlowLineModel = /*#__PURE__*/function (_BaseModel) {
   _inherits(FlowLineModel, _BaseModel);
   var _super = _createSuper(FlowLineModel);
@@ -36,8 +36,6 @@ var FlowLineModel = /*#__PURE__*/function (_BaseModel) {
         _ref$strokeOpacity = _ref.strokeOpacity,
         strokeOpacity = _ref$strokeOpacity === void 0 ? 1 : _ref$strokeOpacity;
       return _objectSpread({
-        // u_opacity: opacity,
-        // u_offsets: offsets,
         u_gap_width: gapWidth,
         u_stroke_width: strokeWidth,
         u_stroke: rgb2arr(stroke),
@@ -77,7 +75,8 @@ var FlowLineModel = /*#__PURE__*/function (_BaseModel) {
                 vertexShader: flow_line_vert,
                 fragmentShader: flow_line_frag,
                 inject: this.getInject(),
-                triangulation: FlowLineFillTriangulation,
+                triangulation: FlowLineTriangulation,
+                styleOption: this.layer.getLayerConfig().symbol,
                 primitive: gl.TRIANGLES,
                 depth: {
                   enable: false

package/es/line/models/line.js

@@ -96,14 +96,7 @@ var LineModel = /*#__PURE__*/function (_BaseModel) {
         _ref$linearDir = _ref.linearDir,
         linearDir = _ref$linearDir === void 0 ? LinearDir.VERTICAL : _ref$linearDir,
         _ref$blur = _ref.blur,
-        blur = _ref$blur === void 0 ? [1, 1, 1] : _ref$blur,
-        _ref$arrow = _ref.arrow,
-        arrow = _ref$arrow === void 0 ? {
-          enable: false,
-          arrowWidth: 2,
-          arrowHeight: 3,
-          tailWidth: 1
-        } : _ref$arrow;
+        blur = _ref$blur === void 0 ? [1, 1, 1] : _ref$blur;
       if (dashArray.length === 2) {
         dashArray.push(0, 0);
       }
@@ -144,12 +137,7 @@ var LineModel = /*#__PURE__*/function (_BaseModel) {
         u_heightfixed: Number(heightfixed),
         // 顶点高度 scale
         u_vertexScale: vertexHeightScale,
-        u_raisingHeight: Number(raisingHeight),
-        // arrow
-        u_arrow: Number(arrow.enable),
-        u_arrowHeight: arrow.arrowHeight || 3,
-        u_arrowWidth: arrow.arrowWidth || 2,
-        u_tailWidth: arrow.tailWidth === undefined ? 1 : arrow.tailWidth
+        u_raisingHeight: Number(raisingHeight)
       }, this.getStyleAttribute());
     }
   }, {