@antv/l7-layers 2.10.1 → 2.10.2

package/lib/raster/models/rasterTile.js

@@ -7,6 +7,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -81,44 +85,83 @@ var RasterModel = /*#__PURE__*/function (_BaseModel) {
     }
   }, {
     key: "initModels",
-    value: function initModels(callbackModel) {
-      var _ref2 = this.layer.getLayerConfig(),
-          _ref2$mask = _ref2.mask,
-          mask = _ref2$mask === void 0 ? false : _ref2$mask,
-          _ref2$maskInside = _ref2.maskInside,
-          maskInside = _ref2$maskInside === void 0 ? true : _ref2$maskInside;
-
-      var source = this.layer.getSource();
-      var createTexture2D = this.rendererService.createTexture2D;
-      var parserDataItem = source.data.dataArray[0];
-      this.texture = createTexture2D({
-        data: parserDataItem.data,
-        width: parserDataItem.width,
-        height: parserDataItem.height,
-        format: _l7Core.gl.LUMINANCE,
-        type: _l7Core.gl.FLOAT
-      });
-      this.layer.buildLayerModel({
-        moduleName: 'rasterTileImageData',
-        vertexShader: rasterVert,
-        fragmentShader: rasterFrag,
-        triangulation: _triangulation.RasterImageTriangulation,
-        depth: {
-          enable: false
-        },
-        stencil: (0, _l7Utils.getMask)(mask, maskInside)
-      }).then(function (model) {
-        callbackModel([model]);
-      }).catch(function (err) {
-        console.warn(err);
-        callbackModel([]);
-      });
-    }
+    value: function () {
+      var _initModels = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var _ref2, _ref2$mask, mask, _ref2$maskInside, maskInside, source, createTexture2D, parserDataItem, model;
+
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _ref2 = this.layer.getLayerConfig(), _ref2$mask = _ref2.mask, mask = _ref2$mask === void 0 ? false : _ref2$mask, _ref2$maskInside = _ref2.maskInside, maskInside = _ref2$maskInside === void 0 ? true : _ref2$maskInside;
+                source = this.layer.getSource();
+                createTexture2D = this.rendererService.createTexture2D;
+                parserDataItem = source.data.dataArray[0];
+                this.texture = createTexture2D({
+                  data: parserDataItem.data,
+                  width: parserDataItem.width,
+                  height: parserDataItem.height,
+                  format: _l7Core.gl.LUMINANCE,
+                  type: _l7Core.gl.FLOAT
+                });
+                _context.next = 7;
+                return this.layer.buildLayerModel({
+                  moduleName: 'rasterTileImageData',
+                  vertexShader: rasterVert,
+                  fragmentShader: rasterFrag,
+                  triangulation: _triangulation.RasterImageTriangulation,
+                  depth: {
+                    enable: false
+                  },
+                  stencil: (0, _l7Utils.getMask)(mask, maskInside)
+                });
+
+              case 7:
+                model = _context.sent;
+                return _context.abrupt("return", [model]);
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initModels() {
+        return _initModels.apply(this, arguments);
+      }
+
+      return initModels;
+    }()
   }, {
     key: "buildModels",
-    value: function buildModels(callbackModel) {
-      this.initModels(callbackModel);
-    }
+    value: function () {
+      var _buildModels = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this.initModels();
+
+              case 2:
+                return _context2.abrupt("return", _context2.sent);
+
+              case 3:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
+
+      return buildModels;
+    }()
   }, {
     key: "clearModels",
     value: function clearModels() {

package/lib/raster/raster.js

@@ -7,10 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -69,30 +73,48 @@ var RasterLayer = /*#__PURE__*/function (_BaseLayer) {
     }
   }, {
     key: "buildModels",
-    value: function buildModels() {
-      var parserDataItem = this.getSource().data.dataArray[0];
-      var createTexture2D = this.rendererService.createTexture2D;
-      this.rasterTexture = createTexture2D({
-        data: parserDataItem.data,
-        width: parserDataItem.width,
-        height: parserDataItem.height,
-        format: _l7Core.gl.LUMINANCE,
-        type: _l7Core.gl.FLOAT,
-        aniso: 4
-      });
+    value: function () {
+      var _buildModels = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var parserDataItem, createTexture2D, _this$getLayerConfig, rampColors, imageData;
+
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                parserDataItem = this.getSource().data.dataArray[0];
+                createTexture2D = this.rendererService.createTexture2D;
+                this.rasterTexture = createTexture2D({
+                  data: parserDataItem.data,
+                  width: parserDataItem.width,
+                  height: parserDataItem.height,
+                  format: _l7Core.gl.LUMINANCE,
+                  type: _l7Core.gl.FLOAT,
+                  aniso: 4
+                });
+                _this$getLayerConfig = this.getLayerConfig(), rampColors = _this$getLayerConfig.rampColors;
+                imageData = (0, _l7Utils.generateColorRamp)(rampColors);
+                this.colorTexture = createTexture2D({
+                  data: imageData.data,
+                  width: imageData.width,
+                  height: imageData.height,
+                  flipY: false
+                });
+                this.models = [this.buildRasterModel()];
+
+              case 7:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-      var _this$getLayerConfig = this.getLayerConfig(),
-          rampColors = _this$getLayerConfig.rampColors;
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
 
-      var imageData = (0, _l7Utils.generateColorRamp)(rampColors);
-      this.colorTexture = createTexture2D({
-        data: imageData.data,
-        width: imageData.width,
-        height: imageData.height,
-        flipY: false
-      });
-      this.models = [this.buildRasterModel()];
-    }
+      return buildModels;
+    }()
   }, {
     key: "renderModels",
     value: function renderModels() {

package/lib/tile/interaction/utils.js

@@ -45,7 +45,7 @@ function setSelect(layers, pickedColors, renderList) {
   }); // unselect normal layer
 
   renderList.filter(function (layer) {
-    return layer.inited && !layer.isVector && layer.isVisible() && layer.needPick('click');
+    return layer.inited && layer.isVisible() && layer.needPick('click');
   }).filter(function (layer) {
     return layer.getCurrentSelectedId() !== null;
   }).map(function (layer) {
@@ -58,9 +58,8 @@ function setSelect(layers, pickedColors, renderList) {
 function setHighlight(layers, pickedColors) {
   var pickId = (0, _l7Utils.decodePickingColor)(pickedColors);
   layers.filter(function (layer) {
-    return layer.inited && layer.isVisible() && layer.isVector;
-  }) // Tip: 使用 vectorLayer 上的 pickID 优化高亮操作（过滤重复操作）
-  // @ts-ignore
+    return layer.inited && layer.isVisible();
+  }) // @ts-ignore
   .filter(function (layer) {
     return layer.getPickID() !== pickId;
   }).map(function (layer) {
@@ -73,13 +72,6 @@ function setHighlight(layers, pickedColors) {
 function setPickState(layers, pickColors) {
   if (pickColors.select) {
     layers.map(function (layer) {
-      // if(layer.modelLoaded) {
-      //   selectFeature(layer, this.pickColors.select);
-      // } else {
-      //   layer.once('modelLoaded', () => {
-      //     selectFeature(layer, this.pickColors.select);
-      //   })
-      // }
       selectFeature(layer, pickColors.select);
     });
   }

package/lib/tile/manager/base.js

@@ -7,63 +7,152 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Base = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _tileFactory = require("../tileFactory");
+var _l7Core = require("@antv/l7-core");
 
-var _utils = require("../utils");
+var _utils = require("../style/utils");
 
 var Base = /*#__PURE__*/function () {
   function Base() {
     (0, _classCallCheck2.default)(this, Base);
     (0, _defineProperty2.default)(this, "tileCache", new Map());
+    (0, _defineProperty2.default)(this, "tileLayerCache", new Map());
   }
 
   (0, _createClass2.default)(Base, [{
+    key: "initTileLayers",
+    value: function () {
+      var _initTileLayers = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(layers, tile) {
+        var _this = this;
+
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", Promise.all(layers.map( /*#__PURE__*/function () {
+                  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(layer) {
+                    var container;
+                    return _regenerator.default.wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            container = (0, _l7Core.createLayerContainer)(_this.parent.sceneContainer);
+                            layer.setContainer(container, _this.parent.sceneContainer);
+                            _context.next = 4;
+                            return layer.init();
+
+                          case 4:
+                            _this.addChild(layer);
+
+                            tile.layerLoad();
+
+                            _this.render();
+
+                          case 7:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }));
+
+                  return function (_x3) {
+                    return _ref.apply(this, arguments);
+                  };
+                }())));
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function initTileLayers(_x, _x2) {
+        return _initTileLayers.apply(this, arguments);
+      }
+
+      return initTileLayers;
+    }()
+  }, {
+    key: "render",
+    value: function render() {
+      this.parent.renderLayers();
+    }
+  }, {
     key: "hasTile",
     value: function hasTile(tile) {
-      return !!this.tileCache.has(tile.key);
-    }
+      return this.tileCache.has(tile.key);
+    } // 添加图层
+
   }, {
     key: "addTile",
-    value: function addTile(tile) {
-      var _tile$layerIDList;
+    value: function () {
+      var _addTile = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(tile) {
+        var layerCollections;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                if (!this.hasTile(tile)) {
+                  _context3.next = 2;
+                  break;
+                }
 
-      // oldTile 存在的时候暂时直接结束
-      // TODO：合并不存在的时候
-      if (this.hasTile(tile)) return {
-        layers: [],
-        layerIDList: []
-      }; // 存储当前 tile
+                return _context3.abrupt("return", {
+                  layers: []
+                });
 
-      this.tileCache.set(tile.key, tile); // 创建 tile 对应的 layers
+              case 2:
+                // 存储当前 tile
+                this.tileCache.set(tile.key, tile); // 创建 tile 对应的 layers
 
-      var layerCollections = this.tileFactory.createTile(tile, this.initOptions); // regist layer 将创建出来的 layer 进行注册初始化操作
+                layerCollections = this.tileFactory.createTile(tile, this.initOptions); // // 初始化图层
 
-      (0, _utils.registerLayers)(this.parent, layerCollections.layers);
+                _context3.next = 6;
+                return this.initTileLayers(layerCollections.layers, tile);
 
-      (_tile$layerIDList = tile.layerIDList).push.apply(_tile$layerIDList, (0, _toConsumableArray2.default)(layerCollections.layerIDList)); // add layer into layerGroup
+              case 6:
+                this.tileLayerCache.set(tile.key, layerCollections.layers); // const visible =  tile.parent ? tile.parent.children.every(t=>this.tileLayerCache.has(t.key)) : true
+                // tile.parent?.children.forEach((t)=>{
+                //   updateLayersConfig(this.getLayers(t),'visible',visible)
+                // })
 
+                return _context3.abrupt("return", layerCollections);
 
-      this.addChildren(layerCollections.layers);
-      layerCollections.layers.map(function (layer) {
-        layer.once('modelLoaded', function () {
-          tile.layerLoad();
-        });
-      });
-      return layerCollections;
-    }
+              case 8:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function addTile(_x4) {
+        return _addTile.apply(this, arguments);
+      }
+
+      return addTile;
+    }()
   }, {
     key: "removeTile",
     value: function removeTile(tile) {
       this.tileCache.delete(tile.key);
-      this.removeChildren(tile.layerIDList, false);
+      var layers = this.tileLayerCache.get(tile.key);
+      this.tileLayerCache.delete(tile.key);
+      this.removeLayers(layers, false);
     }
   }, {
     key: "addChild",
@@ -78,18 +167,16 @@ var Base = /*#__PURE__*/function () {
       (_this$children = this.children).push.apply(_this$children, (0, _toConsumableArray2.default)(layers));
     }
   }, {
-    key: "removeChildren",
-    value: function removeChildren(layerIDList) {
+    key: "removeLayers",
+    value: function removeLayers() {
+      var layers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
       var refresh = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var remveLayerList = [];
-      var cacheLayerList = [];
-      this.children.filter(function (child) {
-        layerIDList.includes(child.id) ? remveLayerList.push(child) : cacheLayerList.push(child);
+      this.children = this.children.filter(function (child) {
+        return !layers.includes(child);
       });
-      remveLayerList.map(function (layer) {
+      layers.map(function (layer) {
         return layer.destroy(refresh);
       });
-      this.children = cacheLayerList;
     }
   }, {
     key: "removeChild",
@@ -103,11 +190,10 @@ var Base = /*#__PURE__*/function () {
       layer.destroy();
     }
   }, {
-    key: "getChildren",
-    value: function getChildren(layerIDList) {
-      return this.children.filter(function (child) {
-        return layerIDList.includes(child.id);
-      });
+    key: "getLayers",
+    value: function getLayers(tile) {
+      if (!tile) return [];
+      return this.tileLayerCache.get(tile.key) || [];
     }
   }, {
     key: "getChild",
@@ -131,14 +217,11 @@ var Base = /*#__PURE__*/function () {
     }
   }, {
     key: "initTileFactory",
-    value: function initTileFactory() {
-      var source = this.parent.getSource();
-      var TileFactory = (0, _tileFactory.getTileFactory)(this.parent.type, source.parser);
-      this.tileFactory = new TileFactory({
-        parent: this.parent,
-        mapService: this.mapService,
-        rendererService: this.rendererService
-      });
+    value: function initTileFactory() {// this.tileFactory = new TileFactory({
+      //   parent: this.parent,
+      //   mapService: this.mapService,
+      //   rendererService: this.rendererService,
+      // });
     }
   }, {
     key: "getSourceLayer",
@@ -151,9 +234,92 @@ var Base = /*#__PURE__*/function () {
         return sourceLayer;
       }
     }
+  }, {
+    key: "updateTileVisible",
+    value: function updateTileVisible(tile, layerService) {
+      var layers = this.getLayers(tile);
+      if (layers.length === 0) return;
+
+      if (tile.isVisible) {
+        // 如果可见直接进行渲染，父级发
+        (0, _utils.updateLayersConfig)(layers, 'visible', tile.isVisible);
+      } else {
+        // 如果不可见，放大，等到子瓦片渲染完成，缩小：父级渲染成功
+        // console.log('updateTileVisible',`${tile.x}_${tile.y}_${tile.z}`,tile.isVisible)
+        // console.log(tile);
+        // console.log(`子瓦片${tile.x}/${tile.y}/${tile.z}`,tile.children.length)
+        // tile.children.forEach((t)=>{
+        //   console.log(`${t.x}/${t.y}/${t.z}`)
+        // })
+        (0, _utils.updateLayersConfig)(layers, 'visible', tile.isVisible);
+      } // this.listenLoad(tile, () => {
+      //   this.isTileAllLoad(tile) && updateLayersConfig(layers, 'visible', tile.isVisible);
+      // })
+
+    }
+  }, {
+    key: "listenLoad",
+    value: function listenLoad(tile, callback) {
+      var _tile$parent;
+
+      tile.once('layerLoaded', function () {
+        callback();
+      });
+      tile.children.map(function (childTile) {
+        childTile.once('layerLoaded', function () {
+          callback();
+        });
+      });
+      (_tile$parent = tile.parent) === null || _tile$parent === void 0 ? void 0 : _tile$parent.once('layerLoaded', function () {
+        callback();
+      });
+    }
+  }, {
+    key: "isTileLoaded",
+    value: function isTileLoaded(tile) {
+      if (tile.isLoad) return true;
+      var isLoad = this.getLayers(tile).length === tile.loadedLayers;
+      tile.isLoad = isLoad;
+      return isLoad;
+    }
+  }, {
+    key: "isTileChildLoaded",
+    value: function isTileChildLoaded(tile) {
+      var _this2 = this;
+
+      if (tile.isChildLoad) return true;
+      var children = tile.children;
+      var isLoad = children.filter(function (child) {
+        return _this2.isTileLoaded(child);
+      }).length === children.length;
+      tile.isChildLoad = isLoad;
+      return isLoad;
+    }
+  }, {
+    key: "isTileParentLoaded",
+    value: function isTileParentLoaded(tile) {
+      var parent = tile.parent;
+
+      if (!parent) {
+        return true;
+      } else {
+        return this.isTileLoaded(parent);
+      }
+    }
+  }, {
+    key: "isTileAllLoad",
+    value: function isTileAllLoad(tile) {
+      var tileLoaded = this.isTileLoaded(tile);
+      var tileChildLoaded = this.isTileChildLoaded(tile);
+      var tileParentLoaded = this.isTileParentLoaded(tile);
+      return tileLoaded && tileChildLoaded && tileParentLoaded;
+    }
   }, {
     key: "destroy",
-    value: function destroy() {}
+    value: function destroy() {
+      this.tileCache.clear();
+      this.tileLayerCache.clear();
+    }
   }]);
   return Base;
 }();