@luma.gl/webgl 8.6.0-alpha.3 → 9.0.0-alpha.2

package/dist/es5/adapter/objects/webgl-vertex-array-object.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _api = require("@luma.gl/api");
+
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
+var _env = require("@probe.gl/env");
+
+var _webglResource = _interopRequireDefault(require("./webgl-resource"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
+
+var WEBGLVertexArrayObject = function (_WebGLResource, _Symbol$toStringTag) {
+  (0, _inherits2.default)(WEBGLVertexArrayObject, _WebGLResource);
+
+  var _super = _createSuper(WEBGLVertexArrayObject);
+
+  function WEBGLVertexArrayObject(device, props) {
+    (0, _classCallCheck2.default)(this, WEBGLVertexArrayObject);
+    return _super.call(this, device, props, {});
+  }
+
+  (0, _createClass2.default)(WEBGLVertexArrayObject, [{
+    key: _Symbol$toStringTag,
+    get: function get() {
+      return 'BaseVertexArrayObject';
+    }
+  }, {
+    key: "_createHandle",
+    value: function _createHandle() {
+      return this.gl2.createVertexArray();
+    }
+  }, {
+    key: "_deleteHandle",
+    value: function _deleteHandle() {
+      this.gl2.deleteVertexArray(this.handle);
+      return [this.elements];
+    }
+  }, {
+    key: "_bindHandle",
+    value: function _bindHandle(handle) {
+      this.gl2.bindVertexArray(handle);
+    }
+  }, {
+    key: "setElementBuffer",
+    value: function setElementBuffer() {
+      var _this = this;
+
+      var elementBuffer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      (0, _api.assert)(!elementBuffer || elementBuffer.target === _constants.default.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
+      this.bind(function () {
+        _this.gl.bindBuffer(_constants.default.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
+      });
+      return this;
+    }
+  }, {
+    key: "setBuffer",
+    value: function setBuffer(location, buffer, accessor) {
+      var _this2 = this;
+
+      if (buffer.target === _constants.default.ELEMENT_ARRAY_BUFFER) {
+        return this.setElementBuffer(buffer, accessor);
+      }
+
+      var size = accessor.size,
+          type = accessor.type,
+          stride = accessor.stride,
+          offset = accessor.offset,
+          normalized = accessor.normalized,
+          integer = accessor.integer,
+          divisor = accessor.divisor;
+      var gl = this.gl,
+          gl2 = this.gl2;
+      location = Number(location);
+      this.bind(function () {
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
+
+        if (integer) {
+          _this2.device.assertWebGL2();
+
+          gl2.vertexAttribIPointer(location, size, type, stride, offset);
+        } else {
+          gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+        }
+
+        gl.enableVertexAttribArray(location);
+        gl2.vertexAttribDivisor(location, divisor || 0);
+      });
+      return this;
+    }
+  }, {
+    key: "enable",
+    value: function enable(location) {
+      var _this3 = this;
+
+      var _enable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+      var canDisableAttributeZero = this.device.isWebGL2 || (0, _env.getBrowser)() === 'Chrome';
+      var canDisableAttribute = canDisableAttributeZero || location !== 0;
+
+      if (_enable || canDisableAttribute) {
+        location = Number(location);
+        this.bind(function () {
+          return _enable ? _this3.gl.enableVertexAttribArray(location) : _this3.gl.disableVertexAttribArray(location);
+        });
+      }
+
+      return this;
+    }
+  }]);
+  return WEBGLVertexArrayObject;
+}(_webglResource.default, Symbol.toStringTag);
+
+exports.default = WEBGLVertexArrayObject;
+//# sourceMappingURL=webgl-vertex-array-object.js.map

package/dist/es5/adapter/objects/webgl-vertex-array-object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/adapter/objects/webgl-vertex-array-object.ts"],"names":["ERR_ELEMENTS","WEBGLVertexArrayObject","device","props","gl2","createVertexArray","deleteVertexArray","handle","elements","bindVertexArray","elementBuffer","opts","target","GL","ELEMENT_ARRAY_BUFFER","bind","gl","bindBuffer","location","buffer","accessor","setElementBuffer","size","type","stride","offset","normalized","integer","divisor","Number","ARRAY_BUFFER","assertWebGL2","vertexAttribIPointer","vertexAttribPointer","enableVertexAttribArray","vertexAttribDivisor","enable","canDisableAttributeZero","isWebGL2","canDisableAttribute","disableVertexAttribArray","WebGLResource","Symbol","toStringTag"],"mappings":"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","sourcesContent":["import {assert, ResourceProps} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {getBrowser} from '@probe.gl/env';\n\nimport WebGLDevice from '../webgl-device';\nimport WebGLResource from './webgl-resource';\n\nimport Buffer from '../resources/webgl-buffer';\n\nconst ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';\n\n/**\n * VertexArrayObject properties\n */\nexport type VertexArrayObjectProps = ResourceProps & {\n};\n\n/** VertexArrayObject wrapper */\nexport default class WEBGLVertexArrayObject extends WebGLResource<VertexArrayObjectProps> {\n  get [Symbol.toStringTag](): string {\n    return 'BaseVertexArrayObject';\n  }\n\n  constructor(device: WebGLDevice, props?: VertexArrayObjectProps) {\n    // @ts-expect-error\n    super(device, props, {});\n  }\n\n  _createHandle() {\n    return this.gl2.createVertexArray();\n  }\n\n  _deleteHandle(): void {\n    this.gl2.deleteVertexArray(this.handle);\n    // @ts-expect-error\n    return [this.elements];\n    // return [this.elements, ...this.buffers];\n  }\n\n  _bindHandle(handle: WEBGLVertexArrayObject): void {\n    this.gl2.bindVertexArray(handle);\n  }\n\n  // Set (bind) an elements buffer, for indexed rendering.\n  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported\n  setElementBuffer(elementBuffer: Buffer = null, opts = {}) {\n    assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);\n\n    // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...\n    this.bind(() => {\n      this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);\n    });\n\n    return this;\n  }\n\n  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */\n  setBuffer(location: number, buffer: Buffer, accessor: any): this {\n    // Check target\n    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {\n      return this.setElementBuffer(buffer, accessor);\n    }\n\n    const {size, type, stride, offset, normalized, integer, divisor} = accessor;\n\n    const {gl, gl2} = this;\n    location = Number(location);\n\n    this.bind(() => {\n      // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target\n      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);\n\n      // WebGL2 supports *integer* data formats, i.e. GPU will see integer values\n      if (integer) {\n        this.device.assertWebGL2();\n        gl2.vertexAttribIPointer(location, size, type, stride, offset);\n      } else {\n        // Attaches ARRAY_BUFFER with specified buffer format to location\n        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);\n      }\n      gl.enableVertexAttribArray(location);\n      gl2.vertexAttribDivisor(location, divisor || 0);\n\n      // NOTE We don't unbind buffer here, typically another buffer will be bound just after\n    });\n\n    return this;\n  }\n\n  /**\n   * Enabling an attribute location makes it reference the currently bound buffer\n   *  Disabling an attribute location makes it reference the global constant value\n   * TODO - handle single values for size 1 attributes?\n   * TODO - convert classic arrays based on known type?\n   */\n  enable(location: number, enable = true): this {\n    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers...\n    const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === 'Chrome';\n    const canDisableAttribute = canDisableAttributeZero || location !== 0;\n\n    if (enable || canDisableAttribute) {\n      location = Number(location);\n      this.bind(() =>\n        enable\n          ? this.gl.enableVertexAttribArray(location)\n          : this.gl.disableVertexAttribArray(location)\n      );\n    }\n    return this;\n  }\n}\n"],"file":"webgl-vertex-array-object.js"}

package/dist/es5/adapter/resources/webgl-buffer.js

@@ -0,0 +1,243 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _api = require("@luma.gl/api");
+
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var DEBUG_DATA_LENGTH = 10;
+
+var WEBGLBuffer = function (_Buffer) {
+  (0, _inherits2.default)(WEBGLBuffer, _Buffer);
+
+  var _super = _createSuper(WEBGLBuffer);
+
+  function WEBGLBuffer(device) {
+    var _this;
+
+    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2.default)(this, WEBGLBuffer);
+    _this = _super.call(this, device, props);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "device", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl2", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "handle", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "target", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "byteLength", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "bytesUsed", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "debugData", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webglUsage", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "accessor", void 0);
+    _this.device = device;
+    _this.gl = _this.device.gl;
+    _this.gl2 = _this.device.gl2;
+    var handle = (0, _typeof2.default)(props) === 'object' ? props.handle : undefined;
+    _this.handle = handle || _this.gl.createBuffer();
+    _this.handle.__SPECTOR_Metadata = _objectSpread(_objectSpread({}, _this.props), {}, {
+      data: (0, _typeof2.default)(_this.props.data)
+    });
+    _this.target = _this.props.target || getWebGLTarget(_this.props.usage);
+    _this.webglUsage = _this.props.webglUsage || getWebGLUsage(_this.props.usage);
+    _this.debugData = null;
+
+    if (props.data) {
+      _this._initWithData(props.data, props.byteOffset, props.byteLength);
+    } else {
+      _this._initWithByteLength(props.byteLength || 0);
+    }
+
+    return _this;
+  }
+
+  (0, _createClass2.default)(WEBGLBuffer, [{
+    key: "_initWithData",
+    value: function _initWithData(data) {
+      var byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var byteLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : data.byteLength + byteOffset;
+      (0, _api.assert)(ArrayBuffer.isView(data));
+
+      var target = this._getWriteTarget();
+
+      this.gl.bindBuffer(target, this.handle);
+      this.gl.bufferData(target, byteLength, this.webglUsage);
+      this.gl.bufferSubData(target, byteOffset, data);
+      this.gl.bindBuffer(target, null);
+      this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
+      this.bytesUsed = byteLength;
+      this.byteLength = byteLength;
+      this.trackAllocatedMemory(byteLength);
+      return this;
+    }
+  }, {
+    key: "_initWithByteLength",
+    value: function _initWithByteLength(byteLength) {
+      (0, _api.assert)(byteLength >= 0);
+      var data = byteLength;
+
+      if (byteLength === 0) {
+        data = new Float32Array(0);
+      }
+
+      var target = this._getWriteTarget();
+
+      this.gl.bindBuffer(target, this.handle);
+      this.gl.bufferData(target, data, this.webglUsage);
+      this.gl.bindBuffer(target, null);
+      this.debugData = null;
+      this.bytesUsed = byteLength;
+      this.byteLength = byteLength;
+      return this;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this.handle) {
+        this.removeStats();
+        this.trackDeallocatedMemory();
+        this.gl.deleteBuffer(this.handle);
+        this.handle = null;
+      }
+    }
+  }, {
+    key: "write",
+    value: function write(data) {
+      var byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var srcOffset = 0;
+      var byteLength = data.byteLength;
+      var target = this.device.isWebGL2 ? _constants.default.COPY_WRITE_BUFFER : this.target;
+      this.gl.bindBuffer(target, this.handle);
+
+      if (srcOffset !== 0 || byteLength !== undefined) {
+        this.device.assertWebGL2();
+        this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
+      } else {
+        this.gl.bufferSubData(target, byteOffset, data);
+      }
+
+      this.gl.bindBuffer(target, null);
+    }
+  }, {
+    key: "readAsync",
+    value: function () {
+      var _readAsync = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+        var byteOffset,
+            byteLength,
+            data,
+            dstOffset,
+            _args = arguments;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                byteOffset = _args.length > 0 && _args[0] !== undefined ? _args[0] : 0;
+                byteLength = _args.length > 1 ? _args[1] : undefined;
+                this.device.assertWebGL2();
+                data = new Uint8Array(byteLength);
+                dstOffset = 0;
+                this.gl.bindBuffer(_constants.default.COPY_READ_BUFFER, this.handle);
+                this.gl2.getBufferSubData(_constants.default.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
+                this.gl.bindBuffer(_constants.default.COPY_READ_BUFFER, null);
+                return _context.abrupt("return", data);
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function readAsync() {
+        return _readAsync.apply(this, arguments);
+      }
+
+      return readAsync;
+    }()
+  }, {
+    key: "_invalidateDebugData",
+    value: function _invalidateDebugData() {
+      this.debugData = null;
+    }
+  }, {
+    key: "_getWriteTarget",
+    value: function _getWriteTarget() {
+      return this.target;
+    }
+  }, {
+    key: "_getReadTarget",
+    value: function _getReadTarget() {
+      return this.target;
+      return this.device.isWebGL2 ? _constants.default.COPY_READ_BUFFER : this.target;
+    }
+  }]);
+  return WEBGLBuffer;
+}(_api.Buffer);
+
+exports.default = WEBGLBuffer;
+
+function getWebGLTarget(usage) {
+  if (usage & _api.Buffer.INDEX) {
+    return _constants.default.ELEMENT_ARRAY_BUFFER;
+  }
+
+  if (usage & _api.Buffer.VERTEX) {
+    return _constants.default.ARRAY_BUFFER;
+  }
+
+  if (usage & _api.Buffer.UNIFORM) {
+    return _constants.default.UNIFORM_BUFFER;
+  }
+
+  return _constants.default.ARRAY_BUFFER;
+}
+
+function getWebGLUsage(usage) {
+  if (usage & _api.Buffer.INDEX) {
+    return _constants.default.STATIC_DRAW;
+  }
+
+  if (usage & _api.Buffer.VERTEX) {
+    return _constants.default.STATIC_DRAW;
+  }
+
+  if (usage & _api.Buffer.UNIFORM) {
+    return _constants.default.DYNAMIC_DRAW;
+  }
+
+  return _constants.default.DYNAMIC_DRAW;
+}
+//# sourceMappingURL=webgl-buffer.js.map

package/dist/es5/adapter/resources/webgl-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/adapter/resources/webgl-buffer.ts"],"names":["DEBUG_DATA_LENGTH","WEBGLBuffer","device","props","gl","gl2","handle","undefined","createBuffer","__SPECTOR_Metadata","data","target","getWebGLTarget","usage","webglUsage","getWebGLUsage","debugData","_initWithData","byteOffset","byteLength","_initWithByteLength","ArrayBuffer","isView","_getWriteTarget","bindBuffer","bufferData","bufferSubData","slice","bytesUsed","trackAllocatedMemory","Float32Array","removeStats","trackDeallocatedMemory","deleteBuffer","srcOffset","isWebGL2","GL","COPY_WRITE_BUFFER","assertWebGL2","offset","Uint8Array","dstOffset","COPY_READ_BUFFER","getBufferSubData","Buffer","INDEX","ELEMENT_ARRAY_BUFFER","VERTEX","ARRAY_BUFFER","UNIFORM","UNIFORM_BUFFER","STATIC_DRAW","DYNAMIC_DRAW"],"mappings":"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","sourcesContent":["import type {BufferProps} from '@luma.gl/api';\nimport {Buffer, assert} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport WebGLDevice from '../webgl-device';\n\nconst DEBUG_DATA_LENGTH = 10;\n\n/** WebGL Buffer interface */\nexport default class WEBGLBuffer extends Buffer {\n  readonly device: WebGLDevice;\n  readonly gl: WebGLRenderingContext;\n  readonly gl2: WebGL2RenderingContext | null;\n  readonly handle: WebGLBuffer;\n  readonly target: number;\n\n  byteLength: number;\n  bytesUsed: number;\n  debugData: ArrayBuffer;\n\n  webglUsage: number;\n\n  accessor: {};\n\n  constructor(device: WebGLDevice, props: BufferProps = {}) {\n    super(device, props);\n\n    this.device = device;\n    this.gl = this.device.gl;\n    this.gl2 = this.device.gl2;\n\n    const handle = typeof props === 'object' ? (props as BufferProps).handle : undefined;\n    this.handle = handle || this.gl.createBuffer();\n    // @ts-expect-error Add metadata for spector\n    this.handle.__SPECTOR_Metadata = {...this.props, data: typeof this.props.data}; // {name: this.props.id};\n\n    // In WebGL1, need to make sure we use GL.ELEMENT_ARRAY_BUFFER when initializing element buffers\n    // otherwise buffer type will lock to generic (non-element) buffer\n    // In WebGL2, we can use GL.COPY_READ_BUFFER which avoids locking the type here\n    // @ts-expect-error Hack - Checking for subclass prop\n    this.target = this.props.target || getWebGLTarget(this.props.usage);\n    // @ts-expect-error Hack - Checking for subclass prop\n    this.webglUsage = this.props.webglUsage || getWebGLUsage(this.props.usage);\n    this.debugData = null;\n\n    // Set data: (re)initializes the buffer\n    if (props.data) {\n      this._initWithData(props.data, props.byteOffset, props.byteLength);\n    } else {\n      this._initWithByteLength(props.byteLength || 0);\n    }\n\n    // Deprecated: Merge main props and accessor\n    // this.accessor = {...props.accessor};\n\n    // Object.seal(this);\n  }\n\n   // PRIVATE METHODS\n\n  // Allocate a new buffer and initialize to contents of typed array\n  _initWithData(data, byteOffset: number = 0, byteLength: number = data.byteLength + byteOffset): this {\n    assert(ArrayBuffer.isView(data));\n\n    const target = this._getWriteTarget();\n\n    this.gl.bindBuffer(target, this.handle);\n    this.gl.bufferData(target, byteLength, this.webglUsage);\n    this.gl.bufferSubData(target, byteOffset, data);\n    this.gl.bindBuffer(target, null);\n\n    this.debugData = data.slice(0, DEBUG_DATA_LENGTH);\n    this.bytesUsed = byteLength;\n    this.byteLength = byteLength;\n    this.trackAllocatedMemory(byteLength);\n\n    return this;\n  }\n\n  // Allocate a GPU buffer of specified size.\n  _initWithByteLength(byteLength: number): this {\n    assert(byteLength >= 0);\n\n    // Workaround needed for Safari (#291):\n    // gl.bufferData with size equal to 0 crashes. Instead create zero sized array.\n    let data = byteLength;\n    if (byteLength === 0) {\n      // @ts-expect-error\n      data = new Float32Array(0);\n    }\n\n    const target = this._getWriteTarget();\n\n    this.gl.bindBuffer(target, this.handle);\n    this.gl.bufferData(target, data, this.webglUsage);\n    this.gl.bindBuffer(target, null);\n\n    this.debugData = null;\n    this.bytesUsed = byteLength;\n    this.byteLength = byteLength;\n\n    return this;\n  }\n\n  destroy(): void {\n    if (this.handle) {\n      this.removeStats();\n      this.trackDeallocatedMemory();\n      this.gl.deleteBuffer(this.handle);\n      // @ts-expect-error\n      this.handle = null;\n    }\n  }\n\n  write(data: ArrayBufferView, byteOffset: number = 0): void {\n    const srcOffset = 0;\n    const byteLength = data.byteLength;\n\n    // Create the buffer - binding it here for the first time locks the type\n    // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type\n    const target = this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.target;\n    this.gl.bindBuffer(target, this.handle);\n    // WebGL2: subData supports additional srcOffset and length parameters\n    if (srcOffset !== 0 || byteLength !== undefined) {\n      this.device.assertWebGL2();\n\n      // @ts-expect-error\n      this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);\n    } else {\n      this.gl.bufferSubData(target, byteOffset, data);\n    }\n    this.gl.bindBuffer(target, null);\n\n    // TODO - update local `data` if offsets are right\n    // this.debugData = data.slice(byteOffset, 40);\n  }\n\n  /** Read data from the buffer */\n  async readAsync(\n    byteOffset: number = 0,\n    byteLength?: number\n  ): Promise<ArrayBuffer> {\n    this.device.assertWebGL2();\n\n    const data = new Uint8Array(byteLength);\n    const dstOffset = 0;\n\n    // Use GL.COPY_READ_BUFFER to avoid disturbing other targets and locking type\n    this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);\n    this.gl2.getBufferSubData(GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);\n    this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);\n\n    // TODO - update local `data` if offsets are 0\n    // this.debugData = null;\n\n    return data;\n  }\n\n  // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)\n\n  _invalidateDebugData() {\n    this.debugData = null;\n  }\n\n  _getWriteTarget() {\n    return this.target;\n    // return this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.target;\n  }\n\n  _getReadTarget() {\n    return this.target;\n    return this.device.isWebGL2 ? GL.COPY_READ_BUFFER : this.target;\n  }\n}\n\n// static MAP_READ = 0x01;\n// static MAP_WRITE = 0x02;\n// static COPY_SRC = 0x0004;\n// static COPY_DST = 0x0008;\n// static INDEX = 0x0010;\n// static VERTEX = 0x0020;\n// static UNIFORM = 0x0040;\n// static STORAGE = 0x0080;\n// static INDIRECT = 0x0100;\n// static QUERY_RESOLVE = 0x0200;\n\nfunction getWebGLTarget(usage: number): GL {\n  if (usage & Buffer.INDEX) {\n    return GL.ELEMENT_ARRAY_BUFFER;\n  }\n  if (usage & Buffer.VERTEX) {\n    return GL.ARRAY_BUFFER;\n  }\n  if (usage & Buffer.UNIFORM) {\n    return GL.UNIFORM_BUFFER;\n  }\n\n  // gl.COPY_READ_BUFFER: Buffer for copying from one buffer object to another.\n  // gl.COPY_WRITE_BUFFER: Buffer for copying from one buffer object to another.\n  // gl.TRANSFORM_FEEDBACK_BUFFER: Buffer for transform feedback operations.\n  // gl.PIXEL_PACK_BUFFER: Buffer used for pixel transfer operations.\n  // gl.PIXEL_UNPACK_BUFFER: Buffer used for pixel transfer operations.\n\n  // Binding a buffer for the first time locks the type\n  // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type\n  return GL.ARRAY_BUFFER;\n}\n\nfunction getWebGLUsage(usage: number): GL {\n  if (usage & Buffer.INDEX) {\n    return GL.STATIC_DRAW;\n  }\n  if (usage & Buffer.VERTEX) {\n    return GL.STATIC_DRAW;\n  }\n  if (usage & Buffer.UNIFORM) {\n    return GL.DYNAMIC_DRAW;\n  }\n  return GL.DYNAMIC_DRAW;\n}\n"],"file":"webgl-buffer.js"}

package/dist/es5/adapter/resources/webgl-command-buffer.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.submitCommands = submitCommands;
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function cast(value) {
+  return value;
+}
+
+var CommandBuffer = function CommandBuffer() {
+  (0, _classCallCheck2.default)(this, CommandBuffer);
+  (0, _defineProperty2.default)(this, "commands", []);
+};
+
+exports.default = CommandBuffer;
+
+function submitCommands(device) {
+  var commands = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  var _iterator = _createForOfIteratorHelper(commands),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var command = _step.value;
+
+      switch (command.name) {
+        case 'copy-buffer-to-buffer':
+          _copyBufferToBuffer(device, command.options);
+
+          break;
+
+        case 'copy-buffer-to-texture':
+          _copyBufferToTexture(device, command.options);
+
+          break;
+
+        case 'copy-texture-to-buffer':
+          _copyTextureToBuffer(device, command.options);
+
+          break;
+
+        case 'copy-texture-to-texture':
+          _copyTextureToTexture(device, command.options);
+
+          break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function _copyBufferToBuffer(device, options) {
+  var source = cast(options.source);
+  var destination = cast(options.destination);
+  var gl2 = device.gl2;
+
+  if (gl2) {
+    var _options$sourceOffset, _options$destinationO;
+
+    gl2.bindBuffer(_constants.default.COPY_READ_BUFFER, source.handle);
+    gl2.bindBuffer(_constants.default.COPY_WRITE_BUFFER, destination.handle);
+    gl2.copyBufferSubData(_constants.default.COPY_READ_BUFFER, _constants.default.COPY_WRITE_BUFFER, (_options$sourceOffset = options.sourceOffset) !== null && _options$sourceOffset !== void 0 ? _options$sourceOffset : 0, (_options$destinationO = options.destinationOffset) !== null && _options$destinationO !== void 0 ? _options$destinationO : 0, options.size);
+    gl2.bindBuffer(_constants.default.COPY_READ_BUFFER, null);
+    gl2.bindBuffer(_constants.default.COPY_WRITE_BUFFER, null);
+  } else {
+    throw new Error('copyBufferToBuffer not implemented in WebGL1');
+  }
+}
+
+function _copyBufferToTexture(device, options) {}
+
+function _copyTextureToBuffer(device, options) {}
+
+function _copyTextureToTexture(device, options) {}
+//# sourceMappingURL=webgl-command-buffer.js.map

package/dist/es5/adapter/resources/webgl-command-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/adapter/resources/webgl-command-buffer.ts"],"names":["cast","value","CommandBuffer","submitCommands","device","commands","command","name","_copyBufferToBuffer","options","_copyBufferToTexture","_copyTextureToBuffer","_copyTextureToTexture","source","destination","gl2","bindBuffer","GL","COPY_READ_BUFFER","handle","COPY_WRITE_BUFFER","copyBufferSubData","sourceOffset","destinationOffset","size","Error"],"mappings":";;;;;;;;;;;;;;AAMA;;;;;;;;AAIA,SAASA,IAAT,CAAiBC,KAAjB,EAAoC;AAClC,SAAOA,KAAP;AACD;;IA4BoBC,a;;kDACG,E;;;;;AAGjB,SAASC,cAAT,CAAwBC,MAAxB,EAAuE;AAAA,MAA1BC,QAA0B,uEAAJ,EAAI;;AAAA,6CACtDA,QADsD;AAAA;;AAAA;AAC5E,wDAAgC;AAAA,UAArBC,OAAqB;;AAC9B,cAAQA,OAAO,CAACC,IAAhB;AACE,aAAK,uBAAL;AACEC,UAAAA,mBAAmB,CAACJ,MAAD,EAASE,OAAO,CAACG,OAAjB,CAAnB;;AACA;;AACF,aAAK,wBAAL;AACEC,UAAAA,oBAAoB,CAACN,MAAD,EAASE,OAAO,CAACG,OAAjB,CAApB;;AACA;;AACF,aAAK,wBAAL;AACEE,UAAAA,oBAAoB,CAACP,MAAD,EAASE,OAAO,CAACG,OAAjB,CAApB;;AACA;;AACF,aAAK,yBAAL;AACEG,UAAAA,qBAAqB,CAACR,MAAD,EAASE,OAAO,CAACG,OAAjB,CAArB;;AACA;AAZJ;AAcD;AAhB2E;AAAA;AAAA;AAAA;AAAA;AAiB7E;;AAED,SAASD,mBAAT,CAA6BJ,MAA7B,EAAkDK,OAAlD,EAA4F;AAC1F,MAAMI,MAAM,GAAGb,IAAI,CAAcS,OAAO,CAACI,MAAtB,CAAnB;AACA,MAAMC,WAAW,GAAGd,IAAI,CAAcS,OAAO,CAACK,WAAtB,CAAxB;AAEA,MAAOC,GAAP,GAAcX,MAAd,CAAOW,GAAP;;AACA,MAAIA,GAAJ,EAAS;AAAA;;AAGPA,IAAAA,GAAG,CAACC,UAAJ,CAAeC,mBAAGC,gBAAlB,EAAoCL,MAAM,CAACM,MAA3C;AACAJ,IAAAA,GAAG,CAACC,UAAJ,CAAeC,mBAAGG,iBAAlB,EAAqCN,WAAW,CAACK,MAAjD;AACAJ,IAAAA,GAAG,CAACM,iBAAJ,CACEJ,mBAAGC,gBADL,EAEED,mBAAGG,iBAFL,2BAGEX,OAAO,CAACa,YAHV,yEAG0B,CAH1B,2BAIEb,OAAO,CAACc,iBAJV,yEAI+B,CAJ/B,EAKEd,OAAO,CAACe,IALV;AAOAT,IAAAA,GAAG,CAACC,UAAJ,CAAeC,mBAAGC,gBAAlB,EAAoC,IAApC;AACAH,IAAAA,GAAG,CAACC,UAAJ,CAAeC,mBAAGG,iBAAlB,EAAqC,IAArC;AACD,GAdD,MAcO;AAGL,UAAM,IAAIK,KAAJ,CAAU,8CAAV,CAAN;AACD;AACF;;AAED,SAASf,oBAAT,CAA8BN,MAA9B,EAAmDK,OAAnD,EAA8F,CAAE;;AAEhG,SAASE,oBAAT,CAA8BP,MAA9B,EAAmDK,OAAnD,EAA8F,CAAE;;AAEhG,SAASG,qBAAT,CAA+BR,MAA/B,EAAoDK,OAApD,EAAgG,CAAE","sourcesContent":["import type {\n  CopyBufferToBufferOptions,\n  CopyBufferToTextureOptions,\n  CopyTextureToBufferOptions,\n  CopyTextureToTextureOptions\n} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport WebGLDevice from '../webgl-device';\nimport WEBGLBuffer from './webgl-buffer';\n\nfunction cast<T>(value: unknown): T {\n  return value as T;\n}\n\ntype CopyBufferToBufferCommand = {\n  name: 'copy-buffer-to-buffer';\n  options: CopyBufferToBufferOptions;\n};\n\ntype CopyBufferToTextureCommand = {\n  name: 'copy-buffer-to-texture';\n  options: CopyBufferToTextureOptions;\n};\n\ntype CopyTextureToBufferCommand = {\n  name: 'copy-texture-to-buffer';\n  options: CopyTextureToBufferOptions;\n};\n\ntype CopyTextureToTextureCommand = {\n  name: 'copy-texture-to-texture';\n  options: CopyTextureToTextureOptions;\n};\n\ntype Command =\n  | CopyBufferToBufferCommand\n  | CopyBufferToTextureCommand\n  | CopyTextureToBufferCommand\n  | CopyTextureToTextureCommand;\n\nexport default class CommandBuffer {\n  commands: Command[] = [];\n}\n\nexport function submitCommands(device: WebGLDevice, commands: Command[] = []) {\n  for (const command of commands) {\n    switch (command.name) {\n      case 'copy-buffer-to-buffer':\n        _copyBufferToBuffer(device, command.options);\n        break;\n      case 'copy-buffer-to-texture':\n        _copyBufferToTexture(device, command.options);\n        break;\n      case 'copy-texture-to-buffer':\n        _copyTextureToBuffer(device, command.options);\n        break;\n      case 'copy-texture-to-texture':\n        _copyTextureToTexture(device, command.options);\n        break;\n    }\n  }\n}\n\nfunction _copyBufferToBuffer(device: WebGLDevice, options: CopyBufferToBufferOptions): void {\n  const source = cast<WEBGLBuffer>(options.source);\n  const destination = cast<WEBGLBuffer>(options.destination);\n\n  const {gl2} = device;\n  if (gl2) {\n    // In WebGL2 we can perform the copy on the GPU\n    // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type\n    gl2.bindBuffer(GL.COPY_READ_BUFFER, source.handle);\n    gl2.bindBuffer(GL.COPY_WRITE_BUFFER, destination.handle);\n    gl2.copyBufferSubData(\n      GL.COPY_READ_BUFFER,\n      GL.COPY_WRITE_BUFFER,\n      options.sourceOffset ?? 0,\n      options.destinationOffset ?? 0,\n      options.size\n    );\n    gl2.bindBuffer(GL.COPY_READ_BUFFER, null);\n    gl2.bindBuffer(GL.COPY_WRITE_BUFFER, null);\n  } else {\n    // TODO - in WebGL1 we would have to read back to CPU\n    // read / write buffer from / to CPU\n    throw new Error('copyBufferToBuffer not implemented in WebGL1');\n  }\n}\n\nfunction _copyBufferToTexture(device: WebGLDevice, options: CopyBufferToTextureOptions): void {}\n\nfunction _copyTextureToBuffer(device: WebGLDevice, options: CopyTextureToBufferOptions): void {}\n\nfunction _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextureOptions): void {}\n"],"file":"webgl-command-buffer.js"}

package/dist/es5/adapter/resources/webgl-command-encoder.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _api = require("@luma.gl/api");
+
+var _webglCommandBuffer = _interopRequireDefault(require("./webgl-command-buffer"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var WEBGLCommandEncoder = function (_CommandEncoder) {
+  (0, _inherits2.default)(WEBGLCommandEncoder, _CommandEncoder);
+
+  var _super = _createSuper(WEBGLCommandEncoder);
+
+  function WEBGLCommandEncoder(device, props) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, WEBGLCommandEncoder);
+    _this = _super.call(this, props);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "device", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "commandBuffer", new _webglCommandBuffer.default());
+    _this.device = device;
+    return _this;
+  }
+
+  (0, _createClass2.default)(WEBGLCommandEncoder, [{
+    key: "destroy",
+    value: function destroy() {}
+  }, {
+    key: "copyBufferToBuffer",
+    value: function copyBufferToBuffer(options) {
+      this.commandBuffer.commands.push({
+        name: 'copy-buffer-to-buffer',
+        options: options
+      });
+    }
+  }, {
+    key: "copyBufferToTexture",
+    value: function copyBufferToTexture(options) {
+      this.commandBuffer.commands.push({
+        name: 'copy-buffer-to-texture',
+        options: options
+      });
+    }
+  }, {
+    key: "copyTextureToBuffer",
+    value: function copyTextureToBuffer(options) {
+      this.commandBuffer.commands.push({
+        name: 'copy-texture-to-buffer',
+        options: options
+      });
+    }
+  }, {
+    key: "copyTextureToTexture",
+    value: function copyTextureToTexture(options) {
+      this.commandBuffer.commands.push({
+        name: 'copy-texture-to-texture',
+        options: options
+      });
+    }
+  }, {
+    key: "pushDebugGroup",
+    value: function pushDebugGroup(groupLabel) {}
+  }, {
+    key: "popDebugGroup",
+    value: function popDebugGroup() {}
+  }, {
+    key: "insertDebugMarker",
+    value: function insertDebugMarker(markerLabel) {}
+  }]);
+  return WEBGLCommandEncoder;
+}(_api.CommandEncoder);
+
+exports.default = WEBGLCommandEncoder;
+;
+//# sourceMappingURL=webgl-command-encoder.js.map

package/dist/es5/adapter/resources/webgl-command-encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/adapter/resources/webgl-command-encoder.ts"],"names":["WEBGLCommandEncoder","device","props","CommandBuffer","options","commandBuffer","commands","push","name","groupLabel","markerLabel","CommandEncoder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAQA;;;;;;IAGqBA,mB;;;;;AAKnB,+BAAYC,MAAZ,EAAiCC,KAAjC,EAA6D;AAAA;;AAAA;AAC3D,8BAAMA,KAAN;AAD2D;AAAA,gGAFpC,IAAIC,2BAAJ,EAEoC;AAE3D,UAAKF,MAAL,GAAcA,MAAd;AAF2D;AAG5D;;;;WAED,mBAAU,CAAE;;;WAMZ,4BAAmBG,OAAnB,EAA6D;AAC3D,WAAKC,aAAL,CAAmBC,QAAnB,CAA4BC,IAA5B,CAAiC;AAACC,QAAAA,IAAI,EAAE,uBAAP;AAAgCJ,QAAAA,OAAO,EAAPA;AAAhC,OAAjC;AACD;;;WAED,6BAAoBA,OAApB,EAAyD;AACvD,WAAKC,aAAL,CAAmBC,QAAnB,CAA4BC,IAA5B,CAAiC;AAACC,QAAAA,IAAI,EAAE,wBAAP;AAAiCJ,QAAAA,OAAO,EAAPA;AAAjC,OAAjC;AACD;;;WAED,6BAAoBA,OAApB,EAA+D;AAC7D,WAAKC,aAAL,CAAmBC,QAAnB,CAA4BC,IAA5B,CAAiC;AAACC,QAAAA,IAAI,EAAE,wBAAP;AAAiCJ,QAAAA,OAAO,EAAPA;AAAjC,OAAjC;AACD;;;WAED,8BAAqBA,OAArB,EAAiE;AAC/D,WAAKC,aAAL,CAAmBC,QAAnB,CAA4BC,IAA5B,CAAiC;AAACC,QAAAA,IAAI,EAAE,yBAAP;AAAkCJ,QAAAA,OAAO,EAAPA;AAAlC,OAAjC;AACD;;;WAED,wBAAeK,UAAf,EAAyC,CAAE;;;WAC3C,yBAAgB,CAAE;;;WAElB,2BAAkBC,WAAlB,EAA6C,CAAE;;;EAnCAC,mB;;;AA8ChD","sourcesContent":["import {CommandEncoder, CommandEncoderProps} from '@luma.gl/api';\nimport type {\n  CopyBufferToBufferOptions,\n  CopyBufferToTextureOptions,\n  CopyTextureToBufferOptions,\n  CopyTextureToTextureOptions\n} from '@luma.gl/api';\n\nimport CommandBuffer from './webgl-command-buffer';\nimport WebGLDevice from '../webgl-device';\n\nexport default class WEBGLCommandEncoder extends CommandEncoder {\n  readonly device: WebGLDevice;\n\n  readonly commandBuffer = new CommandBuffer();\n\n  constructor(device: WebGLDevice, props: CommandEncoderProps) {\n    super(props);\n    this.device = device;\n  }\n\n  destroy() {}\n\n  // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;\n  // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;\n  // finish(options?: {id?: string}): GPUCommandBuffer;\n\n  copyBufferToBuffer(options: CopyBufferToBufferOptions): void {\n    this.commandBuffer.commands.push({name: 'copy-buffer-to-buffer', options});\n  }\n\n  copyBufferToTexture(options: CopyBufferToTextureOptions) {\n    this.commandBuffer.commands.push({name: 'copy-buffer-to-texture', options});\n  }\n\n  copyTextureToBuffer(options: CopyTextureToBufferOptions): void {\n    this.commandBuffer.commands.push({name: 'copy-texture-to-buffer', options});\n  }\n\n  copyTextureToTexture(options: CopyTextureToTextureOptions): void {\n    this.commandBuffer.commands.push({name: 'copy-texture-to-texture', options});\n  }\n\n  pushDebugGroup(groupLabel: string): void {}\n  popDebugGroup() {}\n\n  insertDebugMarker(markerLabel: string): void {}\n\n  // writeTimestamp(querySet: Query, queryIndex: number): void {}\n\n  // resolveQuerySet(options: {\n  //   querySet: GPUQuerySet,\n  //   firstQuery: number,\n  //   queryCount: number,\n  //   destination: Buffer,\n  //   destinationOffset?: number;\n  // }): void;\n};\n"],"file":"webgl-command-encoder.js"}

package/dist/es5/adapter/resources/webgl-external-texture.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=webgl-external-texture.js.map

package/dist/{esm/helpers/program-bindings.js.map → es5/adapter/resources/webgl-external-texture.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"program-bindings.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"webgl-external-texture.js"}