@antv/l7-layers 2.21.0 → 2.21.2

package/es/core/BaseModel.js

@@ -1,18 +1,14 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { BlendType, MaskOperation, StencilType } from '@antv/l7-core';
 import { rgb2arr } from '@antv/l7-utils';
 import { BlendTypes } from "../utils/blend";
-import { getStencil as _getStencil, getStencilMask } from "../utils/stencil";
+import { getStencil, getStencilMask } from "../utils/stencil";
 import { getCommonStyleAttributeOptions, ShaderLocation } from "./CommonStyleAttribute";
 import { DefaultUniformStyleType, DefaultUniformStyleValue } from "./constant";
 import { MultipleOfFourNumber } from "./utils";
-var shaderLocationMap = {
+const shaderLocationMap = {
   opacity: ShaderLocation.OPACITY,
   stroke: ShaderLocation.STROKE,
   offsets: ShaderLocation.OFFSETS,
@@ -22,21 +18,38 @@ var shaderLocationMap = {
 };
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-var BaseModel = /*#__PURE__*/function () {
-  // 用于数据传递的数据纹理
-  // 默认有多少列（宽度）
-
-  // 支持数据映射的buffer
+export default class BaseModel {
   // 不支持数据映射的buffer
 
   // style texture data mapping
 
-  function BaseModel(layer) {
-    _classCallCheck(this, BaseModel);
+  constructor(layer) {
+    _defineProperty(this, "triangulation", void 0);
     _defineProperty(this, "uniformBuffers", []);
     _defineProperty(this, "textures", []);
+    // style texture data mapping
+    _defineProperty(this, "createTexture2D", void 0);
     _defineProperty(this, "preStyleAttribute", {});
     _defineProperty(this, "encodeStyleAttribute", {});
+    _defineProperty(this, "layer", void 0);
+    _defineProperty(this, "dataTexture", void 0);
+    // 用于数据传递的数据纹理
+    _defineProperty(this, "DATA_TEXTURE_WIDTH", void 0);
+    // 默认有多少列（宽度）
+    _defineProperty(this, "dataTextureTest", void 0);
+    _defineProperty(this, "configService", void 0);
+    _defineProperty(this, "shaderModuleService", void 0);
+    _defineProperty(this, "rendererService", void 0);
+    _defineProperty(this, "iconService", void 0);
+    _defineProperty(this, "fontService", void 0);
+    _defineProperty(this, "styleAttributeService", void 0);
+    _defineProperty(this, "mapService", void 0);
+    _defineProperty(this, "cameraService", void 0);
+    _defineProperty(this, "layerService", void 0);
+    _defineProperty(this, "pickingService", void 0);
+    _defineProperty(this, "attributeUnifoms", void 0);
+    // 支持数据映射的buffer
+    _defineProperty(this, "commonUnifoms", void 0);
     this.layer = layer;
     this.configService = layer.getContainer().globalConfigService;
     this.rendererService = layer.getContainer().rendererService;
@@ -55,329 +68,260 @@ var BaseModel = /*#__PURE__*/function () {
     this.registerBuiltinAttributes();
     // 开启动画
     this.startModelAnimate();
-    var createTexture2D = this.rendererService.createTexture2D;
+    const {
+      createTexture2D
+    } = this.rendererService;
     this.createTexture2D = createTexture2D;
   }
 
   // style datatexture mapping
-  _createClass(BaseModel, [{
-    key: "getBlend",
-    value: function getBlend() {
-      var _this$layer$getLayerC = this.layer.getLayerConfig(),
-        _this$layer$getLayerC2 = _this$layer$getLayerC.blend,
-        blend = _this$layer$getLayerC2 === void 0 ? 'normal' : _this$layer$getLayerC2;
-      return BlendTypes[BlendType[blend]];
-    }
-  }, {
-    key: "getStencil",
-    value: function getStencil(option) {
-      var _this$layer$getLayerC3 = this.layer.getLayerConfig(),
-        _this$layer$getLayerC4 = _this$layer$getLayerC3.mask,
-        mask = _this$layer$getLayerC4 === void 0 ? false : _this$layer$getLayerC4,
-        _this$layer$getLayerC5 = _this$layer$getLayerC3.maskInside,
-        maskInside = _this$layer$getLayerC5 === void 0 ? true : _this$layer$getLayerC5,
-        enableMask = _this$layer$getLayerC3.enableMask,
-        _this$layer$getLayerC6 = _this$layer$getLayerC3.maskOperation,
-        maskOperation = _this$layer$getLayerC6 === void 0 ? MaskOperation.AND : _this$layer$getLayerC6;
-      // TODO 临时处理，后期移除MaskLayer
-      if (this.layer.type === 'MaskLayer') {
-        return getStencilMask({
-          isStencil: true,
-          stencilType: StencilType.SINGLE
-        }); // 用于遮罩的stencil 参数
-      }
-
-      if (option.isStencil) {
-        return getStencilMask(_objectSpread(_objectSpread({}, option), {}, {
-          maskOperation: maskOperation
-        })); // 用于遮罩的stencil 参数
-      }
 
-      var maskflag = mask ||
-      //  mask 兼容历史写法
-      enableMask && this.layer.masks.length !== 0 ||
-      // 外部图层的mask
-      this.layer.tileMask !== undefined; // 瓦片图层
-      // !!(mask || enableMask || this.layer.tileMask);
-      return _getStencil(maskflag, maskInside);
-    }
-  }, {
-    key: "getDefaultStyle",
-    value: function getDefaultStyle() {
-      return {};
-    }
-    // public getUninforms(): IModelUniform {
-    //   throw new Error('Method not implemented.');
-    // }
-  }, {
-    key: "getUninforms",
-    value: function getUninforms() {
-      var commoninfo = this.getCommonUniformsInfo();
-      var attributeInfo = this.getUniformsBufferInfo(this.getStyleAttribute());
-      this.updateStyleUnifoms();
-      var result = _objectSpread(_objectSpread({}, attributeInfo.uniformsOption), commoninfo.uniformsOption);
-      //如果是regl渲染 需要在uniform中带上u_texture 暂时用this.rendererService.device判断
-      if (!this.rendererService.hasOwnProperty('device') && this.textures && this.textures.length === 1) {
-        result['u_texture'] = this.textures[0];
-      }
-      return result;
-    }
-  }, {
-    key: "getAnimateUniforms",
-    value: function getAnimateUniforms() {
-      return {};
+  getBlend() {
+    const {
+      blend = 'normal'
+    } = this.layer.getLayerConfig();
+    return BlendTypes[BlendType[blend]];
+  }
+  getStencil(option) {
+    const {
+      mask = false,
+      maskInside = true,
+      enableMask,
+      maskOperation = MaskOperation.AND
+    } = this.layer.getLayerConfig();
+    // TODO 临时处理，后期移除MaskLayer
+    if (this.layer.type === 'MaskLayer') {
+      return getStencilMask({
+        isStencil: true,
+        stencilType: StencilType.SINGLE
+      }); // 用于遮罩的stencil 参数
     }
-  }, {
-    key: "needUpdate",
-    value: function () {
-      var _needUpdate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              return _context.abrupt("return", false);
-            case 1:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee);
-      }));
-      function needUpdate() {
-        return _needUpdate.apply(this, arguments);
-      }
-      return needUpdate;
-    }() // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "buildModels",
-    value: function () {
-      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              throw new Error('Method not implemented.');
-            case 1:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2);
-      }));
-      function buildModels() {
-        return _buildModels.apply(this, arguments);
-      }
-      return buildModels;
-    }() // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "initModels",
-    value: function () {
-      var _initModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              throw new Error('Method not implemented.');
-            case 1:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3);
-      }));
-      function initModels() {
-        return _initModels.apply(this, arguments);
-      }
-      return initModels;
-    }() // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "clearModels",
-    value: function clearModels() {
-      var refresh = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      return;
+    if (option.isStencil) {
+      return getStencilMask(_objectSpread(_objectSpread({}, option), {}, {
+        maskOperation
+      })); // 用于遮罩的stencil 参数
     }
-  }, {
-    key: "getAttribute",
-    value: function getAttribute() {
-      throw new Error('Method not implemented.');
+    const maskflag = mask ||
+    //  mask 兼容历史写法
+    enableMask && this.layer.masks.length !== 0 ||
+    // 外部图层的mask
+    this.layer.tileMask !== undefined; // 瓦片图层
+    // !!(mask || enableMask || this.layer.tileMask);
+    return getStencil(maskflag, maskInside);
+  }
+  getDefaultStyle() {
+    return {};
+  }
+  // public getUninforms(): IModelUniform {
+  //   throw new Error('Method not implemented.');
+  // }
+  getUninforms() {
+    const commoninfo = this.getCommonUniformsInfo();
+    const attributeInfo = this.getUniformsBufferInfo(this.getStyleAttribute());
+    this.updateStyleUnifoms();
+    const result = _objectSpread(_objectSpread({}, attributeInfo.uniformsOption), commoninfo.uniformsOption);
+    //如果是regl渲染 需要在uniform中带上u_texture 暂时用this.rendererService.device判断
+    if (!this.rendererService.hasOwnProperty('device') && this.textures && this.textures.length === 1) {
+      result['u_texture'] = this.textures[0];
     }
-  }, {
-    key: "prerender",
-    value: function prerender() {}
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "render",
-    value: function render(renderOptions) {
+    return result;
+  }
+  getAnimateUniforms() {
+    return {};
+  }
+  needUpdate() {
+    return _asyncToGenerator(function* () {
+      return false;
+    })();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  buildModels() {
+    return _asyncToGenerator(function* () {
       throw new Error('Method not implemented.');
-    }
-  }, {
-    key: "registerBuiltinAttributes",
-    value: function registerBuiltinAttributes() {
+    })();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  initModels() {
+    return _asyncToGenerator(function* () {
       throw new Error('Method not implemented.');
+    })();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  clearModels(refresh = true) {
+    return;
+  }
+  getAttribute() {
+    throw new Error('Method not implemented.');
+  }
+  prerender() {}
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  render(renderOptions) {
+    throw new Error('Method not implemented.');
+  }
+  registerBuiltinAttributes() {
+    throw new Error('Method not implemented.');
+  }
+  animateOption2Array(option) {
+    return [option.enable ? 0 : 1.0, option.duration || 4.0, option.interval || 0.2, option.trailLength || 0.1];
+  }
+  startModelAnimate() {
+    const {
+      animateOption
+    } = this.layer.getLayerConfig();
+    if (animateOption.enable) {
+      this.layer.setAnimateStartTime();
     }
-  }, {
-    key: "animateOption2Array",
-    value: function animateOption2Array(option) {
-      return [option.enable ? 0 : 1.0, option.duration || 4.0, option.interval || 0.2, option.trailLength || 0.1];
-    }
-  }, {
-    key: "startModelAnimate",
-    value: function startModelAnimate() {
-      var _ref = this.layer.getLayerConfig(),
-        animateOption = _ref.animateOption;
-      if (animateOption.enable) {
-        this.layer.setAnimateStartTime();
-      }
-    }
+  }
 
-    // 动态注入参与数据映射的uniform
-  }, {
-    key: "getInject",
-    value: function getInject() {
-      var encodeStyleAttribute = this.layer.encodeStyleAttribute;
-      var str = '';
-      // a_Position = 0
-      // a_Color = 1
-      // a_PickingColor = 2
+  // 动态注入参与数据映射的uniform
+  getInject() {
+    const encodeStyleAttribute = this.layer.encodeStyleAttribute;
+    let str = '';
+    // a_Position = 0
+    // a_Color = 1
+    // a_PickingColor = 2
 
-      var uniforms = [];
-      // 支持数据映射的类型
-      this.layer.enableShaderEncodeStyles.forEach(function (key) {
-        if (encodeStyleAttribute[key]) {
-          // 配置了数据映射的类型
-          str += "#define USE_ATTRIBUTE_".concat(key.toUpperCase(), " 0.0; \n\n");
-        } else {
-          uniforms.push("  ".concat(DefaultUniformStyleType[key], " u_").concat(key, ";"));
-        }
-        var location = shaderLocationMap[key];
-        if (!location && key === 'THETA_OFFSET') {
-          location = 15;
-        }
-        str += "\n          #ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n          layout(location = ").concat(shaderLocationMap[key], ") in ").concat(DefaultUniformStyleType[key], " a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n        #endif\n\n        ");
-      });
-      var attributeUniforms = uniforms.length ? "\nlayout(std140) uniform AttributeUniforms {\n".concat(uniforms.join('\n'), "\n};\n    ") : '';
-      str += attributeUniforms;
-      var innerStr = '';
-      this.layer.enableShaderEncodeStyles.forEach(function (key) {
-        innerStr += "\n\n    #ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n      ").concat(DefaultUniformStyleType[key], " ").concat(key, "  = a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n    #else\n      ").concat(DefaultUniformStyleType[key], " ").concat(key, " = u_").concat(key, ";\n    #endif\n\n    ");
-      });
-      return {
-        'vs:#decl': str,
-        'fs:#decl': attributeUniforms,
-        'vs:#main-start': innerStr
-      };
-    }
+    const uniforms = [];
+    // 支持数据映射的类型
+    this.layer.enableShaderEncodeStyles.forEach(key => {
+      if (encodeStyleAttribute[key]) {
+        // 配置了数据映射的类型
+        str += `#define USE_ATTRIBUTE_${key.toUpperCase()} 0.0; \n\n`;
+      } else {
+        uniforms.push(`  ${DefaultUniformStyleType[key]} u_${key};`);
+      }
+      let location = shaderLocationMap[key];
+      if (!location && key === 'THETA_OFFSET') {
+        location = 15;
+      }
+      str += `
+          #ifdef USE_ATTRIBUTE_${key.toUpperCase()}
+          layout(location = ${shaderLocationMap[key]}) in ${DefaultUniformStyleType[key]} a_${key.charAt(0).toUpperCase() + key.slice(1)};
+        #endif\n
+        `;
+    });
+    const attributeUniforms = uniforms.length ? `
+layout(std140) uniform AttributeUniforms {
+${uniforms.join('\n')}
+};
+    ` : '';
+    str += attributeUniforms;
+    let innerStr = '';
+    this.layer.enableShaderEncodeStyles.forEach(key => {
+      innerStr += `\n
+    #ifdef USE_ATTRIBUTE_${key.toUpperCase()}
+      ${DefaultUniformStyleType[key]} ${key}  = a_${key.charAt(0).toUpperCase() + key.slice(1)};
+    #else
+      ${DefaultUniformStyleType[key]} ${key} = u_${key};
+    #endif\n
+    `;
+    });
+    return {
+      'vs:#decl': str,
+      'fs:#decl': attributeUniforms,
+      'vs:#main-start': innerStr
+    };
+  }
 
-    // 获取数据映射样式
-  }, {
-    key: "getStyleAttribute",
-    value: function getStyleAttribute() {
-      var _this = this;
-      var options = {};
-      // TODO: 优化
-      this.layer.enableShaderEncodeStyles.forEach(function (key) {
-        if (!_this.layer.encodeStyleAttribute[key]) {
-          // 没有设置样式映射
-          // @ts-ignore
-          var keyValue = _this.layer.getLayerConfig()[key];
-          var value = typeof keyValue === 'undefined' ? DefaultUniformStyleValue[key] : keyValue;
-          if (key === 'stroke') {
-            value = rgb2arr(value);
-          }
-          options['u_' + key] = value;
-        }
-      });
-      return options;
-    }
-    // 注册数据映射样式
-  }, {
-    key: "registerStyleAttribute",
-    value: function registerStyleAttribute() {
-      var _this2 = this;
-      Object.keys(this.layer.encodeStyleAttribute).forEach(function (key) {
-        var options = getCommonStyleAttributeOptions(key);
-        if (options) {
-          _this2.styleAttributeService.registerStyleAttribute(options);
-          if (options.descriptor) {
-            options.descriptor.shaderLocation = shaderLocationMap[key];
-          }
+  // 获取数据映射样式
+  getStyleAttribute() {
+    const options = {};
+    // TODO: 优化
+    this.layer.enableShaderEncodeStyles.forEach(key => {
+      if (!this.layer.encodeStyleAttribute[key]) {
+        // 没有设置样式映射
+        // @ts-ignore
+        const keyValue = this.layer.getLayerConfig()[key];
+        let value = typeof keyValue === 'undefined' ? DefaultUniformStyleValue[key] : keyValue;
+        if (key === 'stroke') {
+          value = rgb2arr(value);
         }
-      });
-    }
-  }, {
-    key: "updateEncodeAttribute",
-    value: function updateEncodeAttribute(type, flag) {
-      this.encodeStyleAttribute[type] = flag;
-    }
-  }, {
-    key: "initUniformsBuffer",
-    value: function initUniformsBuffer() {
-      var attrUniforms = this.getUniformsBufferInfo(this.getStyleAttribute());
-      var commonUniforms = this.getCommonUniformsInfo();
-      if (attrUniforms.uniformsLength !== 0) {
-        this.attributeUnifoms = this.rendererService.createBuffer({
-          data: new Float32Array(MultipleOfFourNumber(attrUniforms.uniformsLength)).fill(0),
-          // 长度需要大于等于 4
-          isUBO: true
-        });
-        this.uniformBuffers.push(this.attributeUnifoms);
+        options['u_' + key] = value;
       }
-      if (commonUniforms.uniformsLength !== 0) {
-        this.commonUnifoms = this.rendererService.createBuffer({
-          data: new Float32Array(MultipleOfFourNumber(commonUniforms.uniformsLength)).fill(0),
-          isUBO: true
-        });
-        this.uniformBuffers.push(this.commonUnifoms);
-      }
-    }
-    // 获取数据映射 uniform 信息
-  }, {
-    key: "getUniformsBufferInfo",
-    value: function getUniformsBufferInfo(uniformsOption) {
-      var uniformsLength = 0;
-      var uniformsArray = [];
-      Object.values(uniformsOption).forEach(function (value) {
-        if (Array.isArray(value)) {
-          uniformsArray.push.apply(uniformsArray, _toConsumableArray(value));
-          uniformsLength += value.length;
-        } else if (typeof value === 'number') {
-          // 排除纹理
-          uniformsArray.push(value);
-          uniformsLength += 1;
-        } else if (typeof value === 'boolean') {
-          uniformsArray.push(Number(value));
-          uniformsLength += 1;
+    });
+    return options;
+  }
+  // 注册数据映射样式
+  registerStyleAttribute() {
+    Object.keys(this.layer.encodeStyleAttribute).forEach(key => {
+      const options = getCommonStyleAttributeOptions(key);
+      if (options) {
+        this.styleAttributeService.registerStyleAttribute(options);
+        if (options.descriptor) {
+          options.descriptor.shaderLocation = shaderLocationMap[key];
         }
+      }
+    });
+  }
+  updateEncodeAttribute(type, flag) {
+    this.encodeStyleAttribute[type] = flag;
+  }
+  initUniformsBuffer() {
+    const attrUniforms = this.getUniformsBufferInfo(this.getStyleAttribute());
+    const commonUniforms = this.getCommonUniformsInfo();
+    if (attrUniforms.uniformsLength !== 0) {
+      this.attributeUnifoms = this.rendererService.createBuffer({
+        data: new Float32Array(MultipleOfFourNumber(attrUniforms.uniformsLength)).fill(0),
+        // 长度需要大于等于 4
+        isUBO: true
       });
-      return {
-        uniformsOption: uniformsOption,
-        uniformsLength: uniformsLength,
-        uniformsArray: uniformsArray
-      };
+      this.uniformBuffers.push(this.attributeUnifoms);
     }
-  }, {
-    key: "getCommonUniformsInfo",
-    value: function getCommonUniformsInfo() {
-      return {
-        uniformsLength: 0,
-        uniformsArray: [],
-        uniformsOption: {}
-      };
-    }
-
-    // 更新支持数据映射的uniform
-  }, {
-    key: "updateStyleUnifoms",
-    value: function updateStyleUnifoms() {
-      var _this$attributeUnifom, _this$commonUnifoms;
-      var _this$getUniformsBuff = this.getUniformsBufferInfo(this.getStyleAttribute()),
-        uniformsArray = _this$getUniformsBuff.uniformsArray;
-      var _this$getCommonUnifor = this.getCommonUniformsInfo(),
-        commonUniformsArray = _this$getCommonUnifor.uniformsArray;
-      (_this$attributeUnifom = this.attributeUnifoms) === null || _this$attributeUnifom === void 0 || _this$attributeUnifom.subData({
-        offset: 0,
-        data: new Uint8Array(new Float32Array(uniformsArray).buffer)
-      });
-      (_this$commonUnifoms = this.commonUnifoms) === null || _this$commonUnifoms === void 0 || _this$commonUnifoms.subData({
-        offset: 0,
-        data: new Uint8Array(new Float32Array(commonUniformsArray).buffer)
+    if (commonUniforms.uniformsLength !== 0) {
+      this.commonUnifoms = this.rendererService.createBuffer({
+        data: new Float32Array(MultipleOfFourNumber(commonUniforms.uniformsLength)).fill(0),
+        isUBO: true
       });
+      this.uniformBuffers.push(this.commonUnifoms);
     }
-  }]);
-  return BaseModel;
-}();
-export { BaseModel as default };
+  }
+  // 获取数据映射 uniform 信息
+  getUniformsBufferInfo(uniformsOption) {
+    let uniformsLength = 0;
+    const uniformsArray = [];
+    Object.values(uniformsOption).forEach(value => {
+      if (Array.isArray(value)) {
+        uniformsArray.push(...value);
+        uniformsLength += value.length;
+      } else if (typeof value === 'number') {
+        // 排除纹理
+        uniformsArray.push(value);
+        uniformsLength += 1;
+      } else if (typeof value === 'boolean') {
+        uniformsArray.push(Number(value));
+        uniformsLength += 1;
+      }
+    });
+    return {
+      uniformsOption,
+      uniformsLength,
+      uniformsArray
+    };
+  }
+  getCommonUniformsInfo() {
+    return {
+      uniformsLength: 0,
+      uniformsArray: [],
+      uniformsOption: {}
+    };
+  }
+
+  // 更新支持数据映射的uniform
+  updateStyleUnifoms() {
+    var _this$attributeUnifom, _this$commonUnifoms;
+    const {
+      uniformsArray
+    } = this.getUniformsBufferInfo(this.getStyleAttribute());
+    const {
+      uniformsArray: commonUniformsArray
+    } = this.getCommonUniformsInfo();
+    (_this$attributeUnifom = this.attributeUnifoms) === null || _this$attributeUnifom === void 0 || _this$attributeUnifom.subData({
+      offset: 0,
+      data: new Uint8Array(new Float32Array(uniformsArray).buffer)
+    });
+    (_this$commonUnifoms = this.commonUnifoms) === null || _this$commonUnifoms === void 0 || _this$commonUnifoms.subData({
+      offset: 0,
+      data: new Uint8Array(new Float32Array(commonUniformsArray).buffer)
+    });
+  }
+}