@antv/l7-layers 2.25.7 → 2.25.10

package/lib/plugins/ShaderUniformPlugin.js

@@ -0,0 +1,203 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _l7Core = require("@antv/l7-core");
+/**
+ * 在渲染之前需要获取当前 Shader 所需 Uniform，例如：
+ * 1. 从相机服务中获取 View & ProjectionMatrix，当前缩放等级等等
+ * 2. 从坐标系服务中获取当前坐标系，例如是否是偏移坐标系
+ *    @see https://yuque.antfin-inc.com/yuqi.pyq/fgetpa/doml91
+ * 3. 当前 Layer 本身的样式属性
+ */
+class ShaderUniformPlugin {
+  constructor() {
+    (0, _defineProperty2.default)(this, "cameraService", void 0);
+    (0, _defineProperty2.default)(this, "coordinateSystemService", void 0);
+    (0, _defineProperty2.default)(this, "rendererService", void 0);
+    (0, _defineProperty2.default)(this, "mapService", void 0);
+    (0, _defineProperty2.default)(this, "layerService", void 0);
+  }
+  apply(layer, {
+    rendererService,
+    mapService,
+    layerService,
+    coordinateSystemService,
+    cameraService
+  }) {
+    this.rendererService = rendererService;
+    this.mapService = mapService;
+    this.layerService = layerService;
+    this.coordinateSystemService = coordinateSystemService;
+    this.cameraService = cameraService;
+    let uniformBuffer;
+    if (!this.rendererService.uniformBuffers[0]) {
+      // Create a Uniform Buffer Object(UBO).
+      // Total size: 93 floats, round up to 96 for safety
+      uniformBuffer = this.rendererService.createBuffer({
+        data: new Float32Array(96),
+        isUBO: true,
+        label: 'renderUniformBuffer'
+      });
+      this.rendererService.uniformBuffers[0] = uniformBuffer;
+    }
+    layer.hooks.beforeRender.tap('ShaderUniformPlugin', () => {
+      // 获取图层的相对坐标原点
+      const layerRelativeOrigin = layer.getRelativeOrigin && layer.getRelativeOrigin();
+      const relativeOrigin = layerRelativeOrigin || [0, 0];
+
+      // 重新计算坐标系参数
+      this.coordinateSystemService.refresh();
+
+      // 特殊处理：如果图层启用了相对坐标，强制设置ViewportCenter为RelativeOrigin
+      // 这样可以避免shader中的精度问题
+      const isUsingRelativeCoords = relativeOrigin && (Math.abs(relativeOrigin[0]) > 0.0001 || Math.abs(relativeOrigin[1]) > 0.0001);
+      if (isUsingRelativeCoords && this.coordinateSystemService.getCoordinateSystem() === 2) {
+        // COORDINATE_SYSTEM_LNGLAT_OFFSET
+        // 强制设置ViewportCenter为RelativeOrigin，避免shader中的大数计算
+        this.coordinateSystemService.setViewportCenter(relativeOrigin);
+      }
+      const {
+        width,
+        height
+      } = this.rendererService.getViewportSize();
+      const {
+        data,
+        uniforms
+      } = this.generateUBO(width, height, relativeOrigin);
+      if (this.layerService.alreadyInRendering && this.rendererService.uniformBuffers[0]) {
+        const renderUniformBuffer = this.rendererService.uniformBuffers[0];
+        // Update only once since all models can share one UBO.
+        renderUniformBuffer.subData({
+          offset: 0,
+          data
+        });
+      }
+
+      // For WebGL1. regl
+      const platformString = this.rendererService.queryVerdorInfo();
+      if (platformString === 'WebGL1') {
+        layer.models.forEach(model => {
+          model.addUniforms((0, _objectSpread2.default)((0, _objectSpread2.default)({}, uniforms), {}, {
+            // TODO: move these 2 uniforms to PixelPickingPlugin
+            u_PickingBuffer: layer.getLayerConfig().pickingBuffer || 0,
+            // Tip: 当前地图是否在拖动
+            u_shaderPick: Number(layer.getShaderPickStat())
+          }));
+        });
+      }
+    });
+  }
+  generateUBO(width, height, offset) {
+    const u_ProjectionMatrix = this.cameraService.getProjectionMatrix();
+    const u_ViewMatrix = this.cameraService.getViewMatrix();
+    const u_ViewProjectionMatrix = this.cameraService.getViewProjectionMatrix();
+    const u_ModelMatrix = this.cameraService.getModelMatrix();
+    const u_ViewportCenterProjection = this.coordinateSystemService.getViewportCenterProjection();
+    const u_PixelsPerDegree = this.coordinateSystemService.getPixelsPerDegree();
+    const u_Zoom = this.cameraService.getZoom();
+    const u_PixelsPerDegree2 = this.coordinateSystemService.getPixelsPerDegree2();
+    const u_ZoomScale = this.cameraService.getZoomScale();
+    const u_PixelsPerMeter = this.coordinateSystemService.getPixelsPerMeter();
+    const u_CoordinateSystem = this.coordinateSystemService.getCoordinateSystem();
+    const u_CameraPosition = this.cameraService.getCameraPosition();
+    const u_DevicePixelRatio = window.devicePixelRatio;
+    const u_ViewportCenter = this.coordinateSystemService.getViewportCenter();
+    const u_ViewportSize = [width, height];
+    const u_FocalDistance = this.cameraService.getFocalDistance();
+    const u_RelativeOrigin = offset && offset.length >= 2 ? [offset[0], offset[1]] : [0, 0];
+
+    // Build UBO data array matching GLSL std140 layout
+    // std140 rules:
+    // - mat4: 16-byte aligned, size 64 bytes (16 floats)
+    // - vec4: 16-byte aligned, size 16 bytes (4 floats)
+    // - vec3: 16-byte aligned, size 12 bytes (3 floats) - next member can follow if aligned
+    // - vec2: 8-byte aligned, size 8 bytes (2 floats)
+    // - float: 4-byte aligned, size 4 bytes (1 float)
+    // Key: vec3 only occupies 3 floats, NOT 4. The alignment requirement is for START position.
+    const floats = [];
+
+    // mat4 x 4: each 16 floats, all start at multiples of 4 floats (16-byte aligned)
+    floats.push(...u_ViewMatrix); // floats 0-15
+    floats.push(...u_ProjectionMatrix); // floats 16-31
+    floats.push(...u_ViewProjectionMatrix); // floats 32-47
+    floats.push(...u_ModelMatrix); // floats 48-63
+
+    // vec4: 4 floats, starts at float 64 (64 % 4 = 0 ✓)
+    floats.push(...u_ViewportCenterProjection); // floats 64-67
+
+    // vec3: 3 floats only, starts at float 68 (68 % 4 = 0 ✓)
+    floats.push(...u_PixelsPerDegree); // floats 68-70 (NOT 68-71!)
+
+    // float: starts at float 71, any position is fine for 4-byte alignment
+    floats.push(u_Zoom); // float 71
+
+    // vec3: needs 4-float alignment, 72 % 4 = 0 ✓
+    floats.push(...u_PixelsPerDegree2); // floats 72-74
+
+    // float: starts at float 75
+    floats.push(u_ZoomScale); // float 75
+
+    // vec3: needs 4-float alignment, 76 % 4 = 0 ✓
+    floats.push(...u_PixelsPerMeter); // floats 76-78
+
+    // float: starts at float 79
+    floats.push(u_CoordinateSystem); // float 79
+
+    // vec3: needs 4-float alignment, 80 % 4 = 0 ✓
+    floats.push(...u_CameraPosition); // floats 80-82
+
+    // float: starts at float 83
+    floats.push(u_DevicePixelRatio); // float 83
+
+    // vec2: needs 2-float alignment, 84 % 2 = 0 ✓
+    floats.push(...u_ViewportCenter); // floats 84-85
+
+    // vec2: needs 2-float alignment, 86 % 2 = 0 ✓
+    floats.push(...u_ViewportSize); // floats 86-87
+
+    // float: starts at float 88
+    floats.push(u_FocalDistance); // float 88
+
+    // vec2: needs 2-float alignment, 89 % 2 = 1, NOT aligned!
+    floats.push(0); // padding float 89
+    floats.push(...u_RelativeOrigin); // floats 90-91
+
+    // float u_Reserved3
+    floats.push(0); // float 92
+
+    const data = floats;
+    return {
+      data,
+      uniforms: {
+        // 相机参数，包含 VP 矩阵、缩放等级
+        [_l7Core.CameraUniform.ProjectionMatrix]: u_ProjectionMatrix,
+        [_l7Core.CameraUniform.ViewMatrix]: u_ViewMatrix,
+        [_l7Core.CameraUniform.ViewProjectionMatrix]: u_ViewProjectionMatrix,
+        [_l7Core.CameraUniform.Zoom]: u_Zoom,
+        [_l7Core.CameraUniform.ZoomScale]: u_ZoomScale,
+        [_l7Core.CameraUniform.FocalDistance]: u_FocalDistance,
+        [_l7Core.CameraUniform.CameraPosition]: u_CameraPosition,
+        // 坐标系参数
+        [_l7Core.CoordinateUniform.CoordinateSystem]: u_CoordinateSystem,
+        [_l7Core.CoordinateUniform.ViewportCenter]: u_ViewportCenter,
+        [_l7Core.CoordinateUniform.ViewportCenterProjection]: u_ViewportCenterProjection,
+        [_l7Core.CoordinateUniform.PixelsPerDegree]: u_PixelsPerDegree,
+        [_l7Core.CoordinateUniform.PixelsPerDegree2]: u_PixelsPerDegree2,
+        [_l7Core.CoordinateUniform.PixelsPerMeter]: u_PixelsPerMeter,
+        // 其他参数，例如视口大小、DPR 等
+        u_ViewportSize: u_ViewportSize,
+        u_ModelMatrix,
+        u_DevicePixelRatio: u_DevicePixelRatio,
+        // 相对原点坐标
+        u_RelativeOrigin: u_RelativeOrigin
+      }
+    };
+  }
+}
+exports.default = ShaderUniformPlugin;

package/lib/plugins/UpdateModelPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { ILayer, ILayerPlugin } from '@antv/l7-core';
+/**
+ * Model 更新
+ */
+export default class UpdateModelPlugin implements ILayerPlugin {
+    apply(layer: ILayer): void;
+}

package/lib/plugins/UpdateModelPlugin.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Model 更新
+ */
+class UpdateModelPlugin {
+  apply(layer) {
+    layer.hooks.beforeRender.tap('UpdateModelPlugin', () => {
+      // 处理文本更新
+      if (layer.layerModel) {
+        layer.layerModel.needUpdate().then(flag => {
+          if (flag) {
+            layer.renderLayers();
+          }
+        });
+      }
+    });
+    layer.hooks.afterRender.tap('UpdateModelPlugin', () => {
+      layer.layerModelNeedUpdate = false;
+    });
+  }
+}
+exports.default = UpdateModelPlugin;

package/lib/plugins/UpdateStyleAttributePlugin.d.ts

@@ -0,0 +1,9 @@
+import type { ILayer, ILayerPlugin, L7Container } from '@antv/l7-core';
+/**
+ * 在初始化阶段完成属性的注册，以及首次根据 Layer 指定的三角化方法完成 indices 和 attribute 的创建
+ */
+export default class UpdateStyleAttributePlugin implements ILayerPlugin {
+    apply(layer: ILayer, { styleAttributeService }: L7Container): void;
+    private updateStyleAttribute;
+    private initStyleAttribute;
+}

package/lib/plugins/UpdateStyleAttributePlugin.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * 在初始化阶段完成属性的注册，以及首次根据 Layer 指定的三角化方法完成 indices 和 attribute 的创建
+ */
+class UpdateStyleAttributePlugin {
+  apply(layer, {
+    styleAttributeService
+  }) {
+    layer.hooks.init.tapPromise('UpdateStyleAttributePlugin', () => {
+      this.initStyleAttribute(layer, {
+        styleAttributeService
+      });
+    });
+    layer.hooks.beforeRender.tap('UpdateStyleAttributePlugin', () => {
+      if (layer.layerModelNeedUpdate) {
+        return;
+      }
+      if (layer.inited) {
+        this.updateStyleAttribute(layer, {
+          styleAttributeService
+        });
+      }
+    });
+  }
+  updateStyleAttribute(layer, {
+    styleAttributeService
+  }) {
+    const attributes = styleAttributeService.getLayerStyleAttributes() || [];
+    const filter = styleAttributeService.getLayerStyleAttribute('filter');
+    if (filter && filter.needRegenerateVertices) {
+      layer.layerModelNeedUpdate = true;
+      attributes.forEach(attr => attr.needRegenerateVertices = false);
+      return;
+    }
+    attributes.filter(attribute => attribute.needRegenerateVertices).forEach(attribute => {
+      // 精确更新某个/某些 feature(s)，需要传入 featureIdx d
+      styleAttributeService.updateAttributeByFeatureRange(attribute.name, layer.getEncodedData(),
+      // 获取经过 mapping 最新的数据
+      attribute.featureRange.startIndex, attribute.featureRange.endIndex, layer);
+      attribute.needRegenerateVertices = false;
+    });
+  }
+  initStyleAttribute(layer, {
+    styleAttributeService
+  }) {
+    const attributes = styleAttributeService.getLayerStyleAttributes() || [];
+    attributes.filter(attribute => attribute.needRegenerateVertices).forEach(attribute => {
+      // 精确更新某个/某些 feature(s)，需要传入 featureIdx d
+      styleAttributeService.updateAttributeByFeatureRange(attribute.name, layer.getEncodedData(),
+      // 获取经过 mapping 最新的数据
+      attribute.featureRange.startIndex, attribute.featureRange.endIndex);
+      attribute.needRegenerateVertices = false;
+    });
+  }
+}
+exports.default = UpdateStyleAttributePlugin;

package/lib/plugins/index.d.ts

@@ -0,0 +1,15 @@
+import DataMappingPlugin from './DataMappingPlugin';
+import DataSourcePlugin from './DataSourcePlugin';
+import FeatureScalePlugin from './FeatureScalePlugin';
+import LayerAnimateStylePlugin from './LayerAnimateStylePlugin';
+import LayerMaskPlugin from './LayerMaskPlugin';
+import LayerModelPlugin from './LayerModelPlugin';
+import LayerStylePlugin from './LayerStylePlugin';
+import LightingPlugin from './LightingPlugin';
+import MultiPassRendererPlugin from './MultiPassRendererPlugin';
+import PixelPickingPlugin from './PixelPickingPlugin';
+import RegisterStyleAttributePlugin from './RegisterStyleAttributePlugin';
+import ShaderUniformPlugin from './ShaderUniformPlugin';
+import UpdateModelPlugin from './UpdateModelPlugin';
+import UpdateStyleAttributePlugin from './UpdateStyleAttributePlugin';
+export declare function createPlugins(): (DataSourcePlugin | RegisterStyleAttributePlugin | FeatureScalePlugin | DataMappingPlugin | LayerStylePlugin | LayerMaskPlugin | UpdateStyleAttributePlugin | UpdateModelPlugin | MultiPassRendererPlugin | ShaderUniformPlugin | LayerAnimateStylePlugin | LightingPlugin | PixelPickingPlugin | LayerModelPlugin)[];

package/lib/plugins/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPlugins = createPlugins;
+var _DataMappingPlugin = _interopRequireDefault(require("./DataMappingPlugin"));
+var _DataSourcePlugin = _interopRequireDefault(require("./DataSourcePlugin"));
+var _FeatureScalePlugin = _interopRequireDefault(require("./FeatureScalePlugin"));
+var _LayerAnimateStylePlugin = _interopRequireDefault(require("./LayerAnimateStylePlugin"));
+var _LayerMaskPlugin = _interopRequireDefault(require("./LayerMaskPlugin"));
+var _LayerModelPlugin = _interopRequireDefault(require("./LayerModelPlugin"));
+var _LayerStylePlugin = _interopRequireDefault(require("./LayerStylePlugin"));
+var _LightingPlugin = _interopRequireDefault(require("./LightingPlugin"));
+var _MultiPassRendererPlugin = _interopRequireDefault(require("./MultiPassRendererPlugin"));
+var _PixelPickingPlugin = _interopRequireDefault(require("./PixelPickingPlugin"));
+var _RegisterStyleAttributePlugin = _interopRequireDefault(require("./RegisterStyleAttributePlugin"));
+var _ShaderUniformPlugin = _interopRequireDefault(require("./ShaderUniformPlugin"));
+var _UpdateModelPlugin = _interopRequireDefault(require("./UpdateModelPlugin"));
+var _UpdateStyleAttributePlugin = _interopRequireDefault(require("./UpdateStyleAttributePlugin"));
+// import ConfigSchemaValidationPlugin from './ConfigSchemaValidationPlugin';
+
+function createPlugins() {
+  return [new _DataSourcePlugin.default(), new _RegisterStyleAttributePlugin.default(), new _FeatureScalePlugin.default(), new _DataMappingPlugin.default(), new _LayerStylePlugin.default(), new _LayerMaskPlugin.default(), new _UpdateStyleAttributePlugin.default(), new _UpdateModelPlugin.default(), new _MultiPassRendererPlugin.default(), new _ShaderUniformPlugin.default(), new _LayerAnimateStylePlugin.default(), new _LightingPlugin.default(), new _PixelPickingPlugin.default(), new _LayerModelPlugin.default()];
+}

package/lib/point/index.d.ts

@@ -0,0 +1,35 @@
+import type { ILayer, ILayerConfig } from '@antv/l7-core';
+import BaseLayer from '../core/BaseLayer';
+import type { IPointLayerStyleOptions } from '../core/interface';
+import type { PointType } from './models/index';
+export default class PointLayer extends BaseLayer<IPointLayerStyleOptions> {
+    type: string;
+    enableShaderEncodeStyles: string[];
+    enableDataEncodeStyles: string[];
+    defaultSourceConfig: {
+        data: never[];
+        options: {
+            parser: {
+                type: string;
+                x: string;
+                y: string;
+            };
+        };
+    };
+    buildModels(): Promise<void>;
+    rebuildModels(): Promise<void>;
+    style(options: Partial<IPointLayerStyleOptions> & Partial<ILayerConfig>): ILayer;
+    /**
+     * 在未传入数据的时候判断点图层的 shape 类型
+     * @returns
+     */
+    getModelTypeWillEmptyData(): PointType;
+    protected getDefaultConfig(): {} | {
+        blend: string;
+    } | {} | {} | {
+        blend: string;
+    } | {} | {} | {
+        blend: string;
+    } | {} | {};
+    getModelType(): PointType;
+}

package/lib/point/index.js

@@ -0,0 +1,161 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _BaseLayer = _interopRequireDefault(require("../core/BaseLayer"));
+var _index = _interopRequireDefault(require("./models/index"));
+class PointLayer extends _BaseLayer.default {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "type", 'PointLayer');
+    (0, _defineProperty2.default)(this, "enableShaderEncodeStyles", ['stroke', 'offsets', 'opacity', 'rotation']);
+    //4+2+1+1
+    (0, _defineProperty2.default)(this, "enableDataEncodeStyles", ['textOffset', 'textAnchor']);
+    (0, _defineProperty2.default)(this, "defaultSourceConfig", {
+      data: [],
+      options: {
+        parser: {
+          type: 'json',
+          x: 'lng',
+          y: 'lat'
+        }
+      }
+    });
+  }
+  buildModels() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      const modelType = _this.getModelType();
+      if (_this.layerModel) {
+        _this.layerModel.clearModels();
+      }
+      _this.layerModel = new _index.default[modelType](_this);
+      yield _this.initLayerModels();
+    })();
+  }
+  rebuildModels() {
+    var _this2 = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      yield _this2.buildModels();
+    })();
+  }
+  style(options) {
+    super.style(options);
+    // allowOverlap 依赖 needUpdate() 感知变化并重建 model，而 needUpdate() 仅在渲染帧的
+    // beforeRender 钩子中被调用。style() 本身不触发渲染，因此在 allowOverlap 出现时
+    // 主动触发一次 reRender，确保静止地图下也能即时生效。
+    if ('allowOverlap' in options) {
+      this.reRender();
+    }
+    return this;
+  }
+
+  /**
+   * 在未传入数据的时候判断点图层的 shape 类型
+   * @returns
+   */
+  getModelTypeWillEmptyData() {
+    if (this.shapeOption) {
+      const {
+        field,
+        values
+      } = this.shapeOption;
+      const {
+        shape2d
+      } = this.getLayerConfig();
+      const iconMap = this.iconService.getIconMap();
+      if (field && (shape2d === null || shape2d === void 0 ? void 0 : shape2d.indexOf(field)) !== -1) {
+        return 'fill';
+      }
+      if (values === 'text') {
+        return 'text';
+      }
+      if (values && values instanceof Array) {
+        for (const v of values) {
+          if (typeof v === 'string' && iconMap.hasOwnProperty(v)) {
+            return 'image';
+          }
+        }
+      }
+    }
+    return 'normal';
+  }
+  getDefaultConfig() {
+    const type = this.getModelType();
+    const defaultConfig = {
+      fillImage: {},
+      normal: {
+        blend: 'additive'
+      },
+      radar: {},
+      simplePoint: {},
+      fill: {
+        blend: 'normal'
+      },
+      extrude: {},
+      image: {},
+      text: {
+        blend: 'normal'
+      },
+      tile: {},
+      tileText: {},
+      earthFill: {},
+      earthExtrude: {}
+    };
+    return defaultConfig[type];
+  }
+  getModelType() {
+    //  2D、 3d、 shape、image、text、normal、
+    const layerData = this.getEncodedData();
+    const {
+      shape2d,
+      shape3d,
+      billboard = true
+    } = this.getLayerConfig();
+    const iconMap = this.iconService.getIconMap();
+    const item = layerData.find(fe => {
+      return fe.hasOwnProperty('shape');
+    });
+    if (!item) {
+      return this.getModelTypeWillEmptyData();
+    } else {
+      const shape = item.shape;
+      if (shape === 'dot') {
+        return 'normal';
+      }
+      if (shape === 'simple') {
+        return 'simplePoint';
+      }
+      if (shape === 'radar') {
+        return 'radar';
+      }
+      if (this.layerType === 'fillImage' || billboard === false) {
+        return 'fillImage';
+      }
+      if ((shape2d === null || shape2d === void 0 ? void 0 : shape2d.indexOf(shape)) !== -1) {
+        if (this.mapService.version === 'GLOBEL') {
+          return 'earthFill';
+        } else {
+          return 'fill';
+        }
+      }
+      if ((shape3d === null || shape3d === void 0 ? void 0 : shape3d.indexOf(shape)) !== -1) {
+        if (this.mapService.version === 'GLOBEL') {
+          return 'earthExtrude';
+        } else {
+          return 'extrude';
+        }
+      }
+      if (iconMap.hasOwnProperty(shape)) {
+        return 'image';
+      }
+      return 'text';
+    }
+  }
+}
+exports.default = PointLayer;

package/lib/point/models/billboard_point.d.ts

@@ -0,0 +1,35 @@
+import type { IEncodeFeature, IModel } from '@antv/l7-core';
+import BaseModel from '../../core/BaseModel';
+import type { IPointLayerStyleOptions } from '../../core/interface';
+export declare function PointTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+export default class SimplePointModel 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;
+    };
+    getDefaultStyle(): Partial<IPointLayerStyleOptions>;
+    protected getCommonUniformsInfo(): {
+        uniformsArray: number[];
+        uniformsLength: number;
+        uniformsOption: {
+            [key: string]: any;
+        };
+    };
+    initModels(): Promise<IModel[]>;
+    buildModels(): Promise<IModel[]>;
+    protected registerBuiltinAttributes(): void;
+}