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

package/es/raster/models/rasterRgb.js

@@ -0,0 +1,226 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+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";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+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 { AttributeType, gl } from '@antv/l7-core';
+import { getMask } from '@antv/l7-utils';
+import BaseModel from "../../core/BaseModel";
+import { RasterImageTriangulation } from "../../core/triangulation";
+
+/* babel-plugin-inline-import '../shaders/raster_rgb_frag.glsl' */
+var rasterFrag = "precision mediump float;\nuniform float u_opacity: 1.0;\nuniform sampler2D u_texture;\nuniform float u_channelRMax: 256.;\nuniform float u_channelGMax: 256.;\nuniform float u_channelBMax: 256.;\nvarying vec2 v_texCoord;\n\nvoid main() {\n  vec3 rgb = texture2D(u_texture,vec2(v_texCoord.x,v_texCoord.y)).rgb;\n  gl_FragColor = vec4(rgb.r/u_channelRMax, rgb.g/u_channelGMax, rgb.b/u_channelBMax, u_opacity);\n}";
+
+/* babel-plugin-inline-import '../shaders/raster_2d_vert.glsl' */
+var rasterVert = "precision highp float;\nuniform mat4 u_ModelMatrix;\nuniform mat4 u_Mvp;\nattribute vec3 a_Position;\nattribute vec2 a_Uv;\nvarying vec2 v_texCoord;\n#pragma include \"projection\"\nvoid main() {\n   v_texCoord = a_Uv;\n   vec4 project_pos = project_position(vec4(a_Position, 1.0));\n\n   if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x\n      gl_Position = u_Mvp * (vec4(project_pos.xy,0., 1.0));\n   } else {\n      gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy,0., 1.0));\n   }\n}\n";
+
+var RasterModel = /*#__PURE__*/function (_BaseModel) {
+  _inherits(RasterModel, _BaseModel);
+
+  var _super = _createSuper(RasterModel);
+
+  function RasterModel() {
+    var _this;
+
+    _classCallCheck(this, RasterModel);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "channelRMax", 256);
+
+    _defineProperty(_assertThisInitialized(_this), "channelGMax", 256);
+
+    _defineProperty(_assertThisInitialized(_this), "channelBMax", 256);
+
+    return _this;
+  }
+
+  _createClass(RasterModel, [{
+    key: "getUninforms",
+    value: function getUninforms() {
+      var _ref = this.layer.getLayerConfig(),
+          _ref$opacity = _ref.opacity,
+          opacity = _ref$opacity === void 0 ? 1 : _ref$opacity,
+          channelRMax = _ref.channelRMax,
+          channelGMax = _ref.channelGMax,
+          channelBMax = _ref.channelBMax;
+
+      return {
+        u_opacity: opacity || 1,
+        u_texture: this.texture,
+        u_channelRMax: channelRMax !== undefined ? channelRMax : this.channelRMax,
+        u_channelGMax: channelGMax !== undefined ? channelGMax : this.channelGMax,
+        u_channelBMax: channelBMax !== undefined ? channelBMax : this.channelBMax
+      };
+    }
+  }, {
+    key: "getRasterData",
+    value: function () {
+      var _getRasterData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(parserDataItem) {
+        var _yield$parserDataItem, rasterData, width, height, channelR, channelG, channelB;
+
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!Array.isArray(parserDataItem.data)) {
+                  _context.next = 4;
+                  break;
+                }
+
+                return _context.abrupt("return", {
+                  data: parserDataItem.data,
+                  width: parserDataItem.width,
+                  height: parserDataItem.height
+                });
+
+              case 4:
+                _context.next = 6;
+                return parserDataItem.data;
+
+              case 6:
+                _yield$parserDataItem = _context.sent;
+                rasterData = _yield$parserDataItem.rasterData;
+                width = _yield$parserDataItem.width;
+                height = _yield$parserDataItem.height;
+                channelR = _yield$parserDataItem.channelR;
+                channelG = _yield$parserDataItem.channelG;
+                channelB = _yield$parserDataItem.channelB;
+                this.channelRMax = channelR;
+                this.channelGMax = channelG;
+                this.channelBMax = channelB;
+                return _context.abrupt("return", {
+                  data: Array.from(rasterData),
+                  width: width,
+                  height: height
+                });
+
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function getRasterData(_x) {
+        return _getRasterData.apply(this, arguments);
+      }
+
+      return getRasterData;
+    }()
+  }, {
+    key: "initModels",
+    value: function () {
+      var _initModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(callbackModel) {
+        var _ref2, _ref2$mask, mask, _ref2$maskInside, maskInside, source, createTexture2D, parserDataItem, _yield$this$getRaster, data, width, height;
+
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.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];
+                _context2.next = 6;
+                return this.getRasterData(parserDataItem);
+
+              case 6:
+                _yield$this$getRaster = _context2.sent;
+                data = _yield$this$getRaster.data;
+                width = _yield$this$getRaster.width;
+                height = _yield$this$getRaster.height;
+                this.texture = createTexture2D({
+                  // @ts-ignore
+                  data: data,
+                  width: width,
+                  height: height,
+                  format: gl.RGB,
+                  type: gl.FLOAT
+                });
+                this.layer.buildLayerModel({
+                  moduleName: 'rasterImageDataRGBA',
+                  vertexShader: rasterVert,
+                  fragmentShader: rasterFrag,
+                  triangulation: RasterImageTriangulation,
+                  primitive: gl.TRIANGLES,
+                  depth: {
+                    enable: false
+                  },
+                  stencil: getMask(mask, maskInside),
+                  pick: false
+                }).then(function (model) {
+                  callbackModel([model]);
+                }).catch(function (err) {
+                  console.warn(err);
+                  callbackModel([]);
+                });
+
+              case 12:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function initModels(_x2) {
+        return _initModels.apply(this, arguments);
+      }
+
+      return initModels;
+    }()
+  }, {
+    key: "buildModels",
+    value: function buildModels(callbackModel) {
+      this.initModels(callbackModel);
+    }
+  }, {
+    key: "clearModels",
+    value: function clearModels() {
+      var _this$texture;
+
+      (_this$texture = this.texture) === null || _this$texture === void 0 ? void 0 : _this$texture.destroy();
+    }
+  }, {
+    key: "registerBuiltinAttributes",
+    value: function registerBuiltinAttributes() {
+      // point layer size;
+      this.styleAttributeService.registerStyleAttribute({
+        name: 'uv',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_Uv',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.DYNAMIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 2,
+          update: function update(feature, featureIdx, vertex) {
+            return [vertex[3], vertex[4]];
+          }
+        }
+      });
+    }
+  }]);
+
+  return RasterModel;
+}(BaseModel);
+
+export { RasterModel as default };

package/es/raster/shaders/raster_rgb_frag.glsl

@@ -0,0 +1,12 @@
+precision mediump float;
+uniform float u_opacity: 1.0;
+uniform sampler2D u_texture;
+uniform float u_channelRMax: 256.;
+uniform float u_channelGMax: 256.;
+uniform float u_channelBMax: 256.;
+varying vec2 v_texCoord;
+
+void main() {
+  vec3 rgb = texture2D(u_texture,vec2(v_texCoord.x,v_texCoord.y)).rgb;
+  gl_FragColor = vec4(rgb.r/u_channelRMax, rgb.g/u_channelGMax, rgb.b/u_channelBMax, u_opacity);
+}

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

@@ -30,7 +30,7 @@ export default class TileFactory implements ITileFactory {
     };
     createLayer(tileLayerOption: ILayerTileConfig): any;
     updateStyle(styles: ITileStyles): string;
-    getDefautStyleAttributeField(layer: ILayer, type: string): string | string[] | 1;
+    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;

package/es/tile/tileFactory/base.js

@@ -5,7 +5,6 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import Source from '@antv/l7-source';
 import { osmLonLat2TileXY } from '@antv/l7-utils';
-import MaskLayer from "../../mask";
 import { getLayerShape, readRasterValue, registerLayers } from "../utils";
 import VectorLayer from "./vectorLayer";
 import * as turf from '@turf/helpers';
@@ -170,7 +169,9 @@ var TileFactory = /*#__PURE__*/function () {
       var layers = [layer];
 
       if (mask && layer.isVector) {
-        var masklayer = new MaskLayer().source({
+        var masklayer = new VectorLayer({
+          layerType: "MaskLayer"
+        }).source({
           type: 'FeatureCollection',
           features: [tile.bboxPolygon]
         }, {
@@ -187,15 +188,16 @@ var TileFactory = /*#__PURE__*/function () {
       registerLayers(this.parentLayer, layers);
       this.layers = [layer];
       return layer;
-    }
+    } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
   }, {
     key: "updateStyle",
     value: function updateStyle(styles) {
       return '';
     }
   }, {
-    key: "getDefautStyleAttributeField",
-    value: function getDefautStyleAttributeField(layer, type) {
+    key: "getDefaultStyleAttributeField",
+    value: function getDefaultStyleAttributeField(layer, type) {
       switch (type) {
         case 'size':
           return 1;
@@ -224,7 +226,7 @@ var TileFactory = /*#__PURE__*/function () {
         return;
       }
 
-      var defaultValue = this.getDefautStyleAttributeField(layer, type);
+      var defaultValue = this.getDefaultStyleAttributeField(layer, type);
 
       if (!value) {
         layer[type](defaultValue);

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

@@ -1,5 +1,5 @@
 import { IParserCfg } from '@antv/l7-core';
 import VectorLineTile from './line';
-export declare type TileType = 'PolygonLayer' | 'PointLayer' | 'LineLayer' | 'RasterLayer' | 'TileDebugLayer';
+export declare type TileType = 'PolygonLayer' | 'PointLayer' | 'LineLayer' | 'RasterLayer' | 'MaskLayer' | 'TileDebugLayer';
 export declare function getTileFactory(tileType: TileType, parser: IParserCfg): typeof VectorLineTile;
 export * from '../interface';

package/es/tile/tileFactory/index.js

@@ -2,6 +2,7 @@ import { rasterDataTypes } from '@antv/l7-source';
 import VectorLineTile from "./line";
 import VectorPointLayer from "./point";
 import VectorPolygonTile from "./polygon";
+import VectorMask from "./mask";
 import RasterTileFactory from "./raster";
 import RasterDataFactory from "./rasterData";
 import TestTile from "./test";
@@ -16,6 +17,9 @@ export function getTileFactory(tileType, parser) {
     case 'PointLayer':
       return VectorPointLayer;
 
+    case 'MaskLayer':
+      return VectorMask;
+
     case 'TileDebugLayer':
       return TestTile;
 

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

@@ -2,7 +2,7 @@ import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
 import { Tile } from '@antv/l7-utils';
 import { ITileFactoryOptions } from '../interface';
 import TileFactory from './base';
-export default class VectorPolygonTile extends TileFactory {
+export default class VectorLineTile extends TileFactory {
     parentLayer: ILayer;
     constructor(option: ITileFactoryOptions);
     createTile(tile: Tile, initOptions: ISubLayerInitOptions): {

package/es/tile/tileFactory/line.js

@@ -10,22 +10,22 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 import TileFactory from "./base";
 
-var VectorPolygonTile = /*#__PURE__*/function (_TileFactory) {
-  _inherits(VectorPolygonTile, _TileFactory);
+var VectorLineTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(VectorLineTile, _TileFactory);
 
-  var _super = _createSuper(VectorPolygonTile);
+  var _super = _createSuper(VectorLineTile);
 
-  function VectorPolygonTile(option) {
+  function VectorLineTile(option) {
     var _this;
 
-    _classCallCheck(this, VectorPolygonTile);
+    _classCallCheck(this, VectorLineTile);
 
     _this = _super.call(this, option);
     _this.parentLayer = option.parent;
     return _this;
   }
 
-  _createClass(VectorPolygonTile, [{
+  _createClass(VectorLineTile, [{
     key: "createTile",
     value: function createTile(tile, initOptions) {
       var _this$getFeatureData = this.getFeatureData(tile, initOptions),
@@ -56,7 +56,7 @@ var VectorPolygonTile = /*#__PURE__*/function (_TileFactory) {
     }
   }]);
 
-  return VectorPolygonTile;
+  return VectorLineTile;
 }(TileFactory);
 
-export { VectorPolygonTile as default };
+export { VectorLineTile as default };

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

@@ -0,0 +1,12 @@
+import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+import { ITileFactoryOptions } from '../interface';
+import TileFactory from './base';
+export default class VectorMaskTile extends TileFactory {
+    parentLayer: ILayer;
+    constructor(option: ITileFactoryOptions);
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: any[];
+        layerIDList: any[];
+    };
+}

package/es/tile/tileFactory/mask.js

@@ -0,0 +1,63 @@
+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 TileFactory from "./base";
+
+var VectorMaskTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(VectorMaskTile, _TileFactory);
+
+  var _super = _createSuper(VectorMaskTile);
+
+  function VectorMaskTile(option) {
+    var _this;
+
+    _classCallCheck(this, VectorMaskTile);
+
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  _createClass(VectorMaskTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var _this$getFeatureData = this.getFeatureData(tile, initOptions),
+          features = _this$getFeatureData.features,
+          vectorTileLayer = _this$getFeatureData.vectorTileLayer,
+          source = _this$getFeatureData.source;
+
+      if (features.length === 0) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var layer = this.createLayer({
+        tile: tile,
+        initOptions: initOptions,
+        vectorTileLayer: vectorTileLayer,
+        source: source,
+        needListen: false
+      });
+      layer.once('modelLoaded', function () {
+        tile.layerLoad();
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+
+  return VectorMaskTile;
+}(TileFactory);
+
+export { VectorMaskTile as default };

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

@@ -2,7 +2,7 @@ import { ILayer, ISubLayerInitOptions } from '@antv/l7-core';
 import { Tile } from '@antv/l7-utils';
 import { ITileFactoryOptions } from '../interface';
 import TileFactory from './base';
-export default class VectorPolygonTile extends TileFactory {
+export default class VectorPointTile extends TileFactory {
     parentLayer: ILayer;
     constructor(option: ITileFactoryOptions);
     createTile(tile: Tile, initOptions: ISubLayerInitOptions): {

package/es/tile/tileFactory/point.js

@@ -10,22 +10,22 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 import TileFactory from "./base";
 
-var VectorPolygonTile = /*#__PURE__*/function (_TileFactory) {
-  _inherits(VectorPolygonTile, _TileFactory);
+var VectorPointTile = /*#__PURE__*/function (_TileFactory) {
+  _inherits(VectorPointTile, _TileFactory);
 
-  var _super = _createSuper(VectorPolygonTile);
+  var _super = _createSuper(VectorPointTile);
 
-  function VectorPolygonTile(option) {
+  function VectorPointTile(option) {
     var _this;
 
-    _classCallCheck(this, VectorPolygonTile);
+    _classCallCheck(this, VectorPointTile);
 
     _this = _super.call(this, option);
     _this.parentLayer = option.parent;
     return _this;
   }
 
-  _createClass(VectorPolygonTile, [{
+  _createClass(VectorPointTile, [{
     key: "createTile",
     value: function createTile(tile, initOptions) {
       var _this$getFeatureData = this.getFeatureData(tile, initOptions),
@@ -57,7 +57,7 @@ var VectorPolygonTile = /*#__PURE__*/function (_TileFactory) {
     }
   }]);
 
-  return VectorPolygonTile;
+  return VectorPointTile;
 }(TileFactory);
 
-export { VectorPolygonTile as default };
+export { VectorPointTile as default };

package/es/tile/tileFactory/rasterData.js

@@ -30,6 +30,8 @@ var RasterTiffTile = /*#__PURE__*/function (_TileFactory) {
   _createClass(RasterTiffTile, [{
     key: "createTile",
     value: function createTile(tile, initOptions) {
+      var _this$parentLayer, _this$parentLayer$get, _this$parentLayer$get2;
+
       var colorTexture = initOptions.colorTexture,
           opacity = initOptions.opacity,
           domain = initOptions.domain,
@@ -46,12 +48,14 @@ var RasterTiffTile = /*#__PURE__*/function (_TileFactory) {
         };
       }
 
+      var dataType = (_this$parentLayer = this.parentLayer) === null || _this$parentLayer === void 0 ? void 0 : (_this$parentLayer$get = _this$parentLayer.getSource()) === null || _this$parentLayer$get === void 0 ? void 0 : (_this$parentLayer$get2 = _this$parentLayer$get.parser) === null || _this$parentLayer$get2 === void 0 ? void 0 : _this$parentLayer$get2.dataType;
       var layer = new RasterDataLayer({
         visible: tile.isVisible,
         mask: mask
       }).source(rasterData.data, {
         parser: {
-          type: 'raster',
+          // 数据栅格分为单通道栅格和多通道彩色栅格
+          type: dataType === 'rgb' ? 'rasterRgb' : 'raster',
           width: rasterData.width,
           height: rasterData.height,
           extent: tile.bboxPolygon.bbox
@@ -59,6 +63,7 @@ var RasterTiffTile = /*#__PURE__*/function (_TileFactory) {
       }).style({
         colorTexture: colorTexture,
         opacity: opacity,
+        // TODO: 目前从 domain 从父瓦片图层的 style 进行配置，后续考虑从每个时机请求的栅格文件中进行配置
         domain: domain,
         clampHigh: clampHigh,
         clampLow: clampLow

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

@@ -1,11 +1,12 @@
 import BaseLayer from '../../core/BaseLayer';
 import { IRasterLayerStyleOptions } from '../../core/interface';
 import RasterModel from '../../raster/models/rasterTile';
+import RasterRgbModel from '../../raster/models/rasterRgb';
 export default class RasterTiffLayer extends BaseLayer<Partial<IRasterLayerStyleOptions>> {
     type: string;
     buildModels(): void;
     rebuildModels(): void;
-    protected getModelType(): typeof RasterModel;
+    protected getModelType(): typeof RasterModel | typeof RasterRgbModel;
     protected getConfigSchema(): {
         properties: {
             opacity: {

package/es/tile/tileFactory/rasterDataLayer.js

@@ -12,6 +12,7 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 import BaseLayer from "../../core/BaseLayer";
 import RasterModel from "../../raster/models/rasterTile";
+import RasterRgbModel from "../../raster/models/rasterRgb";
 
 var RasterTiffLayer = /*#__PURE__*/function (_BaseLayer) {
   _inherits(RasterTiffLayer, _BaseLayer);
@@ -57,7 +58,11 @@ var RasterTiffLayer = /*#__PURE__*/function (_BaseLayer) {
   }, {
     key: "getModelType",
     value: function getModelType() {
-      return RasterModel;
+      if (this.layerSource.parser.type === 'rasterRgb') {
+        return RasterRgbModel;
+      } else {
+        return RasterModel;
+      }
     }
   }, {
     key: "getConfigSchema",

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

@@ -1,11 +1,13 @@
 import BaseLayer from '../../core/BaseLayer';
-import { ILineLayerStyleOptions, IPointLayerStyleOptions, IPolygonLayerStyleOptions } from '../../core/interface';
+import { ILineLayerStyleOptions, IPointLayerStyleOptions, IPolygonLayerStyleOptions, IMaskLayerStyleOptions } from '../../core/interface';
 import lineFillModel from '../../line/models/tile';
 import lineSimpleModel from '../../line/models/simpleTileLine';
 import pointTextModel from '../../point/models/tileText';
 import pointFillModel from '../../point/models/tile';
 import polygonFillModel from '../../polygon/models/tile';
-export default class VectorLayer extends BaseLayer<Partial<IPolygonLayerStyleOptions & ILineLayerStyleOptions & IPointLayerStyleOptions & {
+import maskModel from '../../mask/models/fill';
+declare type ILayerStyleOptions = IPolygonLayerStyleOptions & ILineLayerStyleOptions & IPointLayerStyleOptions & IMaskLayerStyleOptions;
+export default class VectorLayer extends BaseLayer<Partial<ILayerStyleOptions & {
     needListen: boolean;
 }>> {
     needListen: boolean;
@@ -19,7 +21,7 @@ export default class VectorLayer extends BaseLayer<Partial<IPolygonLayerStyleOpt
     setPickID(): number | null;
     buildModels(): void;
     rebuildModels(): void;
-    protected getModelType(): typeof lineFillModel | typeof lineSimpleModel | typeof pointTextModel | typeof pointFillModel | typeof polygonFillModel;
+    protected getModelType(): typeof lineFillModel | typeof lineSimpleModel | typeof pointTextModel | typeof pointFillModel | typeof polygonFillModel | typeof maskModel;
     protected getLineModel(): typeof lineFillModel | typeof lineSimpleModel;
     protected getPointModel(): typeof pointTextModel | typeof pointFillModel;
     protected getConfigSchema(): {
@@ -33,3 +35,4 @@ export default class VectorLayer extends BaseLayer<Partial<IPolygonLayerStyleOpt
     };
     protected getDefaultConfig(): {};
 }
+export {};

package/es/tile/tileFactory/vectorLayer.js

@@ -24,6 +24,7 @@ import lineSimpleModel from "../../line/models/simpleTileLine";
 import pointTextModel from "../../point/models/tileText";
 import pointFillModel from "../../point/models/tile";
 import polygonFillModel from "../../polygon/models/tile";
+import maskModel from "../../mask/models/fill";
 
 var VectorLayer = /*#__PURE__*/function (_BaseLayer) {
   _inherits(VectorLayer, _BaseLayer);
@@ -186,6 +187,9 @@ var VectorLayer = /*#__PURE__*/function (_BaseLayer) {
         case 'PointLayer':
           return this.getPointModel();
 
+        case 'MaskLayer':
+          return maskModel;
+
         default:
           return pointFillModel;
       }