@antv/l7-renderer 2.19.10 → 2.20.0

package/es/device/index.js

@@ -0,0 +1,319 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _dec, _class;
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { Format, TextureUsage, TransparentBlack, WebGLDeviceContribution, WebGPUDeviceContribution } from '@antv/g-device-api';
+import { injectable } from 'inversify';
+import 'reflect-metadata';
+import DeviceAttribute from "./DeviceAttribute";
+import DeviceBuffer from "./DeviceBuffer";
+import DeviceElements from "./DeviceElements";
+import DeviceFramebuffer from "./DeviceFramebuffer";
+import DeviceModel from "./DeviceModel";
+import DeviceTexture2D from "./DeviceTexture2D";
+import { isWebGL2 } from "./utils/webgl";
+
+/**
+ * Device API renderer
+ */
+var DeviceRendererService = (_dec = injectable(), _dec(_class = /*#__PURE__*/function () {
+  function DeviceRendererService() {
+    var _this = this;
+    _classCallCheck(this, DeviceRendererService);
+    _defineProperty(this, "uniformBuffers", []);
+    _defineProperty(this, "createModel", function (options) {
+      return new DeviceModel(_this.device, options);
+    });
+    _defineProperty(this, "createAttribute", function (options) {
+      return new DeviceAttribute(_this.device, options);
+    });
+    _defineProperty(this, "createBuffer", function (options) {
+      return new DeviceBuffer(_this.device, options);
+    });
+    _defineProperty(this, "createElements", function (options) {
+      return new DeviceElements(_this.device, options);
+    });
+    _defineProperty(this, "createTexture2D", function (options) {
+      return new DeviceTexture2D(_this.device, options);
+    });
+    _defineProperty(this, "createFramebuffer", function (options) {
+      return new DeviceFramebuffer(_this.device, options);
+    });
+    _defineProperty(this, "useFramebuffer", function ()
+    // framebuffer: IFramebuffer | null,
+    // drawCommands: () => void,
+    {
+      // if (framebuffer == null) {
+      //   // @ts-ignore
+      //   this.device.currentFramebuffer = this.device.onscreenFramebuffer;
+      // } else {
+      //   // @ts-ignore
+      //   this.device.currentFramebuffer = framebuffer;
+      // }
+      // drawCommands();
+    });
+    _defineProperty(this, "clear", function ()
+    // options: IClearOptions
+    {
+      // @see https://github.com/regl-project/regl/blob/gh-pages/API.md#clear-the-draw-buffer
+      // const { color, depth, stencil, framebuffer = null } = options;
+      // const reglClearOptions: regl.ClearOptions = {
+      //   color,
+      //   depth,
+      //   stencil,
+      // };
+      // reglClearOptions.framebuffer =
+      //   framebuffer === null
+      //     ? framebuffer
+      //     : (framebuffer as DeviceFramebuffer).get();
+      // this.gl?.clear(reglClearOptions);
+      // TODO: clear
+    });
+    _defineProperty(this, "viewport", function (_ref) {
+      var width = _ref.width,
+        height = _ref.height;
+      // use WebGL context directly
+      // @see https://github.com/regl-project/regl/blob/gh-pages/API.md#unsafe-escape-hatch
+      // this.gl._gl.viewport(x, y, width, height);
+      _this.width = width;
+      _this.height = height;
+      // Will be used in `setViewport` from RenderPass later.
+      // @ts-ignore
+      _this.device.width = width;
+      // @ts-ignore
+      _this.device.height = height;
+
+      // this.gl._refresh();
+    });
+    _defineProperty(this, "readPixels", function ()
+    // options: IReadPixelsOptions
+    {
+      // const { framebuffer, x, y, width, height } = options;
+
+      // const readback = this.device.createReadback();
+
+      // if (framebuffer) {
+      //   readPixelsOptions.framebuffer = (framebuffer as DeviceFramebuffer).get();
+      // }
+      // return readback.readTextureSync(null, x, y, width, height, new Uint8Array()) as Uint8Array;
+      return new Uint8Array();
+    });
+    _defineProperty(this, "getViewportSize", function () {
+      // FIXME: add viewport size in Device API.
+      return {
+        // @ts-ignore
+        width: _this.device.width,
+        // @ts-ignore
+        height: _this.device.height
+      };
+    });
+    _defineProperty(this, "getContainer", function () {
+      var _this$canvas;
+      return (_this$canvas = _this.canvas) === null || _this$canvas === void 0 ? void 0 : _this$canvas.parentElement;
+    });
+    _defineProperty(this, "getCanvas", function () {
+      // return this.$container?.getElementsByTagName('canvas')[0] || null;
+      return _this.canvas;
+    });
+    _defineProperty(this, "getGLContext", function () {
+      // @ts-ignore
+      return _this.device['gl'];
+    });
+    _defineProperty(this, "destroy", function () {
+      var _this$uniformBuffers;
+      // this.canvas = null 清除对 webgl 实例的引用
+      // @ts-ignore
+      _this.canvas = null;
+      (_this$uniformBuffers = _this.uniformBuffers) === null || _this$uniformBuffers === void 0 || _this$uniformBuffers.forEach(function (buffer) {
+        buffer.destroy();
+      });
+      _this.device.destroy();
+
+      // make sure release webgl context
+      // this.gl?._gl?.getExtension('WEBGL_lose_context')?.loseContext();
+
+      // @see https://github.com/regl-project/regl/blob/gh-pages/API.md#clean-up
+      // this.gl.destroy();
+
+      // @ts-ignore
+      // this.gl = null;
+    });
+  }
+  _createClass(DeviceRendererService, [{
+    key: "init",
+    value: function () {
+      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(canvas, cfg) {
+        var enableWebGPU, shaderCompilerPath, deviceContribution, swapChain, gl, renderTargetTexture;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              enableWebGPU = cfg.enableWebGPU, shaderCompilerPath = cfg.shaderCompilerPath; // this.$container = $container;
+              this.canvas = canvas;
+
+              // TODO: use antialias from cfg
+              deviceContribution = enableWebGPU ? new WebGPUDeviceContribution({
+                shaderCompilerPath: shaderCompilerPath
+              }) : new WebGLDeviceContribution({
+                // Use WebGL2 first and downgrade to WebGL1 if WebGL2 is not supported.
+                targets: ['webgl2', 'webgl1'],
+                onContextLost: function onContextLost(e) {
+                  console.warn('context lost', e);
+                },
+                onContextCreationError: function onContextCreationError(e) {
+                  console.warn('context creation error', e);
+                },
+                onContextRestored: function onContextRestored(e) {
+                  console.warn('context restored', e);
+                }
+              });
+              _context.next = 5;
+              return deviceContribution.createSwapChain(canvas);
+            case 5:
+              swapChain = _context.sent;
+              swapChain.configureSwapChain(canvas.width, canvas.height);
+              this.device = swapChain.getDevice();
+              this.swapChain = swapChain;
+
+              // Create default RT
+              // @ts-ignore
+              // this.device.onscreenFramebuffer = this.createFramebuffer({
+              //   width: canvas.width,
+              //   height: canvas.height,
+              // });
+              // // @ts-ignore
+              // this.device.onscreenFramebuffer.onscreen = true;
+              // // @ts-ignore
+              // this.device.currentFramebuffer = this.device.onscreenFramebuffer;
+
+              // @ts-ignore
+              gl = this.device['gl'];
+              this.extensionObject = {
+                // @ts-ignore
+                OES_texture_float: !isWebGL2(gl) && this.device['OES_texture_float']
+              };
+              renderTargetTexture = this.device.createTexture({
+                format: Format.U8_RGBA_RT,
+                width: canvas.width,
+                height: canvas.height,
+                usage: TextureUsage.RENDER_TARGET
+              });
+              this.renderTarget = this.device.createRenderTargetFromTexture(renderTargetTexture);
+              this.mainDepthRT = this.device.createRenderTargetFromTexture(this.device.createTexture({
+                format: Format.D24_S8,
+                width: canvas.width,
+                height: canvas.height,
+                usage: TextureUsage.RENDER_TARGET
+              }));
+            case 14:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function init(_x, _x2) {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+  }, {
+    key: "beginFrame",
+    value: function beginFrame() {
+      var onscreenTexture = this.swapChain.getOnscreenTexture();
+      this.renderPass = this.device.createRenderPass({
+        colorAttachment: [this.renderTarget],
+        // colorResolveTo: [onscreen ? onscreenTexture : onscreenTexture],
+        colorResolveTo: [onscreenTexture],
+        colorClearColor: [TransparentBlack],
+        depthStencilAttachment: this.mainDepthRT,
+        depthClearValue: 1
+      });
+      // @ts-ignore
+      this.device.renderPass = this.renderPass;
+    }
+  }, {
+    key: "endFrame",
+    value: function endFrame() {
+      this.device.submitPass(this.renderPass);
+    }
+  }, {
+    key: "getPointSizeRange",
+    value: function getPointSizeRange() {
+      // @ts-ignore
+      var gl = this.device['gl'];
+      // FIXME: implement this method in Device API.
+      return gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE);
+    }
+  }, {
+    key: "testExtension",
+    value: function testExtension(name) {
+      // OES_texture_float
+      return !!this.getGLContext().getExtension(name);
+    }
+  }, {
+    key: "setState",
+    value:
+    // TODO: 临时方法
+    function setState() {
+      // this.gl({
+      //   cull: {
+      //     enable: false,
+      //     face: 'back',
+      //   },
+      //   viewport: {
+      //     x: 0,
+      //     y: 0,
+      //     height: this.width,
+      //     width: this.height,
+      //   },
+      //   blend: {
+      //     enable: true,
+      //     equation: 'add',
+      //   },
+      //   framebuffer: null,
+      // });
+      // this.gl._refresh();
+    }
+  }, {
+    key: "setBaseState",
+    value: function setBaseState() {
+      // this.gl({
+      //   cull: {
+      //     enable: false,
+      //     face: 'back',
+      //   },
+      //   viewport: {
+      //     x: 0,
+      //     y: 0,
+      //     height: this.width,
+      //     width: this.height,
+      //   },
+      //   blend: {
+      //     enable: false,
+      //     equation: 'add',
+      //   },
+      //   framebuffer: null,
+      // });
+      // this.gl._refresh();
+    }
+  }, {
+    key: "setCustomLayerDefaults",
+    value: function setCustomLayerDefaults() {
+      // const gl = this.getGLContext();
+      // gl.disable(gl.CULL_FACE);
+    }
+  }, {
+    key: "setDirty",
+    value: function setDirty(flag) {
+      this.isDirty = flag;
+    }
+  }, {
+    key: "getDirty",
+    value: function getDirty() {
+      return this.isDirty;
+    }
+  }]);
+  return DeviceRendererService;
+}()) || _class);
+export { DeviceRendererService as default };

package/es/device/utils/pipeline.d.ts

@@ -0,0 +1 @@
+export declare function pipelineEquals(): void;

package/es/device/utils/pipeline.js

@@ -0,0 +1 @@
+export function pipelineEquals() {}

package/es/device/utils/typedarray.d.ts

@@ -0,0 +1,2 @@
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export declare function isTypedArray(x: any): x is TypedArray;

package/es/device/utils/typedarray.js

@@ -0,0 +1,16 @@
+var dtypes = {
+  '[object Int8Array]': 5120,
+  '[object Int16Array]': 5122,
+  '[object Int32Array]': 5124,
+  '[object Uint8Array]': 5121,
+  '[object Uint8ClampedArray]': 5121,
+  '[object Uint16Array]': 5123,
+  '[object Uint32Array]': 5125,
+  '[object Float32Array]': 5126,
+  '[object Float64Array]': 5121,
+  '[object ArrayBuffer]': 5121
+};
+// eslint-disable-next-line
+export function isTypedArray(x) {
+  return Object.prototype.toString.call(x) in dtypes;
+}

package/es/device/utils/webgl.d.ts

@@ -0,0 +1 @@
+export declare function isWebGL2(gl: WebGL2RenderingContext | WebGLRenderingContext): gl is WebGL2RenderingContext;

package/es/device/utils/webgl.js

@@ -0,0 +1,9 @@
+// @see https://github.com/visgl/luma.gl/blob/30a1039573576d73641de7c1ba222e8992eb526e/modules/gltools/src/utils/webgl-checks.ts#L22
+export function isWebGL2(gl) {
+  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
+    return true;
+  }
+  // Look for debug contexts, headless gl etc
+  // @ts-ignore
+  return Boolean(gl && gl._version === 2);
+}

package/es/index.d.ts

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

package/es/index.js

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

package/es/regl/ReglModel.js

@@ -3,7 +3,8 @@ 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 { ClipSpaceNearZ, preprocessShader_GLSL, ViewportOrigin } from '@antv/g-device-api';
+import { gl, removeDuplicateUniforms } from '@antv/l7-core';
 import { lodashUtil } from '@antv/l7-utils';
 import { blendEquationMap, blendFuncMap, cullFaceMap, depthFuncMap, primitiveMap, stencilFuncMap, stencilOpMap } from "./constants";
 var isPlainObject = lodashUtil.isPlainObject,
@@ -28,6 +29,19 @@ var ReglModel = /*#__PURE__*/function () {
       depth = options.depth,
       cull = options.cull,
       instances = options.instances;
+
+    /**
+     * try to compile GLSL 300 to 100
+     */
+    var vendorInfo = {
+      platformString: 'WebGL1',
+      glslVersion: '#version 100',
+      explicitBindingLocations: false,
+      separateSamplerTextures: false,
+      viewportOrigin: ViewportOrigin.LOWER_LEFT,
+      clipSpaceNearZ: ClipSpaceNearZ.NEGATIVE_ONE,
+      supportMRT: false
+    };
     var reglUniforms = {};
     this.options = options;
     if (uniforms) {
@@ -44,9 +58,9 @@ var ReglModel = /*#__PURE__*/function () {
     });
     var drawParams = {
       attributes: reglAttributes,
-      frag: fs,
+      frag: removeDuplicateUniforms(preprocessShader_GLSL(vendorInfo, 'frag', fs, null, false)),
       uniforms: reglUniforms,
-      vert: vs,
+      vert: removeDuplicateUniforms(preprocessShader_GLSL(vendorInfo, 'vert', vs, null, false)),
       // @ts-ignore
       colorMask: reGl.prop('colorMask'),
       lineWidth: 1,
@@ -162,13 +176,13 @@ var ReglModel = /*#__PURE__*/function () {
   }, {
     key: "destroy",
     value: function destroy() {
-      var _this$drawParams, _this$drawParams$elem;
+      var _this$drawParams;
       // @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();
+      (_this$drawParams = this.drawParams) === null || _this$drawParams === void 0 || (_this$drawParams = _this$drawParams.elements) === null || _this$drawParams === void 0 || _this$drawParams.destroy();
       if (this.options.attributes) {
         Object.values(this.options.attributes).forEach(function (attr) {
           // @ts-ignore
-          attr === null || attr === void 0 ? void 0 : attr.destroy();
+          attr === null || attr === void 0 || attr.destroy();
         });
       }
       this.destroyed = true;

package/es/regl/ReglTexture2D.js

@@ -115,7 +115,7 @@ var ReglTexture2D = /*#__PURE__*/function () {
     value: function destroy() {
       if (!this.isDestroy) {
         var _this$texture;
-        (_this$texture = this.texture) === null || _this$texture === void 0 ? void 0 : _this$texture.destroy();
+        (_this$texture = this.texture) === null || _this$texture === void 0 || _this$texture.destroy();
       }
       this.isDestroy = true;
     }

package/es/regl/index.d.ts

@@ -10,6 +10,7 @@ import ReglFramebuffer from './ReglFramebuffer';
  * regl renderer
  */
 export default class ReglRendererService implements IRendererService {
+    uniformBuffers: IBuffer[];
     extensionObject: IExtensions;
     private gl;
     private $container;
@@ -48,4 +49,6 @@ export default class ReglRendererService implements IRendererService {
     setDirty(flag: boolean): void;
     getDirty(): boolean;
     destroy: () => void;
+    beginFrame(): void;
+    endFrame(): void;
 }

package/es/regl/index.js

@@ -26,6 +26,7 @@ var ReglRendererService = (_dec = injectable(), _dec(_class = /*#__PURE__*/funct
   function ReglRendererService() {
     var _this = this;
     _classCallCheck(this, ReglRendererService);
+    _defineProperty(this, "uniformBuffers", []);
     _defineProperty(this, "createModel", function (options) {
       return new ReglModel(_this.gl, options);
     });
@@ -63,7 +64,7 @@ var ReglRendererService = (_dec = injectable(), _dec(_class = /*#__PURE__*/funct
         stencil: stencil
       };
       reglClearOptions.framebuffer = framebuffer === null ? framebuffer : framebuffer.get();
-      (_this$gl = _this.gl) === null || _this$gl === void 0 ? void 0 : _this$gl.clear(reglClearOptions);
+      (_this$gl = _this.gl) === null || _this$gl === void 0 || _this$gl.clear(reglClearOptions);
     });
     _defineProperty(this, "viewport", function (_ref) {
       var x = _ref.x,
@@ -112,13 +113,13 @@ var ReglRendererService = (_dec = injectable(), _dec(_class = /*#__PURE__*/funct
       return _this.gl._gl;
     });
     _defineProperty(this, "destroy", function () {
-      var _this$gl2, _this$gl2$_gl, _this$gl2$_gl$getExte;
+      var _this$gl2;
       // this.canvas = null 清除对 webgl 实例的引用
       // @ts-ignore
       _this.canvas = null;
 
       // make sure release webgl context
-      (_this$gl2 = _this.gl) === null || _this$gl2 === void 0 ? void 0 : (_this$gl2$_gl = _this$gl2._gl) === null || _this$gl2$_gl === void 0 ? void 0 : (_this$gl2$_gl$getExte = _this$gl2$_gl.getExtension('WEBGL_lose_context')) === null || _this$gl2$_gl$getExte === void 0 ? void 0 : _this$gl2$_gl$getExte.loseContext();
+      (_this$gl2 = _this.gl) === null || _this$gl2 === void 0 || (_this$gl2 = _this$gl2._gl) === null || _this$gl2 === void 0 || (_this$gl2 = _this$gl2.getExtension('WEBGL_lose_context')) === null || _this$gl2 === void 0 || _this$gl2.loseContext();
 
       // @see https://github.com/regl-project/regl/blob/gh-pages/API.md#clean-up
       _this.gl.destroy();
@@ -265,6 +266,12 @@ var ReglRendererService = (_dec = injectable(), _dec(_class = /*#__PURE__*/funct
     value: function getDirty() {
       return this.isDirty;
     }
+  }, {
+    key: "beginFrame",
+    value: function beginFrame() {}
+  }, {
+    key: "endFrame",
+    value: function endFrame() {}
   }]);
   return ReglRendererService;
 }()) || _class);

package/lib/device/DeviceAttribute.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device/DeviceAttribute.ts
+var DeviceAttribute_exports = {};
+__export(DeviceAttribute_exports, {
+  default: () => DeviceAttribute
+});
+module.exports = __toCommonJS(DeviceAttribute_exports);
+var DeviceAttribute = class {
+  constructor(device, options) {
+    const {
+      buffer,
+      offset,
+      stride,
+      normalized,
+      size,
+      divisor,
+      shaderLocation
+    } = options;
+    this.buffer = buffer;
+    this.attribute = {
+      shaderLocation,
+      buffer: buffer.get(),
+      offset: offset || 0,
+      stride: stride || 0,
+      normalized: normalized || false,
+      divisor: divisor || 0
+    };
+    if (size) {
+      this.attribute.size = size;
+    }
+  }
+  get() {
+    return this.buffer;
+  }
+  updateBuffer(options) {
+    this.buffer.subData(options);
+  }
+  destroy() {
+    this.buffer.destroy();
+  }
+};

package/lib/device/DeviceBuffer.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device/DeviceBuffer.ts
+var DeviceBuffer_exports = {};
+__export(DeviceBuffer_exports, {
+  default: () => DeviceBuffer
+});
+module.exports = __toCommonJS(DeviceBuffer_exports);
+var import_g_device_api = require("@antv/g-device-api");
+var import_l7_core = require("@antv/l7-core");
+var import_constants = require("./constants");
+var import_typedarray = require("./utils/typedarray");
+var DeviceBuffer = class {
+  constructor(device, options) {
+    this.isDestroyed = false;
+    const { data, usage, type, isUBO } = options;
+    let typed;
+    if ((0, import_typedarray.isTypedArray)(data)) {
+      typed = data;
+    } else {
+      typed = new import_constants.typedArrayCtorMap[this.type || import_l7_core.gl.FLOAT](data);
+    }
+    this.type = type;
+    this.size = typed.byteLength;
+    this.buffer = device.createBuffer({
+      viewOrSize: typed,
+      usage: isUBO ? import_g_device_api.BufferUsage.UNIFORM : import_g_device_api.BufferUsage.VERTEX,
+      hint: import_constants.hintMap[usage || import_l7_core.gl.STATIC_DRAW]
+    });
+  }
+  get() {
+    return this.buffer;
+  }
+  destroy() {
+    if (!this.isDestroyed) {
+      this.buffer.destroy();
+    }
+    this.isDestroyed = true;
+  }
+  subData({
+    data,
+    offset
+  }) {
+    let typed;
+    if ((0, import_typedarray.isTypedArray)(data)) {
+      typed = data;
+    } else {
+      typed = new import_constants.typedArrayCtorMap[this.type || import_l7_core.gl.FLOAT](data);
+    }
+    this.buffer.setSubData(offset, new Uint8Array(typed.buffer));
+  }
+};