@antv/l7-layers 2.9.32-alpha.3 → 2.9.32-alpha.5

package/es/tile/manager/tilePickerManager.js

@@ -0,0 +1,194 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import { EventEmitter } from 'eventemitter3';
+
+var TilePickManager = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(TilePickManager, _EventEmitter);
+
+  var _super = _createSuper(TilePickManager);
+
+  function TilePickManager(parent, rendererService, pickingService, children) {
+    var _this;
+
+    _classCallCheck(this, TilePickManager);
+
+    _this = _super.call(this);
+
+    _defineProperty(_assertThisInitialized(_this), "isLastPicked", false);
+
+    _this.parent = parent;
+    _this.rendererService = rendererService;
+    _this.pickingService = pickingService;
+    _this.children = children;
+    return _this;
+  }
+  /**
+   *
+   * @param layers
+   */
+
+
+  _createClass(TilePickManager, [{
+    key: "normalRender",
+    value: function normalRender(layers) {
+      var _this2 = this;
+
+      layers.filter(function (layer) {
+        return layer.inited;
+      }).filter(function (layer) {
+        return layer.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeRenderData.call();
+        layer.hooks.beforeRender.call();
+
+        if (layer.masks.length > 0) {
+          // 清除上一次的模版缓存
+          _this2.rendererService.clear({
+            stencil: 0,
+            depth: 1,
+            framebuffer: null
+          });
+
+          layer.masks.map(function (m) {
+            m.hooks.beforeRenderData.call();
+            m.hooks.beforeRender.call();
+            m.render();
+            m.hooks.afterRender.call();
+          });
+        }
+
+        layer.render();
+        layer.hooks.afterRender.call();
+      });
+    }
+  }, {
+    key: "pickRender",
+    value: function pickRender(layers, target) {
+      var _this3 = this;
+
+      // Tip: 在进行拾取渲染的时候也需要先渲染一遍父组件然后再渲染子组件
+      //  如需要在 栅格瓦片存在 Mask 的时候发生的拾取，那么就需要先渲染父组件（渲染父组件的帧缓冲）
+      if (this.parent.type === 'RasterLayer') {
+        this.renderMask(this.parent);
+      }
+
+      var isPicked = layers.filter(function (layer) {
+        return _this3.parent.needPick(target.type) && layer.inited && layer.isVisible();
+      }).some(function (layer) {
+        layer.hooks.beforePickingEncode.call();
+
+        if (layer.masks.length > 0) {
+          // 清除上一次的模版缓存
+          _this3.rendererService.clear({
+            stencil: 0,
+            depth: 1,
+            framebuffer: null
+          });
+
+          layer.masks.map(function (m) {
+            m.hooks.beforeRender.call();
+            m.render();
+            m.hooks.afterRender.call();
+          });
+        }
+
+        layer.renderModels(true);
+        layer.hooks.afterPickingEncode.call();
+
+        var layerPicked = _this3.pickingService.pickFromPickingFBO(layer, target); // RasterLayer 不参与拾取后的 shader 计算
+
+
+        if (layerPicked && _this3.parent.type !== 'RasterLayer') {
+          _this3.emit('pick', {
+            type: target.type,
+            pickedColors: _this3.pickingService.pickedColors,
+            layer: layer
+          });
+
+          _this3.pickingService.pickedTileLayers = [_this3.parent];
+        }
+
+        return layerPicked;
+      });
+
+      if (this.parent.type !== 'RasterLayer' && !isPicked && this.isLastPicked && target.type !== 'click') {
+        // 只有上一次有被高亮选中，本次未选中的时候才需要清除选中状态
+        this.pickingService.pickedTileLayers = [];
+        this.emit('unpick', {});
+        this.beforeHighlight([0, 0, 0]);
+      }
+
+      this.isLastPicked = isPicked;
+      return isPicked;
+    }
+  }, {
+    key: "clearPick",
+    value: function clearPick() {
+      this.children.filter(function (child) {
+        return child.inited && child.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeSelect.call([0, 0, 0]);
+      });
+      this.pickingService.pickedTileLayers = [];
+    }
+  }, {
+    key: "beforeHighlight",
+    value: function beforeHighlight(pickedColors) {
+      this.children.filter(function (child) {
+        return child.inited && child.isVisible();
+      }).map(function (child) {
+        child.hooks.beforeHighlight.call(pickedColors);
+      });
+    }
+  }, {
+    key: "beforeSelect",
+    value: function beforeSelect(pickedColors) {
+      this.children.filter(function (child) {
+        return child.inited && child.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeSelect.call(pickedColors);
+      });
+    }
+  }, {
+    key: "renderMask",
+    value: function renderMask(layer) {
+      if (layer.inited && layer.isVisible()) {
+        layer.hooks.beforeRender.call();
+
+        if (layer.masks.length > 0) {
+          this.rendererService.clear({
+            stencil: 0,
+            depth: 1,
+            framebuffer: null
+          });
+          layer.masks.map(function (m) {
+            m.hooks.beforeRender.call();
+            m.render();
+            m.hooks.afterRender.call();
+          });
+        }
+
+        layer.hooks.afterRender.call();
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.removeAllListeners();
+    }
+  }]);
+
+  return TilePickManager;
+}(EventEmitter);
+
+export { TilePickManager as default };

package/es/tile/models/tileModel.d.ts

@@ -0,0 +1,10 @@
+import { IModelUniform } from '@antv/l7-core';
+import BaseModel from '../../core/BaseModel';
+export default class TileModel extends BaseModel {
+    getUninforms(): IModelUniform;
+    private getTileLayer;
+    initModels(): never[];
+    clearModels(): void;
+    buildModels(): never[];
+    protected registerBuiltinAttributes(): void;
+}

package/es/tile/models/tileModel.js

@@ -0,0 +1,81 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import BaseModel from "../../core/BaseModel";
+import { TMSTileLayer } from "../tmsTileLayer";
+import { TMSBaseMapTileLayer } from "../tmsMapTileLayer";
+
+var TileModel = /*#__PURE__*/function (_BaseModel) {
+  _inherits(TileModel, _BaseModel);
+
+  var _super = _createSuper(TileModel);
+
+  function TileModel() {
+    _classCallCheck(this, TileModel);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(TileModel, [{
+    key: "getUninforms",
+    value: function getUninforms() {
+      return {};
+    }
+  }, {
+    key: "getTileLayer",
+    value: function getTileLayer(usage) {
+      switch (usage) {
+        case 'basemap':
+          return TMSBaseMapTileLayer;
+
+        default:
+          return TMSTileLayer;
+      }
+    }
+  }, {
+    key: "initModels",
+    value: function initModels() {
+      var source = this.layer.getSource();
+
+      var _this$layer$getLayerC = this.layer.getLayerConfig(),
+          usage = _this$layer$getLayerC.usage;
+
+      if (source !== null && source !== void 0 && source.data.isTile && !this.layer.tileLayer) {
+        var tileLayer = this.getTileLayer(usage);
+        this.layer.tileLayer = new tileLayer({
+          parent: this.layer,
+          rendererService: this.rendererService,
+          mapService: this.mapService,
+          layerService: this.layerService,
+          pickingService: this.pickingService,
+          transforms: source.transforms
+        });
+      }
+
+      return this.buildModels();
+    }
+  }, {
+    key: "clearModels",
+    value: function clearModels() {}
+  }, {
+    key: "buildModels",
+    value: function buildModels() {
+      return [];
+    }
+  }, {
+    key: "registerBuiltinAttributes",
+    value: function registerBuiltinAttributes() {//
+    }
+  }]);
+
+  return TileModel;
+}(BaseModel);
+
+export { TileModel as default };

package/es/tile/tileFactory/base.d.ts

@@ -0,0 +1,44 @@
+import { ILayer, IMapService, IParseDataItem, IRendererService, IScaleValue, ISubLayerInitOptions, ScaleAttributeType } from '@antv/l7-core';
+import Source from '@antv/l7-source';
+import { Tile, TilesetManager } from '@antv/l7-utils';
+import { ILayerTileConfig, ITileFactory, ITileFactoryOptions, ITileStyles, Timeout } from '../interface';
+export default class TileFactory implements ITileFactory {
+    type: string;
+    parentLayer: ILayer;
+    mapService: IMapService;
+    rendererService: IRendererService;
+    outSideEventTimer: Timeout | null;
+    protected zoomOffset: number;
+    protected tilesetManager: TilesetManager;
+    protected layers: ILayer[];
+    private eventCache;
+    constructor(option: ITileFactoryOptions);
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: ILayer[];
+        layerIDList: string[];
+    };
+    getFeatureData(tile: Tile, initOptions: ISubLayerInitOptions): {
+        features: never[];
+        featureId: null;
+        vectorTileLayer: null;
+        source: null;
+    } | {
+        features: any[];
+        featureId: string | undefined;
+        vectorTileLayer: any;
+        source: Source;
+    };
+    createLayer(tileLayerOption: ILayerTileConfig): any;
+    updateStyle(styles: ITileStyles): string;
+    getDefaultStyleAttributeField(layer: ILayer, type: string): string | string[] | 1;
+    setStyleAttributeField(layer: ILayer, type: ScaleAttributeType, value: IScaleValue | undefined | string | string[]): ILayer | undefined;
+    protected parseScaleValue(value: IScaleValue | string, type: string): (string | number | any[])[] | (import("@antv/l7-core").StyleAttributeField | ((...args: any[]) => [] | undefined))[];
+    protected getTile(lng: number, lat: number): Tile;
+    protected emitEvent(layers: ILayer[], isVector?: boolean): void;
+    protected getCombineFeature(features: IParseDataItem[]): any;
+    protected getFeatureAndEmitEvent(layer: ILayer, eventName: string, e: any, isVector?: boolean, tile?: any): void;
+    private setScale;
+    private getAllFeatures;
+    private getLayerInitOption;
+    private handleOutsideEvent;
+}