@antv/l7-layers 2.16.0 → 2.16.2

package/es/core/BaseModel.js

@@ -1,6 +1,5 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _initializerDefineProperty from "@babel/runtime/helpers/esm/initializerDefineProperty";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
@@ -9,30 +8,21 @@ import _applyDecoratedDescriptor from "@babel/runtime/helpers/esm/applyDecorated
 import _initializerWarningHelper from "@babel/runtime/helpers/esm/initializerWarningHelper";
 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; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-import { BlendType, gl, lazyInject, MaskOperation, StencilType, TYPES } from '@antv/l7-core';
+import { BlendType, lazyInject, MaskOperation, StencilType, TYPES } from '@antv/l7-core';
 import { rgb2arr } from '@antv/l7-utils';
-import { color } from 'd3-color';
-import { isEqual, isNumber, isString } from 'lodash';
 import { BlendTypes } from "../utils/blend";
 import { getStencil as _getStencil, getStencilMask } from "../utils/stencil";
+import { getCommonStyleAttributeOptions } from "./CommonStyleAttribute";
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 var BaseModel = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__PURE__*/function () {
   // style texture data mapping
 
-  // 用于数据传递的数据纹理
-  // 默认有多少列（宽度）
-  // 计算得到的当前数据纹理有多少行（高度）
-
-  // 单个 cell 的长度
-  // 需要进行数据映射的属性集合
-
   // style texture data mapping
 
   function BaseModel(layer) {
     _classCallCheck(this, BaseModel);
+    _defineProperty(this, "preStyleAttribute", {});
+    _defineProperty(this, "encodeStyleAttribute", {});
     _initializerDefineProperty(this, "configService", _descriptor, this);
     this.layer = layer;
     this.rendererService = layer.getContainer().get(TYPES.IRendererService);
@@ -44,360 +34,19 @@ var BaseModel = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
     this.fontService = layer.getContainer().get(TYPES.IFontService);
     this.cameraService = layer.getContainer().get(TYPES.ICameraService);
     this.layerService = layer.getContainer().get(TYPES.ILayerService);
+    // 初始化支持数据映射的 Style 属性
 
+    this.registerStyleAttribute();
     // 注册 Attribute
     this.registerBuiltinAttributes();
     // 开启动画
     this.startModelAnimate();
     var createTexture2D = this.rendererService.createTexture2D;
     this.createTexture2D = createTexture2D;
-    this.DATA_TEXTURE_WIDTH = 1024; // 数据纹理固定宽度
-    this.rowCount = 1;
-    this.cellLength = 0;
-    this.cellProperties = [];
-    this.cacheStyleProperties = {
-      thetaOffset: undefined,
-      opacity: undefined,
-      strokeOpacity: undefined,
-      strokeWidth: undefined,
-      stroke: undefined,
-      offsets: undefined
-    };
-    this.stylePropertiesExist = {
-      hasThetaOffset: 0,
-      hasOpacity: 0,
-      hasStrokeOpacity: 0,
-      hasStrokeWidth: 0,
-      hasStroke: 0,
-      hasOffsets: 0
-    };
-    this.dataTextureTest = this.layerService.getOESTextureFloat();
-    // 只有在不支持数据纹理的情况下进行赋值
-    if (!this.dataTextureTest) {
-      this.dataTexture = this.createTexture2D({
-        // data: new Uint8ClampedArray(4),
-        // 使用 Uint8ClampedArray 在 支付宝 环境中可能存在问题 UC 内核对格式有要求 L7 v2.7.18 版本发现
-        // Uint8ClampedArray 和 Uint8Array 没有实质性的区别
-        data: new Uint8Array(4),
-        mag: gl.NEAREST,
-        min: gl.NEAREST,
-        width: 1,
-        height: 1
-      });
-    }
   }
 
   // style datatexture mapping
-
-  /**
-   * 清除上一次的计算结果 - 全量清除
-   */
   _createClass(BaseModel, [{
-    key: "clearLastCalRes",
-    value: function clearLastCalRes() {
-      this.cellProperties = []; // 清空上一次计算的需要进行数据映射的属性集合
-      this.cellLength = 0; // 清空上一次计算的 cell 的长度
-      this.stylePropertiesExist = {
-        // 全量清空上一次是否需要对 style 属性进行数据映射的判断
-        hasThetaOffset: 0,
-        hasOpacity: 0,
-        hasStrokeOpacity: 0,
-        hasStrokeWidth: 0,
-        hasStroke: 0,
-        hasOffsets: 0
-      };
-    }
-  }, {
-    key: "getCellTypeLayout",
-    value: function getCellTypeLayout() {
-      if (this.dataTextureTest) {
-        return [
-        // 0
-        this.rowCount,
-        // 数据纹理有几行
-        this.DATA_TEXTURE_WIDTH,
-        // 数据纹理有几列
-        0.0, 0.0,
-        // 1
-        this.stylePropertiesExist.hasOpacity,
-        // cell 中是否存在 opacity
-        this.stylePropertiesExist.hasStrokeOpacity,
-        // cell 中是否存在 strokeOpacity
-        this.stylePropertiesExist.hasStrokeWidth,
-        // cell 中是否存在 strokeWidth
-        this.stylePropertiesExist.hasStroke,
-        // cell 中是否存在 stroke
-        // 2
-        this.stylePropertiesExist.hasOffsets,
-        // cell 中是否存在 offsets
-        this.stylePropertiesExist.hasThetaOffset,
-        // cell 中是否存在 thetaOffset
-        0.0, 0.0,
-        // 3
-        0.0, 0.0, 0.0, 1.0];
-      } else {
-        return [1.0,
-        // 数据纹理有几行
-        1.0,
-        // 数据纹理有几列
-        0.0, 0.0, 0.0,
-        // cell 中是否存在 opacity
-        0.0,
-        // cell 中是否存在 strokeOpacity
-        0.0,
-        // cell 中是否存在 strokeWidth
-        0.0,
-        // cell 中是否存在 stroke
-        0.0,
-        // cell 中是否存在 offsets
-        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0];
-      }
-    }
-
-    /**
-     * 判断数据纹理是否需要重新计算 - 根据传入的值进行判断
-     * @param options
-     * @returns
-     */
-  }, {
-    key: "dataTextureNeedUpdate",
-    value: function dataTextureNeedUpdate(options) {
-      var isUpdate = false;
-      if (!isEqual(options.thetaOffset, this.cacheStyleProperties.thetaOffset)) {
-        isUpdate = true;
-        this.cacheStyleProperties.thetaOffset = options.thetaOffset;
-      }
-      if (!isEqual(options.opacity, this.cacheStyleProperties.opacity)) {
-        isUpdate = true;
-        this.cacheStyleProperties.opacity = options.opacity;
-      }
-      if (!isEqual(options.strokeOpacity, this.cacheStyleProperties.strokeOpacity)) {
-        isUpdate = true;
-        this.cacheStyleProperties.strokeOpacity = options.strokeOpacity;
-      }
-      if (!isEqual(options.strokeWidth, this.cacheStyleProperties.strokeWidth)) {
-        isUpdate = true;
-        this.cacheStyleProperties.strokeWidth = options.strokeWidth;
-      }
-      if (!isEqual(options.stroke, this.cacheStyleProperties.stroke)) {
-        isUpdate = true;
-        this.cacheStyleProperties.stroke = options.stroke;
-      }
-      if (!isEqual(options.offsets, this.cacheStyleProperties.offsets)) {
-        isUpdate = true;
-        this.cacheStyleProperties.offsets = options.offsets;
-      }
-      if (this.dataTexture === undefined) {
-        isUpdate = true;
-      }
-      return isUpdate;
-    }
-    /**
-     * 判断当前的样式中哪些是需要进行数据映射的，哪些是常量，同时计算用于构建数据纹理的一些中间变量
-     * @param options
-     */
-  }, {
-    key: "judgeStyleAttributes",
-    value: function judgeStyleAttributes(options) {
-      this.clearLastCalRes(); // 清除上一次的计算结果 - 全量清除
-
-      if (options.opacity !== undefined && !isNumber(options.opacity)) {
-        // 数据映射
-        this.cellProperties.push({
-          attr: 'opacity',
-          count: 1
-        });
-        this.stylePropertiesExist.hasOpacity = 1;
-        this.cellLength += 1;
-      }
-      if (options.strokeOpacity !== undefined && !isNumber(options.strokeOpacity)) {
-        // 数据映射
-        this.cellProperties.push({
-          attr: 'strokeOpacity',
-          count: 1
-        });
-        this.stylePropertiesExist.hasStrokeOpacity = 1;
-        this.cellLength += 1;
-      }
-      if (options.strokeWidth !== undefined && !isNumber(options.strokeWidth)) {
-        // 数据映射
-        this.cellProperties.push({
-          attr: 'strokeWidth',
-          count: 1
-        });
-        this.stylePropertiesExist.hasStrokeWidth = 1;
-        this.cellLength += 1;
-      }
-      if (options.stroke !== undefined && !this.isStaticColor(options.stroke)) {
-        // 数据映射
-        this.cellProperties.push({
-          attr: 'stroke',
-          count: 4
-        });
-        this.stylePropertiesExist.hasStroke = 1;
-        this.cellLength += 4;
-      }
-      if (options.offsets !== undefined && !this.isOffsetStatic(options.offsets)) {
-        // 数据映射
-        this.cellProperties.push({
-          attr: 'offsets',
-          count: 2
-        });
-        this.stylePropertiesExist.hasOffsets = 1;
-        this.cellLength += 2;
-      }
-      if (options.thetaOffset !== undefined && !isNumber(options.thetaOffset)) {
-        // 数据映射
-        this.cellProperties.push({
-          attr: 'thetaOffset',
-          count: 1
-        });
-        this.stylePropertiesExist.hasThetaOffset = 1;
-        this.cellLength += 1;
-      }
-    }
-
-    /**
-     * 判断变量 stroke 是否是常量值
-     * @param stroke
-     * @returns
-     */
-  }, {
-    key: "isStaticColor",
-    value: function isStaticColor(stroke) {
-      if (isString(stroke)) {
-        if (color(stroke)) {
-          return true;
-        } else {
-          return false;
-        }
-      }
-      return false;
-    }
-    /**
-     * 获取 stroke 颜色并做兼容处理
-     * @param stroke
-     * @returns
-     */
-  }, {
-    key: "getStrokeColor",
-    value: function getStrokeColor(stroke) {
-      if (this.isStaticColor(stroke)) {
-        var strokeColor = rgb2arr(stroke);
-        strokeColor[0] = strokeColor[0] ? strokeColor[0] : 0;
-        strokeColor[1] = strokeColor[1] ? strokeColor[1] : 0;
-        strokeColor[2] = strokeColor[2] ? strokeColor[2] : 0;
-        strokeColor[3] = strokeColor[3] ? strokeColor[3] : 0;
-        return strokeColor;
-      } else {
-        return [0, 0, 0, 0];
-      }
-    }
-
-    /**
-     * 判断 offsets 是否是常量
-     * @param offsets
-     * @returns
-     */
-  }, {
-    key: "isOffsetStatic",
-    value: function isOffsetStatic(offsets) {
-      if (Array.isArray(offsets) && offsets.length === 2 && isNumber(offsets[0]) && isNumber(offsets[1])) {
-        return true;
-      } else {
-        return false;
-      }
-    }
-
-    /**
-     * 补空位
-     * @param d
-     * @param count
-     */
-  }, {
-    key: "patchMod",
-    value: function patchMod(d, count) {
-      for (var i = 0; i < count; i++) {
-        d.push(-1);
-      }
-    }
-
-    /**
-     * 根据映射的数据字段往推入数据
-     * @param d
-     * @param cellData
-     * @param cellPropertiesLayouts
-     */
-  }, {
-    key: "patchData",
-    value: function patchData(d, cellData, cellPropertiesLayouts) {
-      var _iterator = _createForOfIteratorHelper(cellPropertiesLayouts),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var layout = _step.value;
-          var attr = layout.attr,
-            count = layout.count;
-          var value = cellData[attr];
-          if (value !== undefined) {
-            // 数据中存在该属性
-            if (attr === 'stroke') {
-              d.push.apply(d, _toConsumableArray(rgb2arr(value)));
-            } else if (attr === 'offsets') {
-              if (this.isOffsetStatic(value)) {
-                d.push(-value[0], value[1]);
-              } else {
-                d.push(0, 0);
-              }
-            } else {
-              d.push(isNumber(value) ? value : 1.0);
-            }
-          } else {
-            // 若不存在时则补位
-            this.patchMod(d, count);
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-    }
-
-    /**
-     * 计算推入数据纹理的数据
-     * @param cellLength
-     * @param encodeData
-     * @param cellPropertiesLayouts
-     * @returns
-     */
-  }, {
-    key: "calDataFrame",
-    value: function calDataFrame(cellLength, encodeData, cellPropertiesLayouts) {
-      var encodeDatalength = encodeData.length;
-      var rowCount = Math.ceil(encodeDatalength * cellLength / this.DATA_TEXTURE_WIDTH); // 有多少行
-
-      var totalLength = rowCount * this.DATA_TEXTURE_WIDTH;
-      var d = [];
-      for (var i = 0; i < encodeDatalength; i++) {
-        // 根据 encodeData 数据推入数据
-        var cellData = encodeData[i];
-        this.patchData(d, cellData, cellPropertiesLayouts);
-      }
-      for (var _i = d.length; _i < totalLength; _i++) {
-        // 每行不足的部分用 -1 补足（数据纹理时 width * height 的矩形数据集合）
-        d.push(-1);
-      }
-      // console.log('data', d)
-      return {
-        data: d,
-        width: this.DATA_TEXTURE_WIDTH,
-        height: rowCount
-      };
-    }
-
-    // style datatexture mapping
-  }, {
     key: "getBlend",
     value: function getBlend() {
       var _this$layer$getLayerC = this.layer.getLayerConfig(),
@@ -546,6 +195,75 @@ var BaseModel = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
         this.layer.setAnimateStartTime();
       }
     }
+  }, {
+    key: "getInject",
+    value: function getInject() {
+      var encodeStyleAttribute = this.layer.encodeStyleAttribute;
+      var str = '';
+      var attrType = {
+        opacity: 'float',
+        stroke: 'vec4',
+        offsets: 'vec2',
+        textOffset: 'vec2'
+      };
+      this.layer.enableEncodeStyles.forEach(function (key) {
+        if (encodeStyleAttribute[key]) {
+          str += "#define USE_ATTRIBUTE_".concat(key.toUpperCase(), " 0.0; \n\n");
+        }
+        str += "\n      #ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n  attribute ").concat(attrType[key], " a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n#else\n  uniform ").concat(attrType[key], " u_").concat(key, ";\n#endif\n\n");
+      });
+      var innerStr = '';
+      this.layer.enableEncodeStyles.forEach(function (key) {
+        innerStr += "\n\n#ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n  ").concat(attrType[key], " ").concat(key, "  = a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n#else\n  ").concat(attrType[key], " ").concat(key, " = u_").concat(key, ";\n#endif\n\n");
+      });
+      return {
+        'vs:#decl': str,
+        'vs:#main-start': innerStr
+      };
+    }
+
+    // 获取数据映射样式
+  }, {
+    key: "getStyleAttribute",
+    value: function getStyleAttribute() {
+      var _this = this;
+      var options = {};
+      // TODO: 优化
+
+      var defualtValue = {
+        opacity: 1,
+        stroke: [1, 0, 0, 1],
+        offsets: [0, 0]
+      };
+      this.layer.enableEncodeStyles.forEach(function (key) {
+        if (!_this.layer.encodeStyleAttribute[key]) {
+          // @ts-ignore
+          var value = _this.layer.getLayerConfig()[key] || defualtValue[key];
+          if (key === 'stroke') {
+            value = rgb2arr(value);
+          }
+          options['u_' + key] = value;
+        }
+      });
+      return options;
+    }
+    // 注册数据映射样式
+  }, {
+    key: "registerStyleAttribute",
+    value: function registerStyleAttribute() {
+      var _this2 = this;
+      Object.keys(this.layer.encodeStyleAttribute).forEach(function (key) {
+        var options = getCommonStyleAttributeOptions(key);
+        if (options) {
+          _this2.styleAttributeService.registerStyleAttribute(options);
+        }
+      });
+    }
+  }, {
+    key: "updateEncodeAttribute",
+    value: function updateEncodeAttribute(type, flag) {
+      this.encodeStyleAttribute[type] = flag;
+    }
   }]);
   return BaseModel;
 }(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, "configService", [_dec], {

package/es/core/CommonStyleAttribute.d.ts

@@ -0,0 +1,2 @@
+import { IStyleAttribute } from '@antv/l7-core';
+export declare function getCommonStyleAttributeOptions(name: string): Partial<IStyleAttribute> | undefined;

package/es/core/CommonStyleAttribute.js

@@ -0,0 +1,66 @@
+import { AttributeType, gl } from '@antv/l7-core';
+export function getCommonStyleAttributeOptions(name) {
+  switch (name) {
+    case 'stroke':
+      return {
+        name: 'stroke',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_Stroke',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.DYNAMIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 4,
+          update: function update(feature) {
+            var _feature$stroke = feature.stroke,
+              stroke = _feature$stroke === void 0 ? [1, 1, 1, 1] : _feature$stroke;
+            return stroke;
+          }
+        }
+      };
+    case 'opacity':
+      return {
+        name: 'opacity',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_Opacity',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.STATIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 1,
+          update: function update(feature) {
+            var _feature$opacity = feature.opacity,
+              op = _feature$opacity === void 0 ? 1 : _feature$opacity;
+            return [op];
+          }
+        }
+      };
+    case 'offsets':
+      return {
+        name: 'offsets',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_Offsets',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.STATIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 2,
+          update: function update(feature) {
+            var epo = feature.offsets;
+            return epo;
+          }
+        }
+      };
+    default:
+      return undefined;
+  }
+}

package/es/core/interface.d.ts

@@ -1,6 +1,5 @@
-import { IAnimateOption, IMapService, ITexture2D } from '@antv/l7-core';
+import { IAnimateOption, IMapService, ITexture2D, StyleAttributeField, StyleAttributeOption } from '@antv/l7-core';
 import { IColorRamp } from '@antv/l7-utils';
-import { styleOffset } from '../core/BaseModel';
 import { anchorType } from '../utils/symbol-layout';
 export declare enum lineStyleType {
     'solid' = 0,
@@ -91,7 +90,7 @@ export interface IPointLayerStyleOptions extends IBaseLayerStyleOptions {
         dir: string;
     };
     lightEnable: boolean;
-    offsets?: styleOffset;
+    offsets?: [number, number];
     unit?: SizeUnitType;
     rotation?: number;
     speed?: number;
@@ -227,4 +226,15 @@ export interface IRasterTerrainLayerStyleOptions extends IBaseRasterLayerStyleOp
     bScaler?: number;
     offset?: number;
 }
+export interface IFlowLineStyleOptions extends IBaseLayerStyleOptions {
+    gapWidth?: number;
+    offsets?: [number, number];
+    stroke?: string;
+    strokeOpacity?: number;
+    strokeWidth?: number;
+}
+export interface IStyleEncodeAttributeOptions {
+    field: StyleAttributeField;
+    values?: StyleAttributeOption;
+}
 export {};

package/es/core/shape/extrude.js

@@ -73,15 +73,22 @@ export function extrude_PolygonNormal(path) {
   var normals = [];
   // 设置顶部z值 position uv
   for (var j = 0; j < vertices.length / dimensions; j++) {
-    if (dimensions === 2) {
-      positions.push(vertices[j * 2], vertices[j * 2 + 1], 1, -1, -1);
-    } else {
-      positions.push(vertices[j * 3], vertices[j * 3 + 1], 1, -1, -1);
-    }
+    positions.push(vertices[j * dimensions],
+    // x
+    vertices[j * dimensions + 1],
+    // y
+    1,
+    // z
+    -1,
+    // 顶部uv
+    -1 // 顶部uv
+    );
+
     normals.push(0, 0, 1);
   }
   var triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
   indexArray.push.apply(indexArray, _toConsumableArray(triangles));
+  // 设置侧面
   var _loop2 = function _loop2() {
     var prePoint = flattengeo.vertices.slice(i * dimensions, (i + 1) * dimensions);
     var nextPoint = flattengeo.vertices.slice((i + 1) * dimensions, (i + 2) * dimensions);
@@ -89,7 +96,12 @@ export function extrude_PolygonNormal(path) {
       nextPoint = flattengeo.vertices.slice(0, dimensions);
     }
     var indexOffset = positions.length / 5;
-    positions.push(prePoint[0], prePoint[1], 1, 0, 0, nextPoint[0], nextPoint[1], 1, 0.1, 0, prePoint[0], prePoint[1], 0, 0, 0.8, nextPoint[0], nextPoint[1], 0, 0.1, 0.8);
+    // 侧面四顶点
+    positions.push(prePoint[0], prePoint[1], 1, 0, 0, nextPoint[0], nextPoint[1], 1, 0.1,
+    // 侧面 低uv
+    0,
+    // 侧面低 uv
+    prePoint[0], prePoint[1], 0, 0, 0.8, nextPoint[0], nextPoint[1], 0, 0.1, 0.8);
     var normal = computeVertexNormals([nextPoint[0], nextPoint[1], 1], [prePoint[0], prePoint[1], 0], [prePoint[0], prePoint[1], 1], needFlat);
     normals.push.apply(normals, _toConsumableArray(normal).concat(_toConsumableArray(normal), _toConsumableArray(normal), _toConsumableArray(normal)));
     indexArray.push.apply(indexArray, _toConsumableArray([1, 2, 0, 3, 2, 1].map(function (v) {

package/es/core/triangulation.d.ts

@@ -47,6 +47,18 @@ export declare function LineTriangulation(feature: IEncodeFeature): {
     indexes: number[];
     size: number;
 };
+export declare function FlowLineFillTriangulation(feature: IEncodeFeature): {
+    vertices: any[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function FlowLineStrokeTriangulation(feature: IEncodeFeature): {
+    vertices: any[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
 export declare function SimpleLineTriangulation(feature: IEncodeFeature): {
     vertices: any[];
     indices: never[];