@antv/l7-layers 2.9.32 → 2.9.33

package/es/core/BaseLayer.d.ts

@@ -6,6 +6,7 @@ import { Container } from 'inversify';
 export default class BaseLayer<ChildLayerStyleOptions = {}> extends EventEmitter<LayerEventType> implements ILayer {
     id: string;
     name: string;
+    coordCenter: number[];
     type: string;
     visible: boolean;
     zIndex: number;

package/es/core/BaseLayer.js

@@ -500,7 +500,7 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
   }, {
     key: "source",
     value: function source(data, options) {
-      if (data !== null && data !== void 0 && data.data) {
+      if ((data === null || data === void 0 ? void 0 : data.type) === 'source') {
         // 判断是否为source
         this.setSource(data);
         return this;
@@ -1045,6 +1045,15 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
 
 
       this.layerSource.on('sourceUpdate', function () {
+        if (_this8.coordCenter === undefined) {
+          var layerCenter = _this8.layerSource.center;
+          _this8.coordCenter = layerCenter;
+          _this8.mapService.setCoordCenter && _this8.mapService.setCoordCenter(layerCenter); // // @ts-ignore
+          // this.mapService.map.customCoords.setCenter(layerCenter);
+          // // @ts-ignore
+          // this.mapService.setCustomCoordCenter(layerCenter);
+        }
+
         _this8.sourceEvent();
       });
     }
@@ -1176,6 +1185,8 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
               return reject(err);
             });
           } else {
+            // console.log(this.encodedData[1].originCoordinates[0])
+            // console.log(this.encodedData[1].coordinates[0])
             var _this9$styleAttribute = _this9.styleAttributeService.createAttributesAndIndices(_this9.encodedData, triangulation, segmentNumber),
                 attributes = _this9$styleAttribute.attributes,
                 elements = _this9$styleAttribute.elements,

package/es/core/interface.d.ts

@@ -217,5 +217,8 @@ export interface IRasterLayerStyleOptions extends IBaseLayerStyleOptions {
     clampHigh: boolean;
     rampColors: IColorRamp;
     rampColorsData?: ImageData | IImagedata;
+    channelRMax?: number;
+    channelGMax?: number;
+    channelBMax?: number;
 }
 export {};

package/es/plugins/DataMappingPlugin.d.ts

@@ -11,7 +11,6 @@ export default class DataMappingPlugin implements ILayerPlugin {
     private mapLayerMapping;
     private adjustData2Amap2Coordinates;
     private adjustData2SimpleCoordinates;
-    private getLayerCenter;
     private unProjectCoordinates;
     private applyAttributeMapping;
     private applyMapLayerAttributeMapping;

package/es/plugins/DataMappingPlugin.js

@@ -254,7 +254,7 @@ var DataMappingPlugin = (_dec = injectable(), _dec2 = inject(TYPES.IMapService),
 
       // 根据地图的类型判断是否需要对点位数据进行处理, 若是高德2.0则需要对坐标进行相对偏移
       if (mappedData.length > 0 && this.mapService.version === Version['GAODE2.x']) {
-        var layerCenter = this.getLayerCenter(layer);
+        var layerCenter = layer.coordCenter;
 
         if (typeof mappedData[0].coordinates[0] === 'number') {
           // 单个的点数据
@@ -273,7 +273,6 @@ var DataMappingPlugin = (_dec = injectable(), _dec2 = inject(TYPES.IMapService),
           });
         } else {
           // 连续的线、面数据
-          // @ts-ignore
           mappedData // TODO: 避免经纬度被重复计算导致坐标位置偏移
           .filter(function (d) {
             return !d.originCoordinates;
@@ -303,12 +302,6 @@ var DataMappingPlugin = (_dec = injectable(), _dec2 = inject(TYPES.IMapService),
         });
       }
     }
-  }, {
-    key: "getLayerCenter",
-    value: function getLayerCenter(layer) {
-      var source = layer.getSource();
-      return source.center;
-    }
   }, {
     key: "unProjectCoordinates",
     value: function unProjectCoordinates(coordinates) {

package/es/plugins/ShaderUniformPlugin.js

@@ -48,15 +48,7 @@ var ShaderUniformPlugin = (_dec = injectable(), _dec2 = inject(TYPES.ICameraServ
         _this.coordinateSystemService.refresh(offset);
 
         if (version === 'GAODE2.x') {
-          var layerCenter = _this.getLayerCenter(layer); // @ts-ignore
-
-
-          _this.mapService.map.customCoords.setCenter(layerCenter); // @ts-ignore
-
-
-          _this.mapService.setCustomCoordCenter(layerCenter); // @ts-ignore
-
-
+          // @ts-ignore
           mvp = _this.mapService.map.customCoords.getMVPMatrix(); // mvp = amapCustomCoords.getMVPMatrix()
           // @ts-ignore
 

package/es/raster/index.d.ts

@@ -14,6 +14,6 @@ export default class RaterLayer extends BaseLayer<IRasterLayerStyleOptions> {
             };
         };
     };
-    protected getDefaultConfig(): {} | {} | {};
+    protected getDefaultConfig(): {} | {} | {} | {};
     protected getModelType(): RasterModelType;
 }

package/es/raster/index.js

@@ -73,6 +73,7 @@ var RaterLayer = /*#__PURE__*/function (_BaseLayer) {
       var type = this.getModelType();
       var defaultConfig = {
         raster: {},
+        rasterRgb: {},
         raster3d: {},
         rasterTile: {}
       };
@@ -88,6 +89,9 @@ var RaterLayer = /*#__PURE__*/function (_BaseLayer) {
         case 'raster':
           return 'raster';
 
+        case 'rasterRgb':
+          return 'rasterRgb';
+
         case 'rasterTile':
           return 'rasterTile';
 

package/es/raster/models/index.d.ts

@@ -1,4 +1,4 @@
-export declare type RasterModelType = 'raster' | 'raster3d' | 'rasterTile';
+export declare type RasterModelType = 'raster' | 'raster3d' | 'rasterTile' | 'rasterRgb';
 declare const RasterModels: {
     [key in RasterModelType]: any;
 };

package/es/raster/models/index.js

@@ -1,7 +1,9 @@
 import RasterTileModel from "../../tile/models/tileModel";
 import RasterModel from "./raster";
+import RasterRgbModel from "./rasterRgb";
 var RasterModels = {
   raster: RasterModel,
+  rasterRgb: RasterRgbModel,
   raster3d: RasterModel,
   rasterTile: RasterTileModel
 };

package/es/raster/models/raster.d.ts

@@ -13,7 +13,8 @@ export default class RasterModel extends BaseModel {
         u_noDataValue: number;
         u_colorTexture: ITexture2D;
     };
-    initModels(callbackModel: (models: IModel[]) => void): void;
+    private getRasterData;
+    initModels(callbackModel: (models: IModel[]) => void): Promise<void>;
     buildModels(callbackModel: (models: IModel[]) => void): void;
     clearModels(): void;
     protected registerBuiltinAttributes(): void;

package/es/raster/models/raster.js

@@ -1,8 +1,10 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 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";
+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); }; }
 
@@ -62,53 +64,125 @@ var RasterModel = /*#__PURE__*/function (_BaseModel) {
         u_colorTexture: this.colorTexture
       };
     }
+  }, {
+    key: "getRasterData",
+    value: function () {
+      var _getRasterData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(parserDataItem) {
+        var _yield$parserDataItem, rasterData, width, height;
+
+        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;
+                return _context.abrupt("return", {
+                  data: Array.from(rasterData),
+                  width: width,
+                  height: height
+                });
+
+              case 11:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function getRasterData(_x) {
+        return _getRasterData.apply(this, arguments);
+      }
+
+      return getRasterData;
+    }()
   }, {
     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,
-          rampColorsData = _ref2.rampColorsData,
-          rampColors = _ref2.rampColors;
-
-      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: gl.LUMINANCE,
-        type: gl.FLOAT // aniso: 4,
+    value: function () {
+      var _initModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(callbackModel) {
+        var _ref2, _ref2$mask, mask, _ref2$maskInside, maskInside, rampColorsData, rampColors, source, createTexture2D, parserDataItem, _yield$this$getRaster, data, width, height, imageData;
+
+        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, rampColorsData = _ref2.rampColorsData, rampColors = _ref2.rampColors;
+                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({
+                  data: data,
+                  width: width,
+                  height: height,
+                  format: gl.LUMINANCE,
+                  type: gl.FLOAT // aniso: 4,
+
+                });
+                imageData = rampColorsData ? rampColorsData : generateColorRamp(rampColors);
+                this.colorTexture = createTexture2D({
+                  data: imageData.data,
+                  width: imageData.width,
+                  height: imageData.height,
+                  flipY: false
+                });
+                this.layer.buildLayerModel({
+                  moduleName: 'rasterImageData',
+                  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 14:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-      });
-      var imageData = rampColorsData ? rampColorsData : generateColorRamp(rampColors);
-      this.colorTexture = createTexture2D({
-        data: imageData.data,
-        width: imageData.width,
-        height: imageData.height,
-        flipY: false
-      });
-      this.layer.buildLayerModel({
-        moduleName: 'rasterImageData',
-        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([]);
-      });
-    }
+      function initModels(_x2) {
+        return _initModels.apply(this, arguments);
+      }
+
+      return initModels;
+    }()
   }, {
     key: "buildModels",
     value: function buildModels(callbackModel) {

package/es/raster/models/rasterRgb.d.ts

@@ -0,0 +1,20 @@
+import { IModel, ITexture2D } from '@antv/l7-core';
+import BaseModel from '../../core/BaseModel';
+export default class RasterModel extends BaseModel {
+    protected texture: ITexture2D;
+    protected channelRMax: number;
+    protected channelGMax: number;
+    protected channelBMax: number;
+    getUninforms(): {
+        u_opacity: number;
+        u_texture: ITexture2D;
+        u_channelRMax: number;
+        u_channelGMax: number;
+        u_channelBMax: number;
+    };
+    private getRasterData;
+    initModels(callbackModel: (models: IModel[]) => void): Promise<void>;
+    buildModels(callbackModel: (models: IModel[]) => void): void;
+    clearModels(): void;
+    protected registerBuiltinAttributes(): void;
+}

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/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: {