@antv/l7-scene 2.9.32-alpha.2 → 2.9.32-alpha.4

package/es/index.js

@@ -0,0 +1,568 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { Logo } from '@antv/l7-component';
+import { createLayerContainer, createSceneContainer, SceneEventList, TYPES } from '@antv/l7-core';
+import { MaskLayer } from '@antv/l7-layers';
+import { ReglRendererService } from '@antv/l7-renderer';
+import { DOM, isMini } from '@antv/l7-utils';
+import BoxSelect, { BoxSelectEventList } from "./boxSelect";
+
+/**
+ * 暴露 Scene API
+ *
+ * @example
+ * import { Scene } from 'l7/scene';
+ * import { PointLayer } from 'l7/layers';
+ *
+ * const scene = new Scene();
+ * const pointLayer = new PointLayer();
+ * scene.addLayer(pointLayer);
+ *
+ */
+var Scene = /*#__PURE__*/function () {
+  function Scene(config) {
+    _classCallCheck(this, Scene);
+
+    var id = config.id,
+        map = config.map,
+        canvas = config.canvas,
+        hasBaseMap = config.hasBaseMap; // 创建场景容器
+
+    var sceneContainer = createSceneContainer();
+    this.container = sceneContainer; // 绑定地图服务
+
+    map.setContainer(sceneContainer, id, canvas, hasBaseMap); // 绑定渲染引擎服务
+
+    sceneContainer.bind(TYPES.IRendererService).to(ReglRendererService).inSingletonScope(); // 依赖注入
+
+    this.sceneService = sceneContainer.get(TYPES.ISceneService);
+    this.mapService = sceneContainer.get(TYPES.IMapService);
+    this.iconService = sceneContainer.get(TYPES.IIconService);
+    this.fontService = sceneContainer.get(TYPES.IFontService);
+    this.controlService = sceneContainer.get(TYPES.IControlService);
+    this.layerService = sceneContainer.get(TYPES.ILayerService);
+    this.markerService = sceneContainer.get(TYPES.IMarkerService);
+    this.interactionService = sceneContainer.get(TYPES.IInteractionService);
+    this.popupService = sceneContainer.get(TYPES.IPopupService);
+    this.boxSelect = new BoxSelect(this, {
+      className: config.selectBoxClassName
+    });
+
+    if (isMini) {
+      this.sceneService.initMiniScene(config);
+    } else {
+      this.initComponent(id); // 初始化 scene
+
+      this.sceneService.init(config); // TODO: 初始化组件
+
+      this.initControl();
+    }
+  }
+
+  _createClass(Scene, [{
+    key: "map",
+    get: function get() {
+      return this.mapService.map;
+    }
+  }, {
+    key: "loaded",
+    get: function get() {
+      return this.sceneService.loaded;
+    }
+  }, {
+    key: "getServiceContainer",
+    value: function getServiceContainer() {
+      return this.container;
+    }
+  }, {
+    key: "getSize",
+    value: function getSize() {
+      return this.mapService.getSize();
+    }
+  }, {
+    key: "getMinZoom",
+    value: function getMinZoom() {
+      return this.mapService.getMinZoom();
+    }
+  }, {
+    key: "getMaxZoom",
+    value: function getMaxZoom() {
+      return this.mapService.getMaxZoom();
+    }
+  }, {
+    key: "getType",
+    value: function getType() {
+      return this.mapService.getType();
+    }
+  }, {
+    key: "getMapContainer",
+    value: function getMapContainer() {
+      return this.mapService.getMapContainer();
+    }
+  }, {
+    key: "getMapCanvasContainer",
+    value: function getMapCanvasContainer() {
+      return this.mapService.getMapCanvasContainer();
+    }
+  }, {
+    key: "getMapService",
+    value: function getMapService() {
+      return this.mapService;
+    }
+  }, {
+    key: "exportPng",
+    value: function exportPng(type) {
+      return this.sceneService.exportPng(type);
+    }
+  }, {
+    key: "exportMap",
+    value: function exportMap(type) {
+      return this.sceneService.exportPng(type);
+    }
+  }, {
+    key: "registerRenderService",
+    value: function registerRenderService(render) {
+      var _this = this;
+
+      if (this.sceneService.loaded) {
+        var renderSerivce = new render(this);
+        renderSerivce.init();
+      } else {
+        this.on('loaded', function () {
+          var renderSerivce = new render(_this);
+          renderSerivce.init();
+        });
+      }
+    }
+  }, {
+    key: "setBgColor",
+    value: function setBgColor(color) {
+      this.mapService.setBgColor(color);
+    } // layer 管理
+
+  }, {
+    key: "addLayer",
+    value: function addLayer(layer) {
+      // 为当前图层创建一个容器
+      // TODO: 初始化的时候设置 容器
+      var layerContainer = createLayerContainer(this.container);
+      layer.setContainer(layerContainer, this.container);
+      this.sceneService.addLayer(layer);
+      var layerConfig = layer.getLayerConfig();
+
+      if (layerConfig) {
+        // 若 layer 未初始化成功，则 layerConfig 为 undefined （scene loaded 尚未执行完成）
+        var mask = layerConfig.mask,
+            maskfence = layerConfig.maskfence,
+            _layerConfig$maskColo = layerConfig.maskColor,
+            maskColor = _layerConfig$maskColo === void 0 ? '#000' : _layerConfig$maskColo,
+            _layerConfig$maskOpac = layerConfig.maskOpacity,
+            maskOpacity = _layerConfig$maskOpac === void 0 ? 0 : _layerConfig$maskOpac;
+
+        if (mask && maskfence) {
+          var maskInstance = new MaskLayer().source(maskfence).shape('fill').style({
+            color: maskColor,
+            opacity: maskOpacity
+          });
+          this.addMask(maskInstance, layer.id);
+        }
+      } else {
+        console.warn('addLayer should run after scene loaded!');
+      }
+    }
+  }, {
+    key: "addMask",
+    value: function addMask(mask, layerId) {
+      var parent = this.getLayer(layerId);
+
+      if (parent) {
+        var layerContainer = createLayerContainer(this.container);
+        mask.setContainer(layerContainer, this.container);
+        parent.addMaskLayer(mask);
+        this.sceneService.addLayer(mask);
+      } else {
+        console.warn('parent layer not find!');
+      }
+    }
+  }, {
+    key: "getPickedLayer",
+    value: function getPickedLayer() {
+      return this.layerService.pickedLayerId;
+    }
+  }, {
+    key: "getLayers",
+    value: function getLayers() {
+      return this.layerService.getLayers();
+    }
+  }, {
+    key: "getLayer",
+    value: function getLayer(id) {
+      return this.layerService.getLayer(id);
+    }
+  }, {
+    key: "getLayerByName",
+    value: function getLayerByName(name) {
+      return this.layerService.getLayerByName(name);
+    }
+  }, {
+    key: "removeLayer",
+    value: function removeLayer(layer, parentLayer) {
+      this.layerService.remove(layer, parentLayer);
+    }
+  }, {
+    key: "removeAllLayer",
+    value: function removeAllLayer() {
+      this.layerService.removeAllLayers();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      this.sceneService.render();
+    }
+  }, {
+    key: "setEnableRender",
+    value: function setEnableRender(flag) {
+      this.layerService.setEnableRender(flag);
+    } // asset method
+
+    /**
+     * 为 layer/point/text 支持 iconfont 模式支持
+     * @param fontUnicode
+     * @param name
+     */
+
+  }, {
+    key: "addIconFont",
+    value: function addIconFont(name, fontUnicode) {
+      this.fontService.addIconFont(name, fontUnicode);
+    }
+  }, {
+    key: "addIconFonts",
+    value: function addIconFonts(options) {
+      var _this2 = this;
+
+      options.forEach(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+            name = _ref2[0],
+            fontUnicode = _ref2[1];
+
+        _this2.fontService.addIconFont(name, fontUnicode);
+      });
+    }
+    /**
+     * 用户自定义添加第三方字体
+     * @param fontFamily
+     * @param fontPath
+     */
+
+  }, {
+    key: "addFontFace",
+    value: function addFontFace(fontFamily, fontPath) {
+      this.sceneService.addFontFace(fontFamily, fontPath);
+    }
+  }, {
+    key: "addImage",
+    value: function addImage(id, img) {
+      if (!isMini) {
+        this.iconService.addImage(id, img);
+      } else {
+        this.iconService.addImageMini(id, img, this.sceneService);
+      } // this.iconService.addImage(id, img);
+
+    }
+  }, {
+    key: "hasImage",
+    value: function hasImage(id) {
+      return this.iconService.hasImage(id);
+    }
+  }, {
+    key: "removeImage",
+    value: function removeImage(id) {
+      this.iconService.removeImage(id);
+    }
+  }, {
+    key: "addIconFontGlyphs",
+    value: function addIconFontGlyphs(fontFamily, glyphs) {
+      this.fontService.addIconGlyphs(glyphs);
+    } // map control method
+
+  }, {
+    key: "addControl",
+    value: function addControl(ctr) {
+      this.controlService.addControl(ctr, this.container);
+    }
+  }, {
+    key: "removeControl",
+    value: function removeControl(ctr) {
+      this.controlService.removeControl(ctr);
+    }
+  }, {
+    key: "getControlByName",
+    value: function getControlByName(name) {
+      return this.controlService.getControlByName(name);
+    } // marker
+
+  }, {
+    key: "addMarker",
+    value: function addMarker(marker) {
+      this.markerService.addMarker(marker);
+    }
+  }, {
+    key: "addMarkerLayer",
+    value: function addMarkerLayer(layer) {
+      this.markerService.addMarkerLayer(layer);
+    }
+  }, {
+    key: "removeMarkerLayer",
+    value: function removeMarkerLayer(layer) {
+      this.markerService.removeMarkerLayer(layer);
+    }
+  }, {
+    key: "removeAllMakers",
+    value: function removeAllMakers() {
+      this.markerService.removeAllMarkers();
+    }
+  }, {
+    key: "addPopup",
+    value: function addPopup(popup) {
+      this.popupService.addPopup(popup);
+    }
+  }, {
+    key: "removePopup",
+    value: function removePopup(popup) {
+      this.popupService.removePopup(popup);
+    }
+  }, {
+    key: "on",
+    value: function on(type, handle) {
+      if (BoxSelectEventList.includes(type)) {
+        var _this$boxSelect;
+
+        (_this$boxSelect = this.boxSelect) === null || _this$boxSelect === void 0 ? void 0 : _this$boxSelect.on(type, handle);
+      } else if (SceneEventList.includes(type)) {
+        this.sceneService.on(type, handle);
+      } else {
+        this.mapService.on(type, handle);
+      }
+    }
+  }, {
+    key: "once",
+    value: function once(type, handle) {
+      if (BoxSelectEventList.includes(type)) {
+        var _this$boxSelect2;
+
+        (_this$boxSelect2 = this.boxSelect) === null || _this$boxSelect2 === void 0 ? void 0 : _this$boxSelect2.once(type, handle);
+      } else if (SceneEventList.includes(type)) {
+        this.sceneService.once(type, handle);
+      } else {
+        this.mapService.once(type, handle);
+      }
+    }
+  }, {
+    key: "off",
+    value: function off(type, handle) {
+      if (BoxSelectEventList.includes(type)) {
+        var _this$boxSelect3;
+
+        (_this$boxSelect3 = this.boxSelect) === null || _this$boxSelect3 === void 0 ? void 0 : _this$boxSelect3.off(type, handle);
+      } else if (SceneEventList.includes(type)) {
+        this.sceneService.off(type, handle);
+      } else {
+        this.mapService.off(type, handle);
+      }
+    } // implements IMapController
+
+  }, {
+    key: "getZoom",
+    value: function getZoom() {
+      return this.mapService.getZoom();
+    }
+  }, {
+    key: "getCenter",
+    value: function getCenter(options) {
+      return this.mapService.getCenter(options);
+    }
+  }, {
+    key: "setCenter",
+    value: function setCenter(center, options) {
+      return this.mapService.setCenter(center, options);
+    }
+  }, {
+    key: "getPitch",
+    value: function getPitch() {
+      return this.mapService.getPitch();
+    }
+  }, {
+    key: "setPitch",
+    value: function setPitch(pitch) {
+      return this.mapService.setPitch(pitch);
+    }
+  }, {
+    key: "getRotation",
+    value: function getRotation() {
+      return this.mapService.getRotation();
+    }
+  }, {
+    key: "getBounds",
+    value: function getBounds() {
+      return this.mapService.getBounds();
+    }
+  }, {
+    key: "setRotation",
+    value: function setRotation(rotation) {
+      this.mapService.setRotation(rotation);
+    }
+  }, {
+    key: "zoomIn",
+    value: function zoomIn() {
+      this.mapService.zoomIn();
+    }
+  }, {
+    key: "zoomOut",
+    value: function zoomOut() {
+      this.mapService.zoomOut();
+    }
+  }, {
+    key: "panTo",
+    value: function panTo(p) {
+      this.mapService.panTo(p);
+    }
+  }, {
+    key: "panBy",
+    value: function panBy(x, y) {
+      this.mapService.panBy(x, y);
+    }
+  }, {
+    key: "getContainer",
+    value: function getContainer() {
+      return this.mapService.getContainer();
+    }
+  }, {
+    key: "setZoom",
+    value: function setZoom(zoom) {
+      this.mapService.setZoom(zoom);
+    }
+  }, {
+    key: "fitBounds",
+    value: function fitBounds(bound, options) {
+      var _this$sceneService$ge = this.sceneService.getSceneConfig(),
+          fitBoundsOptions = _this$sceneService$ge.fitBoundsOptions,
+          animate = _this$sceneService$ge.animate;
+
+      this.mapService.fitBounds(bound, // 选项优先级：用户传入，覆盖animate直接配置，覆盖Scene配置项传入
+      options || _objectSpread(_objectSpread({}, fitBoundsOptions), {}, {
+        animate: animate
+      }));
+    }
+  }, {
+    key: "setZoomAndCenter",
+    value: function setZoomAndCenter(zoom, center) {
+      this.mapService.setZoomAndCenter(zoom, center);
+    }
+  }, {
+    key: "setMapStyle",
+    value: function setMapStyle(style) {
+      this.mapService.setMapStyle(style);
+    }
+  }, {
+    key: "setMapStatus",
+    value: function setMapStatus(options) {
+      this.mapService.setMapStatus(options);
+    } // conversion Method
+
+  }, {
+    key: "pixelToLngLat",
+    value: function pixelToLngLat(pixel) {
+      return this.mapService.pixelToLngLat(pixel);
+    }
+  }, {
+    key: "lngLatToPixel",
+    value: function lngLatToPixel(lnglat) {
+      return this.mapService.lngLatToPixel(lnglat);
+    }
+  }, {
+    key: "containerToLngLat",
+    value: function containerToLngLat(pixel) {
+      return this.mapService.containerToLngLat(pixel);
+    }
+  }, {
+    key: "lngLatToContainer",
+    value: function lngLatToContainer(lnglat) {
+      return this.mapService.lngLatToContainer(lnglat);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.sceneService.destroy(); // TODO: 清理其他 Service 例如 IconService
+    }
+  }, {
+    key: "registerPostProcessingPass",
+    value: function registerPostProcessingPass(constructor, name) {
+      this.container.bind(TYPES.IPostProcessingPass).to(constructor).whenTargetNamed(name);
+    } // 控制 shader pick 计算
+
+  }, {
+    key: "enableShaderPick",
+    value: function enableShaderPick() {
+      this.layerService.enableShaderPick();
+    }
+  }, {
+    key: "diasbleShaderPick",
+    value: function diasbleShaderPick() {
+      this.layerService.disableShaderPick();
+    }
+  }, {
+    key: "enableBoxSelect",
+    value: function enableBoxSelect() {
+      var _this3 = this;
+
+      var once = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      this.boxSelect.enable();
+
+      if (once) {
+        this.boxSelect.once('selectend', function () {
+          _this3.disableBoxSelect();
+        });
+      }
+    }
+  }, {
+    key: "disableBoxSelect",
+    value: function disableBoxSelect() {
+      this.boxSelect.disable();
+    } // get current point size info
+
+  }, {
+    key: "getPointSizeRange",
+    value: function getPointSizeRange() {
+      return this.sceneService.getPointSizeRange();
+    }
+  }, {
+    key: "initComponent",
+    value: function initComponent(id) {
+      this.controlService.init({
+        container: DOM.getContainer(id)
+      }, this.container);
+      this.markerService.init(this.container);
+      this.popupService.init(this.container);
+    }
+  }, {
+    key: "initControl",
+    value: function initControl() {
+      var _this$sceneService$ge2 = this.sceneService.getSceneConfig(),
+          logoVisible = _this$sceneService$ge2.logoVisible,
+          logoPosition = _this$sceneService$ge2.logoPosition;
+
+      if (logoVisible) {
+        this.addControl(new Logo({
+          position: logoPosition
+        }));
+      }
+    }
+  }]);
+
+  return Scene;
+}();
+
+export { Scene };

package/lib/ILayerManager.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ILayerManager.ts
+var ILayerManager_exports = {};
+module.exports = __toCommonJS(ILayerManager_exports);

package/lib/IMapController.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/IMapController.ts
+var IMapController_exports = {};
+module.exports = __toCommonJS(IMapController_exports);

package/lib/IPostProcessingPassPluggable.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/IPostProcessingPassPluggable.ts
+var IPostProcessingPassPluggable_exports = {};
+module.exports = __toCommonJS(IPostProcessingPassPluggable_exports);