@antv/l7-renderer 2.18.2 → 2.19.0

package/es/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ *
+ */
+import ReglRendererService from './regl';
+export { ReglRendererService };

package/es/index.js

@@ -0,0 +1,5 @@
+/**
+ *
+ */
+import ReglRendererService from "./regl";
+export { ReglRendererService };

package/es/regl/ReglAttribute.d.ts

@@ -0,0 +1,16 @@
+import { IAttribute, IAttributeInitializationOptions } from '@antv/l7-core';
+import regl from 'regl';
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#attributes
+ */
+export default class ReglAttribute implements IAttribute {
+    private attribute;
+    private buffer;
+    constructor(gl: regl.Regl, options: IAttributeInitializationOptions);
+    get(): regl.Attribute;
+    updateBuffer(options: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+    destroy(): void;
+}

package/es/regl/ReglAttribute.js

@@ -0,0 +1,45 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#attributes
+ */
+var ReglAttribute = /*#__PURE__*/function () {
+  function ReglAttribute(gl, options) {
+    _classCallCheck(this, ReglAttribute);
+    var buffer = options.buffer,
+      offset = options.offset,
+      stride = options.stride,
+      normalized = options.normalized,
+      size = options.size,
+      divisor = options.divisor;
+    this.buffer = buffer;
+    this.attribute = {
+      buffer: buffer.get(),
+      offset: offset || 0,
+      stride: stride || 0,
+      normalized: normalized || false,
+      divisor: divisor || 0
+    };
+    if (size) {
+      this.attribute.size = size;
+    }
+  }
+  _createClass(ReglAttribute, [{
+    key: "get",
+    value: function get() {
+      return this.attribute;
+    }
+  }, {
+    key: "updateBuffer",
+    value: function updateBuffer(options) {
+      this.buffer.subData(options);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.buffer.destroy();
+    }
+  }]);
+  return ReglAttribute;
+}();
+export { ReglAttribute as default };

package/es/regl/ReglBuffer.d.ts

@@ -0,0 +1,17 @@
+import { IBuffer, IBufferInitializationOptions } from '@antv/l7-core';
+import regl from 'regl';
+/**
+ * adaptor for regl.Buffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#buffers
+ */
+export default class ReglBuffer implements IBuffer {
+    private buffer;
+    private isDestroyed;
+    constructor(reGl: regl.Regl, options: IBufferInitializationOptions);
+    get(): regl.Buffer;
+    destroy(): void;
+    subData({ data, offset, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+}

package/es/regl/ReglBuffer.js

@@ -0,0 +1,48 @@
+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 { gl } from '@antv/l7-core';
+import { dataTypeMap, usageMap } from "./constants";
+
+/**
+ * adaptor for regl.Buffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#buffers
+ */
+var ReglBuffer = /*#__PURE__*/function () {
+  function ReglBuffer(reGl, options) {
+    _classCallCheck(this, ReglBuffer);
+    _defineProperty(this, "isDestroyed", false);
+    var data = options.data,
+      usage = options.usage,
+      type = options.type;
+    this.buffer = reGl.buffer({
+      data: data,
+      usage: usageMap[usage || gl.STATIC_DRAW],
+      type: dataTypeMap[type || gl.UNSIGNED_BYTE]
+      // length: 0,
+    });
+  }
+  _createClass(ReglBuffer, [{
+    key: "get",
+    value: function get() {
+      return this.buffer;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this.isDestroyed) {
+        this.buffer.destroy();
+      }
+      this.isDestroyed = true;
+    }
+  }, {
+    key: "subData",
+    value: function subData(_ref) {
+      var data = _ref.data,
+        offset = _ref.offset;
+      this.buffer.subdata(data, offset);
+    }
+  }]);
+  return ReglBuffer;
+}();
+export { ReglBuffer as default };

package/es/regl/ReglElements.d.ts

@@ -0,0 +1,14 @@
+import { IElements, IElementsInitializationOptions } from '@antv/l7-core';
+import regl from 'regl';
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#elements
+ */
+export default class ReglElements implements IElements {
+    private elements;
+    constructor(reGl: regl.Regl, options: IElementsInitializationOptions);
+    get(): regl.Elements;
+    subData({ data, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+    }): void;
+    destroy(): void;
+}

package/es/regl/ReglElements.js

@@ -0,0 +1,42 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { gl } from '@antv/l7-core';
+import { dataTypeMap, usageMap } from "./constants";
+
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#elements
+ */
+var ReglElements = /*#__PURE__*/function () {
+  function ReglElements(reGl, options) {
+    _classCallCheck(this, ReglElements);
+    var data = options.data,
+      usage = options.usage,
+      type = options.type,
+      count = options.count;
+    this.elements = reGl.elements({
+      data: data,
+      usage: usageMap[usage || gl.STATIC_DRAW],
+      type: dataTypeMap[type || gl.UNSIGNED_BYTE],
+      count: count
+    });
+  }
+  _createClass(ReglElements, [{
+    key: "get",
+    value: function get() {
+      return this.elements;
+    }
+  }, {
+    key: "subData",
+    value: function subData(_ref) {
+      var data = _ref.data;
+      this.elements.subdata(data);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      // this.elements.destroy();
+    }
+  }]);
+  return ReglElements;
+}();
+export { ReglElements as default };

package/es/regl/ReglFramebuffer.d.ts

@@ -0,0 +1,16 @@
+import { IFramebuffer, IFramebufferInitializationOptions } from '@antv/l7-core';
+import regl from 'regl';
+/**
+ * adaptor for regl.Framebuffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#framebuffers
+ */
+export default class ReglFramebuffer implements IFramebuffer {
+    private framebuffer;
+    constructor(reGl: regl.Regl, options: IFramebufferInitializationOptions);
+    get(): regl.Framebuffer;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}

package/es/regl/ReglFramebuffer.js

@@ -0,0 +1,51 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+/**
+ * adaptor for regl.Framebuffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#framebuffers
+ */
+var ReglFramebuffer = /*#__PURE__*/function () {
+  function ReglFramebuffer(reGl, options) {
+    _classCallCheck(this, ReglFramebuffer);
+    var width = options.width,
+      height = options.height,
+      color = options.color,
+      colors = options.colors;
+    var framebufferOptions = {
+      width: width,
+      height: height
+    };
+    if (Array.isArray(colors)) {
+      framebufferOptions.colors = colors.map(function (c) {
+        return c.get();
+      });
+    }
+    if (color && typeof color !== 'boolean') {
+      framebufferOptions.color = color.get();
+    }
+
+    // TODO: depth & stencil
+
+    this.framebuffer = reGl.framebuffer(framebufferOptions);
+  }
+  _createClass(ReglFramebuffer, [{
+    key: "get",
+    value: function get() {
+      return this.framebuffer;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.framebuffer.destroy();
+    }
+  }, {
+    key: "resize",
+    value: function resize(_ref) {
+      var width = _ref.width,
+        height = _ref.height;
+      this.framebuffer.resize(width, height);
+    }
+  }]);
+  return ReglFramebuffer;
+}();
+export { ReglFramebuffer as default };

package/es/regl/ReglModel.d.ts

@@ -0,0 +1,46 @@
+import { IAttribute, IElements, IModel, IModelDrawOptions, IModelInitializationOptions, IUniform } from '@antv/l7-core';
+import regl from 'regl';
+/**
+ * adaptor for regl.DrawCommand
+ */
+export default class ReglModel implements IModel {
+    private reGl;
+    private destroyed;
+    private drawCommand;
+    private drawParams;
+    private options;
+    private uniforms;
+    constructor(reGl: regl.Regl, options: IModelInitializationOptions);
+    updateAttributesAndElements(attributes: {
+        [key: string]: IAttribute;
+    }, elements: IElements): void;
+    updateAttributes(attributes: {
+        [key: string]: IAttribute;
+    }): void;
+    addUniforms(uniforms: {
+        [key: string]: IUniform;
+    }): void;
+    draw(options: IModelDrawOptions, pick?: boolean): void;
+    destroy(): void;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#depth-buffer
+     */
+    private initDepthDrawParams;
+    private getBlendDrawParams;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+     */
+    private getStencilDrawParams;
+    private getColorMaskDrawParams;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#culling
+     */
+    private initCullDrawParams;
+    /**
+     * 考虑结构体命名, eg:
+     * a: { b: 1 }  ->  'a.b'
+     * a: [ { b: 1 } ] -> 'a[0].b'
+     */
+    private extractUniforms;
+    private extractUniformsRecursively;
+}

package/es/regl/ReglModel.js

@@ -0,0 +1,350 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+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 { gl } from '@antv/l7-core';
+import { lodashUtil } from '@antv/l7-utils';
+import { blendEquationMap, blendFuncMap, cullFaceMap, depthFuncMap, primitiveMap, stencilFuncMap, stencilOpMap } from "./constants";
+var isPlainObject = lodashUtil.isPlainObject,
+  isTypedArray = lodashUtil.isTypedArray;
+
+/**
+ * adaptor for regl.DrawCommand
+ */
+var ReglModel = /*#__PURE__*/function () {
+  function ReglModel(reGl, options) {
+    _classCallCheck(this, ReglModel);
+    _defineProperty(this, "destroyed", false);
+    _defineProperty(this, "uniforms", {});
+    this.reGl = reGl;
+    var vs = options.vs,
+      fs = options.fs,
+      attributes = options.attributes,
+      uniforms = options.uniforms,
+      primitive = options.primitive,
+      count = options.count,
+      elements = options.elements,
+      depth = options.depth,
+      cull = options.cull,
+      instances = options.instances;
+    var reglUniforms = {};
+    this.options = options;
+    if (uniforms) {
+      this.uniforms = this.extractUniforms(uniforms);
+      Object.keys(uniforms).forEach(function (uniformName) {
+        // use regl prop API
+        // @ts-ignore
+        reglUniforms[uniformName] = reGl.prop(uniformName);
+      });
+    }
+    var reglAttributes = {};
+    Object.keys(attributes).forEach(function (name) {
+      reglAttributes[name] = attributes[name].get();
+    });
+    var drawParams = {
+      attributes: reglAttributes,
+      frag: fs,
+      uniforms: reglUniforms,
+      vert: vs,
+      // @ts-ignore
+      colorMask: reGl.prop('colorMask'),
+      lineWidth: 1,
+      blend: {
+        // @ts-ignore
+        enable: reGl.prop('blend.enable'),
+        // @ts-ignore
+        func: reGl.prop('blend.func'),
+        // @ts-ignore
+        equation: reGl.prop('blend.equation'),
+        // @ts-ignore
+        color: reGl.prop('blend.color')
+      },
+      stencil: {
+        // @ts-ignore
+        enable: reGl.prop('stencil.enable'),
+        // @ts-ignore
+        mask: reGl.prop('stencil.mask'),
+        // @ts-ignore
+        func: reGl.prop('stencil.func'),
+        // @ts-ignore
+        opFront: reGl.prop('stencil.opFront'),
+        // @ts-ignore
+        opBack: reGl.prop('stencil.opBack')
+      },
+      primitive: primitiveMap[primitive === undefined ? gl.TRIANGLES : primitive]
+    };
+    if (instances) {
+      drawParams.instances = instances;
+    }
+
+    // Tip:
+    // elements 中可能包含 count，此时不应传入
+    // count 和 elements 相比、count 优先
+    if (count) {
+      drawParams.count = count;
+    } else if (elements) {
+      drawParams.elements = elements.get();
+    }
+    this.initDepthDrawParams({
+      depth: depth
+    }, drawParams);
+    // this.initBlendDrawParams({ blend }, drawParams);
+    // this.initStencilDrawParams({ stencil }, drawParams);
+    this.initCullDrawParams({
+      cull: cull
+    }, drawParams);
+    this.drawCommand = reGl(drawParams);
+    this.drawParams = drawParams;
+  }
+  _createClass(ReglModel, [{
+    key: "updateAttributesAndElements",
+    value: function updateAttributesAndElements(attributes, elements) {
+      var reglAttributes = {};
+      Object.keys(attributes).forEach(function (name) {
+        reglAttributes[name] = attributes[name].get();
+      });
+      this.drawParams.attributes = reglAttributes;
+      this.drawParams.elements = elements.get();
+      this.drawCommand = this.reGl(this.drawParams);
+    }
+  }, {
+    key: "updateAttributes",
+    value: function updateAttributes(attributes) {
+      var reglAttributes = {};
+      Object.keys(attributes).forEach(function (name) {
+        reglAttributes[name] = attributes[name].get();
+      });
+      this.drawParams.attributes = reglAttributes;
+      this.drawCommand = this.reGl(this.drawParams);
+    }
+  }, {
+    key: "addUniforms",
+    value: function addUniforms(uniforms) {
+      this.uniforms = _objectSpread(_objectSpread({}, this.uniforms), this.extractUniforms(uniforms));
+    }
+  }, {
+    key: "draw",
+    value: function draw(options, pick) {
+      if (this.drawParams.attributes && Object.keys(this.drawParams.attributes).length === 0) {
+        return;
+      }
+      var uniforms = _objectSpread(_objectSpread({}, this.uniforms), this.extractUniforms(options.uniforms || {}));
+      var reglDrawProps = {};
+      Object.keys(uniforms).forEach(function (uniformName) {
+        var type = _typeof(uniforms[uniformName]);
+        if (type === 'boolean' || type === 'number' || Array.isArray(uniforms[uniformName]) ||
+        // @ts-ignore
+        uniforms[uniformName].BYTES_PER_ELEMENT) {
+          reglDrawProps[uniformName] = uniforms[uniformName];
+        } else {
+          reglDrawProps[uniformName] = uniforms[uniformName].get();
+        }
+      });
+      // 更新 blend
+      // @ts-ignore
+      reglDrawProps.blend = pick // picking 操作不应该使用 blend
+      ? this.getBlendDrawParams({
+        blend: {
+          enable: false
+        }
+      }) : this.getBlendDrawParams(options);
+
+      // 更新stentil 配置
+      // @ts-ignore
+      reglDrawProps.stencil = this.getStencilDrawParams(options);
+      // @ts-ignore
+      reglDrawProps.colorMask = this.getColorMaskDrawParams(options, pick);
+
+      // 在进行拾取操作的绘制中，不应该使用叠加模式 - picking 根据拾取的颜色作为判断的输入，而叠加模式会产生新的，在 id 序列中不存在的颜色
+      this.drawCommand(reglDrawProps);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this$drawParams, _this$drawParams$elem;
+      // @ts-ignore
+      (_this$drawParams = this.drawParams) === null || _this$drawParams === void 0 ? void 0 : (_this$drawParams$elem = _this$drawParams.elements) === null || _this$drawParams$elem === void 0 ? void 0 : _this$drawParams$elem.destroy();
+      if (this.options.attributes) {
+        Object.values(this.options.attributes).forEach(function (attr) {
+          // @ts-ignore
+          attr === null || attr === void 0 ? void 0 : attr.destroy();
+        });
+      }
+      this.destroyed = true;
+    }
+
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#depth-buffer
+     */
+  }, {
+    key: "initDepthDrawParams",
+    value: function initDepthDrawParams(_ref, drawParams) {
+      var depth = _ref.depth;
+      if (depth) {
+        drawParams.depth = {
+          enable: depth.enable === undefined ? true : !!depth.enable,
+          mask: depth.mask === undefined ? true : !!depth.mask,
+          func: depthFuncMap[depth.func || gl.LESS],
+          range: depth.range || [0, 1]
+        };
+      }
+    }
+  }, {
+    key: "getBlendDrawParams",
+    value: function getBlendDrawParams(_ref2) {
+      var blend = _ref2.blend;
+      var _ref3 = blend || {},
+        enable = _ref3.enable,
+        func = _ref3.func,
+        equation = _ref3.equation,
+        _ref3$color = _ref3.color,
+        color = _ref3$color === void 0 ? [0, 0, 0, 0] : _ref3$color;
+      // @ts-ignore
+      return {
+        enable: !!enable,
+        func: {
+          srcRGB: blendFuncMap[func && func.srcRGB || gl.SRC_ALPHA],
+          srcAlpha: blendFuncMap[func && func.srcAlpha || gl.SRC_ALPHA],
+          dstRGB: blendFuncMap[func && func.dstRGB || gl.ONE_MINUS_SRC_ALPHA],
+          dstAlpha: blendFuncMap[func && func.dstAlpha || gl.ONE_MINUS_SRC_ALPHA]
+        },
+        equation: {
+          rgb: blendEquationMap[equation && equation.rgb || gl.FUNC_ADD],
+          alpha: blendEquationMap[equation && equation.alpha || gl.FUNC_ADD]
+        },
+        color: color
+      };
+    }
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+     */
+  }, {
+    key: "getStencilDrawParams",
+    value: function getStencilDrawParams(_ref4) {
+      var stencil = _ref4.stencil;
+      var _ref5 = stencil || {},
+        enable = _ref5.enable,
+        _ref5$mask = _ref5.mask,
+        mask = _ref5$mask === void 0 ? -1 : _ref5$mask,
+        _ref5$func = _ref5.func,
+        func = _ref5$func === void 0 ? {
+          cmp: gl.ALWAYS,
+          ref: 0,
+          mask: -1
+        } : _ref5$func,
+        _ref5$opFront = _ref5.opFront,
+        opFront = _ref5$opFront === void 0 ? {
+          fail: gl.KEEP,
+          zfail: gl.KEEP,
+          zpass: gl.KEEP
+        } : _ref5$opFront,
+        _ref5$opBack = _ref5.opBack,
+        opBack = _ref5$opBack === void 0 ? {
+          fail: gl.KEEP,
+          zfail: gl.KEEP,
+          zpass: gl.KEEP
+        } : _ref5$opBack;
+      return {
+        enable: !!enable,
+        mask: mask,
+        func: _objectSpread(_objectSpread({}, func), {}, {
+          cmp: stencilFuncMap[func.cmp]
+        }),
+        opFront: {
+          fail: stencilOpMap[opFront.fail],
+          zfail: stencilOpMap[opFront.zfail],
+          zpass: stencilOpMap[opFront.zpass]
+        },
+        opBack: {
+          fail: stencilOpMap[opBack.fail],
+          zfail: stencilOpMap[opBack.zfail],
+          zpass: stencilOpMap[opBack.zpass]
+        }
+      };
+    }
+  }, {
+    key: "getColorMaskDrawParams",
+    value: function getColorMaskDrawParams(_ref6, pick) {
+      var stencil = _ref6.stencil;
+      // TODO: 重构相关参数
+      // 掩膜模式下，颜色通道全部关闭
+      var colorMask = stencil !== null && stencil !== void 0 && stencil.enable && stencil.opFront && !pick ? [false, false, false, false] : [true, true, true, true]; // 非掩码模式下，颜色通道全部开启
+      return colorMask;
+    }
+
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#culling
+     */
+  }, {
+    key: "initCullDrawParams",
+    value: function initCullDrawParams(_ref7, drawParams) {
+      var cull = _ref7.cull;
+      if (cull) {
+        var enable = cull.enable,
+          _cull$face = cull.face,
+          face = _cull$face === void 0 ? gl.BACK : _cull$face;
+        drawParams.cull = {
+          enable: !!enable,
+          face: cullFaceMap[face]
+        };
+      }
+    }
+
+    /**
+     * 考虑结构体命名, eg:
+     * a: { b: 1 }  ->  'a.b'
+     * a: [ { b: 1 } ] -> 'a[0].b'
+     */
+  }, {
+    key: "extractUniforms",
+    value: function extractUniforms(uniforms) {
+      var _this = this;
+      var extractedUniforms = {};
+      Object.keys(uniforms).forEach(function (uniformName) {
+        _this.extractUniformsRecursively(uniformName, uniforms[uniformName], extractedUniforms, '');
+      });
+      return extractedUniforms;
+    }
+  }, {
+    key: "extractUniformsRecursively",
+    value: function extractUniformsRecursively(uniformName, uniformValue, uniforms, prefix) {
+      var _this2 = this;
+      if (uniformValue === null || typeof uniformValue === 'number' ||
+      // u_A: 1
+      typeof uniformValue === 'boolean' ||
+      // u_A: false
+      Array.isArray(uniformValue) && typeof uniformValue[0] === 'number' ||
+      // u_A: [1, 2, 3]
+      isTypedArray(uniformValue) ||
+      // u_A: Float32Array
+      // @ts-ignore
+      uniformValue === '' || 'resize' in uniformValue) {
+        uniforms["".concat(prefix && prefix + '.').concat(uniformName)] = uniformValue;
+        return;
+      }
+
+      // u_Struct.a.b.c
+      if (isPlainObject(uniformValue)) {
+        Object.keys(uniformValue).forEach(function (childName) {
+          _this2.extractUniformsRecursively(childName,
+          // @ts-ignore
+          uniformValue[childName], uniforms, "".concat(prefix && prefix + '.').concat(uniformName));
+        });
+      }
+
+      // u_Struct[0].a
+      if (Array.isArray(uniformValue)) {
+        uniformValue.forEach(function (child, idx) {
+          Object.keys(child).forEach(function (childName) {
+            _this2.extractUniformsRecursively(childName,
+            // @ts-ignore
+            child[childName], uniforms, "".concat(prefix && prefix + '.').concat(uniformName, "[").concat(idx, "]"));
+          });
+        });
+      }
+    }
+  }]);
+  return ReglModel;
+}();
+export { ReglModel as default };

package/es/regl/ReglRenderbuffer.d.ts

@@ -0,0 +1,16 @@
+import { IRenderbuffer, IRenderbufferInitializationOptions } from '@antv/l7-core';
+import regl from 'regl';
+/**
+ * adaptor for regl.Renderbuffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#renderbuffers
+ */
+export default class ReglRenderbuffer implements IRenderbuffer {
+    private renderbuffer;
+    constructor(reGl: regl.Regl, options: IRenderbufferInitializationOptions);
+    get(): regl.Renderbuffer;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}