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

package/dist/es5/adapter/webgl-device.js

@@ -5,9 +5,12 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getWebGLDevice = getWebGLDevice;
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -24,17 +27,13 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _api = require("@luma.gl/api");
 
+var _env = require("@probe.gl/env");
+
 var _polyfillContext = require("../context/polyfill/polyfill-context");
 
 var _trackContextState = require("../context/state-tracker/track-context-state");
 
-var _devicePixels = require("../context/context/device-pixels");
-
-var _createContext2 = require("../context/context/create-context");
-
-var _getCanvas = require("../context/context/get-canvas");
-
-var _webglChecks = require("../context/context/webgl-checks");
+var _createContext = require("../context/context/create-context");
 
 var _getDeviceInfo = require("./device-helpers/get-device-info");
 
@@ -42,11 +41,27 @@ var _deviceFeatures = require("./device-helpers/device-features");
 
 var _deviceLimits = require("./device-helpers/device-limits");
 
-var _webglBuffer = _interopRequireDefault(require("../classes/webgl-buffer"));
+var _webglCanvasContext = _interopRequireDefault(require("./webgl-canvas-context"));
+
+var _spector = require("../context/debug/spector");
+
+var _webglDeveloperTools = require("../context/debug/webgl-developer-tools");
+
+var _textureFormats = require("./converters/texture-formats");
+
+var _buffer = _interopRequireDefault(require("../classic/buffer"));
+
+var _webglShader = _interopRequireDefault(require("./resources/webgl-shader"));
+
+var _webglSampler = _interopRequireDefault(require("./resources/webgl-sampler"));
 
-var _webglShader = require("../adapter/webgl-shader");
+var _webglTexture = _interopRequireDefault(require("./resources/webgl-texture"));
 
-var _texture2d = _interopRequireDefault(require("../classes/texture-2d"));
+var _webglFramebuffer = _interopRequireDefault(require("./resources/webgl-framebuffer"));
+
+var _webglRenderPass = _interopRequireDefault(require("./resources/webgl-render-pass"));
+
+var _webglRenderPipeline = _interopRequireDefault(require("./resources/webgl-render-pipeline"));
 
 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; }
 
@@ -56,36 +71,7 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 
 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 DEFAULT_DEVICE_PROPS = {
-  canvas: undefined,
-  gl: undefined,
-  webgl2: true,
-  webgl1: true,
-  manageState: true,
-  width: 800,
-  height: 600,
-  debug: false,
-  break: undefined,
-  onContextLost: function onContextLost() {
-    return console.error('WebGL context lost');
-  },
-  onContextRestored: function onContextRestored() {
-    return console.info('WebGL context restored');
-  },
-  alpha: undefined,
-  depth: undefined,
-  stencil: undefined,
-  antialias: undefined,
-  premultipliedAlpha: undefined,
-  preserveDrawingBuffer: undefined,
-  failIfMajorPerformanceCaveat: undefined
-};
-var glToContextMap = new WeakMap();
-
-function getWebGLDevice(gl) {
-  return glToContextMap.get(gl);
-}
-
+var LOG_LEVEL = 1;
 var counter = 0;
 
 var WebGLDevice = function (_Device) {
@@ -94,27 +80,24 @@ var WebGLDevice = function (_Device) {
   var _super = _createSuper(WebGLDevice);
 
   function WebGLDevice(props) {
-    var _this$props$gl;
+    var _props$gl;
 
     var _this;
 
     (0, _classCallCheck2.default)(this, WebGLDevice);
-    _this = _super.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "features", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "limits", void 0);
+    _this = _super.call(this, props);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "info", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "canvasContext", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "lost", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "props", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "userData", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isWebGL2", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "handle", 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), "offScreen", false);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webglFeatures", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webglLimits", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "defaultFramebuffer", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "defaultVertexArray", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_state", 'uninitialized');
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "debug", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isWebGL1", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isWebGL2", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_features", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_limits", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_webglLimits", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_canvasSizeInfo", {
       clientWidth: 0,
       clientHeight: 0,
@@ -122,44 +105,26 @@ var WebGLDevice = function (_Device) {
     });
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_extensions", {});
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_polyfilled", false);
-    _this.props = _objectSpread(_objectSpread({}, DEFAULT_DEVICE_PROPS), props);
-    var device = (_this$props$gl = _this.props.gl) === null || _this$props$gl === void 0 ? void 0 : _this$props$gl.device;
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "spector", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "renderPass", void 0);
+    var device = (_props$gl = props.gl) === null || _props$gl === void 0 ? void 0 : _props$gl.device;
 
     if (device) {
-      if (device._state !== 'initialized') {
-        _api.log.error('recursive context');
-
-        throw new Error('recursive context');
-      }
+      _api.log.warn("WebGL context already attached to device ".concat(device.id));
 
       return (0, _possibleConstructorReturn2.default)(_this, device);
     }
 
-    _this.offScreen = typeof OffscreenCanvas !== 'undefined' && props.canvas instanceof OffscreenCanvas;
-    _this.gl = _this.props.gl || _this._createContext(props);
+    _this.canvasContext = new _webglCanvasContext.default((0, _assertThisInitialized2.default)(_this), props);
+    _this.handle = props.gl || (0, _createContext.createBrowserContext)(_this.canvasContext.canvas, props);
+    _this.gl = _this.handle;
     _this.gl2 = _this.gl;
-    _this.isWebGL2 = (0, _webglChecks.isWebGL2)(_this.gl);
-    _this._state = 'initializing';
-
-    if (_this.gl.device) {
-      _api.log.error('device already created');
-
-      throw new Error('device already created');
-    }
-
-    _this.gl.device = (0, _assertThisInitialized2.default)(_this);
-    _this.gl._version = typeof WebGL2RenderingContext !== 'undefined' && _this.gl instanceof WebGL2RenderingContext ? 2 : 1;
-    glToContextMap.set(_this.gl, (0, _assertThisInitialized2.default)(_this));
+    _this.isWebGL2 = isWebGL2(_this.gl);
+    _this.isWebGL1 = !_this.isWebGL2;
     _this.info = (0, _getDeviceInfo.getDeviceInfo)(_this.gl);
-    var debug = _this.gl.debug ? ' debug' : '';
-    var webGL = (0, _webglChecks.isWebGL2)(_this.gl) ? 'WebGL2' : 'WebGL1';
-
-    _api.log.group(0, "".concat(webGL).concat(debug, " context: ").concat(_this.info.vendor, ", ").concat(_this.info.renderer))();
-
+    _this.gl.device = (0, _assertThisInitialized2.default)(_this);
+    _this.gl._version = _this.isWebGL2 ? 2 : 1;
     (0, _polyfillContext.polyfillContext)(_this.gl);
-
-    _api.log.probe(0, 'polyfilled context')();
-
     (0, _trackContextState.trackContextState)(_this.gl, {
       copyState: false,
       log: function log() {
@@ -171,27 +136,53 @@ var WebGLDevice = function (_Device) {
       }
     });
 
-    _api.log.probe(0, 'instrumented context')();
-
-    _this.features = (0, _deviceFeatures.getDeviceFeatures)(_this.gl);
-
-    _api.log.probe(0, "queried device features ".concat(counter))();
+    if ((0, _env.isBrowser)() && props.debug) {
+      _this.gl = (0, _webglDeveloperTools.makeDebugContext)(_this.gl, _objectSpread(_objectSpread({}, props), {}, {
+        webgl2: _this.isWebGL2,
+        throwOnError: true
+      }));
+      _this.gl2 = _this.gl;
+      _this.debug = true;
+      _api.log.level = Math.max(_api.log.level, 1);
 
-    _this.limits = (0, _deviceLimits.getDeviceLimits)(_this.gl);
+      _api.log.warn('WebGL debug mode activated. Performance reduced.')();
+    }
 
-    _api.log.probe(0, 'queried device limits')();
+    if ((0, _env.isBrowser)() && props.spector) {
+      var canvas = _this.handle.canvas || props.canvas;
+      _this.spector = (0, _spector.initializeSpectorJS)(_objectSpread(_objectSpread({}, _this.props), {}, {
+        canvas: canvas
+      }));
+    }
 
-    _this.webglLimits = (0, _deviceLimits.getWebGLLimits)(_this.gl);
+    var message = "Created ".concat(_this.info.type).concat(_this.debug ? ' debug' : '', " context: ").concat(_this.info.vendor, ", ").concat(_this.info.renderer, " for canvas: ").concat(_this.canvasContext.id);
 
-    _api.log.probe(0, 'queried webgl limits')();
+    _api.log.probe(LOG_LEVEL, message)();
 
-    _api.log.groupEnd(0)();
+    _api.log.groupEnd(LOG_LEVEL)();
 
-    _this._state = 'initialized';
     return _this;
   }
 
   (0, _createClass2.default)(WebGLDevice, [{
+    key: "features",
+    get: function get() {
+      this._features = this._features || (0, _deviceFeatures.getDeviceFeatures)(this.gl);
+      return this._features;
+    }
+  }, {
+    key: "limits",
+    get: function get() {
+      this._limits = this._limits || (0, _deviceLimits.getDeviceLimits)(this.gl);
+      return this._limits;
+    }
+  }, {
+    key: "webglLimits",
+    get: function get() {
+      this._webglLimits = this._webglLimits || (0, _deviceLimits.getWebGLLimits)(this.gl);
+      return this._webglLimits;
+    }
+  }, {
     key: "destroy",
     value: function destroy() {
       var ext = this.gl.getExtension('STACKGL_destroy_context');
@@ -201,79 +192,208 @@ var WebGLDevice = function (_Device) {
       }
     }
   }, {
-    key: "resize",
-    value: function resize(options) {
-      if (this.gl.canvas) {
-        var devicePixelRatio = (0, _devicePixels.getDevicePixelRatio)(options === null || options === void 0 ? void 0 : options.useDevicePixels);
-        (0, _devicePixels.setDevicePixelRatio)(this.gl, devicePixelRatio, options);
-        return;
-      }
-
-      var ext = this.gl.getExtension('STACKGL_resize_drawingbuffer');
-
-      if (ext && options && "width" in options && "height" in options) {
-        ext.resize(options.width, options.height);
-      }
+    key: "isLost",
+    get: function get() {
+      return this.gl.isContextLost();
+    }
+  }, {
+    key: "getSize",
+    value: function getSize() {
+      return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight];
+    }
+  }, {
+    key: "isTextureFormatSupported",
+    value: function isTextureFormatSupported(format) {
+      return (0, _textureFormats.isTextureFormatSupported)(this.gl, format);
+    }
+  }, {
+    key: "isTextureFormatFilterable",
+    value: function isTextureFormatFilterable(format) {
+      return (0, _textureFormats.isTextureFormatFilterable)(this.gl, format);
+    }
+  }, {
+    key: "isTextureFormatRenderable",
+    value: function isTextureFormatRenderable(format) {
+      return (0, _textureFormats.isTextureFormatRenderable)(this.gl, format);
+    }
+  }, {
+    key: "assertWebGL2",
+    value: function assertWebGL2() {
+      (0, _api.assert)(this.isWebGL2, 'Requires WebGL2');
+      return this.gl2;
+    }
+  }, {
+    key: "createCanvasContext",
+    value: function createCanvasContext(props) {
+      throw new Error('WebGL only supports a single canvas');
     }
   }, {
     key: "_createBuffer",
     value: function _createBuffer(props) {
-      return new _webglBuffer.default(this.gl, props);
+      return new _buffer.default(this, props);
     }
   }, {
-    key: "createTexture",
-    value: function createTexture(props) {
-      return new _texture2d.default(this, props);
+    key: "_createTexture",
+    value: function _createTexture(props) {
+      return new _webglTexture.default(this, props);
+    }
+  }, {
+    key: "createExternalTexture",
+    value: function createExternalTexture(props) {
+      throw new Error('createExternalTexture() not implemented');
+    }
+  }, {
+    key: "createSampler",
+    value: function createSampler(props) {
+      return new _webglSampler.default(this, props);
     }
   }, {
     key: "createShader",
     value: function createShader(props) {
-      return new _webglShader.WEBGLShader(this, props);
+      return new _webglShader.default(this, props);
     }
   }, {
-    key: "commit",
-    value: function commit() {
-      if (this.offScreen && this.gl.commit) {
-        this.gl.commit();
-      }
+    key: "createFramebuffer",
+    value: function createFramebuffer(props) {
+      return new _webglFramebuffer.default(this, props);
+    }
+  }, {
+    key: "createRenderPipeline",
+    value: function createRenderPipeline(props) {
+      return new _webglRenderPipeline.default(this, props);
+    }
+  }, {
+    key: "beginRenderPass",
+    value: function beginRenderPass(props) {
+      return new _webglRenderPass.default(this, props);
+    }
+  }, {
+    key: "createComputePipeline",
+    value: function createComputePipeline(props) {
+      throw new Error('ComputePipeline not supported in WebGL');
     }
   }, {
-    key: "_createContext",
-    value: function _createContext(options) {
-      var _this$props = this.props,
-          width = _this$props.width,
-          height = _this$props.height,
-          canvas = _this$props.canvas;
-      var targetCanvas = (0, _getCanvas.getCanvas)({
-        canvas: canvas,
-        width: width,
-        height: height
+    key: "beginComputePass",
+    value: function beginComputePass(props) {
+      throw new Error('compute shaders not supported in WebGL');
+    }
+  }, {
+    key: "getDefaultRenderPass",
+    value: function getDefaultRenderPass() {
+      this.renderPass = this.renderPass || this.beginRenderPass({
+        framebuffer: this.canvasContext.getCurrentFramebuffer()
       });
-      return (0, _createContext2.createBrowserContext)(targetCanvas, options);
+      return this.renderPass;
+    }
+  }, {
+    key: "submit",
+    value: function submit() {
+      this.renderPass.endPass();
+      this.renderPass = null;
     }
   }], [{
-    key: "fromContext",
-    value: function fromContext(gl) {
-      return gl.device;
+    key: "isSupported",
+    value: function isSupported() {
+      return typeof WebGLRenderingContext !== 'undefined';
     }
   }, {
     key: "attach",
-    value: function attach(gl, props) {
+    value: function attach(gl) {
       if (gl instanceof WebGLDevice) {
         return gl;
       }
 
-      if (!(0, _webglChecks.isWebGL)(gl)) {
+      if ((gl === null || gl === void 0 ? void 0 : gl.device) instanceof _api.Device) {
+        return gl.device;
+      }
+
+      if (!isWebGL(gl)) {
         throw new Error('Invalid WebGLRenderingContext');
       }
 
-      return new WebGLDevice(_objectSpread(_objectSpread({}, props), {}, {
+      return new WebGLDevice({
         gl: gl
-      }));
+      });
     }
+  }, {
+    key: "create",
+    value: function () {
+      var _create = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(props) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _api.log.groupCollapsed(LOG_LEVEL, 'WebGLDevice created');
+
+                if (!(typeof props.canvas === 'string')) {
+                  _context.next = 4;
+                  break;
+                }
+
+                _context.next = 4;
+                return _api.CanvasContext.pageLoaded;
+
+              case 4:
+                if (!props.debug) {
+                  _context.next = 7;
+                  break;
+                }
+
+                _context.next = 7;
+                return (0, _webglDeveloperTools.loadWebGLDeveloperTools)();
+
+              case 7:
+                if (!props.spector) {
+                  _context.next = 10;
+                  break;
+                }
+
+                _context.next = 10;
+                return (0, _spector.loadSpectorJS)();
+
+              case 10:
+                _api.log.probe(LOG_LEVEL, 'DOM is loaded')();
+
+                return _context.abrupt("return", new WebGLDevice(props));
+
+              case 12:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function create(_x) {
+        return _create.apply(this, arguments);
+      }
+
+      return create;
+    }()
   }]);
   return WebGLDevice;
 }(_api.Device);
 
 exports.default = WebGLDevice;
+(0, _defineProperty2.default)(WebGLDevice, "type", 'webgl');
+
+function isWebGL(gl) {
+  if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {
+    return true;
+  }
+
+  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
+    return true;
+  }
+
+  return Boolean(gl && Number.isFinite(gl._version));
+}
+
+function isWebGL2(gl) {
+  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
+    return true;
+  }
+
+  return Boolean(gl && gl._version === 2);
+}
 //# sourceMappingURL=webgl-device.js.map

package/dist/es5/adapter/webgl-device.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapter/webgl-device.ts"],"names":["DEFAULT_DEVICE_PROPS","canvas","undefined","gl","webgl2","webgl1","manageState","width","height","debug","break","onContextLost","console","error","onContextRestored","info","alpha","depth","stencil","antialias","premultipliedAlpha","preserveDrawingBuffer","failIfMajorPerformanceCaveat","glToContextMap","WeakMap","getWebGLDevice","get","counter","WebGLDevice","props","clientWidth","clientHeight","devicePixelRatio","device","_state","log","Error","offScreen","OffscreenCanvas","_createContext","gl2","isWebGL2","_version","WebGL2RenderingContext","set","webGL","group","vendor","renderer","probe","copyState","args","features","limits","webglLimits","groupEnd","ext","getExtension","destroy","options","useDevicePixels","resize","WEBGLBuffer","Texture2D","WEBGLShader","commit","targetCanvas","Device"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nimport {Device, DeviceInfo, DeviceLimits, log} from '@luma.gl/api';\nimport {polyfillContext} from '../context/polyfill/polyfill-context';\nimport {trackContextState} from '../context/state-tracker/track-context-state';\nimport { ContextState } from '../context/context/context-state';\nimport {getDevicePixelRatio, setDevicePixelRatio} from '../context/context/device-pixels';\nimport {createBrowserContext} from '../context/context/create-context';\nimport {getCanvas} from '../context/context/get-canvas';\nimport {isWebGL, isWebGL2} from '../context/context/webgl-checks';\nimport {getDeviceInfo} from './device-helpers/get-device-info';\nimport {getDeviceFeatures, Feature} from './device-helpers/device-features';\nimport {getDeviceLimits, getWebGLLimits, WebGLLimits} from './device-helpers/device-limits';\n\n// WebGL classes\nimport type {BufferProps, ShaderProps} from '@luma.gl/api';\nimport WEBGLBuffer from '../classes/webgl-buffer';\nimport {WEBGLShader} from '../adapter/webgl-shader';\nimport Texture2D, {Texture2DProps} from '../classes/texture-2d';\nimport type {default as Framebuffer} from '../classes/framebuffer';\nimport type {default as VertexArrayObject} from '../classes/vertex-array-object';\n\n/** WebGLDevice options */\nexport type WebGLDeviceProps = {\n  canvas?: HTMLCanvasElement | OffscreenCanvas | string; // A canvas element or a canvas string id\n  width?: number /** width is only used when creating a new canvas */;\n  height?: number /** height is only used when creating a new canvas */;\n  // Attach to existing context\n  gl?: WebGLRenderingContext | WebGL2RenderingContext;\n  // COMMON CONTEXT PARAMETERS\n  webgl2?: boolean; // Set to false to not create a WebGL2 context (force webgl1)\n  webgl1?: boolean; // set to false to not create a WebGL1 context (fails if webgl2 not available)\n  manageState?: boolean; // Set to false to disable WebGL state management instrumentation\n  debug?: boolean; // Instrument context (at the expense of performance)\n  break?: Array<any>; // TODO: types\n  onContextLost?: (event: Event) => void;\n  onContextRestored?: (event: Event) => void;\n  // BROWSER CONTEXT PARAMETERS\n  alpha?: boolean; // Default render target has an alpha buffer.\n  depth?: boolean; // Default render target has a depth buffer of at least 16 bits.\n  stencil?: boolean; // Default render target has a stencil buffer of at least 8 bits.\n  antialias?: boolean; // Boolean that indicates whether or not to perform anti-aliasing.\n  premultipliedAlpha?: boolean; // Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n  preserveDrawingBuffer?: boolean; // Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten\n  failIfMajorPerformanceCaveat?: boolean; // Do not create if the system performance is low.\n};\n\nconst DEFAULT_DEVICE_PROPS: Required<WebGLDeviceProps> = {\n  canvas: undefined, // A canvas element or a canvas string id\n  gl: undefined,\n  webgl2: true, // Attempt to create a WebGL2 context\n  webgl1: true, // Attempt to create a WebGL1 context (false to fail if webgl2 not available)\n  manageState: true,\n  width: 800, // width are height are only used by headless gl\n  height: 600,\n  debug: false, // Instrument context (at the expense of performance)\n  break: undefined,\n  onContextLost: () => console.error('WebGL context lost'),\n  onContextRestored: () => console.info('WebGL context restored'),\n\n  alpha: undefined,\n  depth: undefined,\n  stencil: undefined,\n  antialias: undefined,\n  premultipliedAlpha: undefined,\n  preserveDrawingBuffer: undefined,\n  failIfMajorPerformanceCaveat: undefined\n};\n\n// TODO use weakmap instead of modifying context\nconst glToContextMap = new WeakMap<WebGLRenderingContext | WebGL2RenderingContext, WebGLDevice>();\n\nexport function getWebGLDevice(gl: WebGLRenderingContext | WebGL2RenderingContext): WebGLDevice | undefined {\n  return glToContextMap.get(gl);\n}\n\nlet counter = 0;\n\n/** WebGPU style Device API for a WebGL context */\nexport default class WebGLDevice extends Device implements ContextState {\n  // WebGPU style API\n\n  /** A set like interface to test features */\n  readonly features: Set<Feature>;\n  readonly limits: DeviceLimits;\n  readonly info: DeviceInfo;\n\n  /** Promise that rejects when context is lost */\n  readonly lost: Promise<string>;\n\n  // Common API\n  props: Required<WebGLDeviceProps>;\n  userData: {[key: string]: any};\n\n  // WebGL specific API\n  readonly isWebGL2: boolean;\n  readonly gl: WebGLRenderingContext;\n  readonly gl2: WebGL2RenderingContext;\n  /** Is this device attached to an offscreen context */\n  readonly offScreen: boolean = false;\n\n  readonly webglFeatures: Set<string>;\n  readonly webglLimits: WebGLLimits;\n\n  defaultFramebuffer?: Framebuffer;\n  defaultVertexArray?: VertexArrayObject;\n\n  // State used by luma.gl classes\n  _state: 'uninitialized' | 'initializing' | 'initialized' = 'uninitialized';\n  readonly _canvasSizeInfo = {clientWidth: 0, clientHeight: 0, devicePixelRatio: 1};\n  readonly _extensions: Record<string, any> = {};\n  _polyfilled: boolean = false;\n\n  /**\n   *\n   */\n  static fromContext(gl: WebGLRenderingContext): WebGLDevice {\n    // @ts-expect-error\n    return gl.device as WebGLDevice;\n  }\n\n  /**\n   * Get a device instance from a GL context\n   * Creates and instruments the device if not already created\n   * @param gl\n   * @returns\n   */\n  static attach(\n    gl: Device | WebGLRenderingContext | WebGL2RenderingContext,\n    props?: WebGLDeviceProps\n  ): WebGLDevice {\n    if (gl instanceof WebGLDevice) {\n      return gl;\n    }\n    if (!isWebGL(gl)) {\n      throw new Error('Invalid WebGLRenderingContext');\n    }\n    return new WebGLDevice({...props, gl: gl as WebGLRenderingContext});\n  }\n\n\n  constructor(props: WebGLDeviceProps) {\n    super();\n\n    this.props = {...DEFAULT_DEVICE_PROPS, ...props};\n\n    // If attaching to an already attached context, return the attached device\n    // @ts-expect-error device is attached to context\n    const device: WebGLDevice | undefined = this.props.gl?.device;\n    if (device) {\n      if (device._state !== 'initialized') {\n        log.error('recursive context');\n        throw new Error('recursive context');\n      }\n      return device;\n    }\n\n    this.offScreen =\n      typeof OffscreenCanvas !== 'undefined' &&\n      props.canvas instanceof OffscreenCanvas;\n\n    // Create an instrument context\n    this.gl = (this.props.gl || this._createContext(props)) as WebGLRenderingContext;\n    this.gl2 = this.gl as WebGL2RenderingContext;\n    this.isWebGL2 = isWebGL2(this.gl);\n    this._state = 'initializing';\n    // Avoid multiple instrumentations\n    // @ts-expect-error\n    if (this.gl.device) {\n      log.error('device already created');\n      throw new Error('device already created'); // ASSERT this device;\n    }\n    // @ts-expect-error\n    this.gl.device = this;\n    // @ts-ignore\n    this.gl._version = typeof WebGL2RenderingContext !== 'undefined' && this.gl instanceof WebGL2RenderingContext ? 2 : 1;\n    // TODO - move to weak map indexing\n    glToContextMap.set(this.gl, this);\n\n    // Luma Device fields\n    this.info = getDeviceInfo(this.gl);\n    // Log some debug info about the newly created context\n    // @ts-expect-error device is attached to context\n    const debug = this.gl.debug ? ' debug' : '';\n    const webGL = isWebGL2(this.gl) ? 'WebGL2' : 'WebGL1';\n    log.group(0, `${webGL}${debug} context: ${this.info.vendor}, ${this.info.renderer}`)();\n\n    polyfillContext(this.gl);\n    log.probe(0, 'polyfilled context')();\n\n    // Install context state tracking\n    trackContextState(this.gl, {\n      copyState: false,\n      log: (...args) => log.log(1, ...args)()\n    });\n    log.probe(0, 'instrumented context')();\n\n    // WebGPU Device fields\n    this.features = getDeviceFeatures(this.gl);\n    log.probe(0, `queried device features ${counter}`)();\n    this.limits = getDeviceLimits(this.gl);\n    log.probe(0, 'queried device limits')();\n\n    // Add seer integration - TODO - currently removed\n\n    // WEBGL specific fields\n    this.webglLimits = getWebGLLimits(this.gl);\n    log.probe(0, 'queried webgl limits')();\n\n    // Add debug instrumentation to the context\n    // if (isBrowser() && props.debug) {\n    //   // @ts-ignore\n    //   const {makeDebugContext} = global;\n    //   if (!makeDebugContext) {\n    //     log.warn('WebGL debug mode not activated. import \"@luma.gl/debug\" to enable.')();\n    //   } else {\n    //     // @ts-ignore\n    //     this.gl = global.makeDebugContext(this.gl, props);\n    //     this.gl2 = this.gl as WebGL2RenderingContext;\n    //     // Debug forces log level to at least 1\n    //     log.level = Math.max(log.level, 1);\n    //   }\n    // }\n\n    log.groupEnd(0)();\n    this._state = 'initialized';\n  }\n\n  /**\n   * Destroys the context\n   * @note Has no effect for browser contexts, there is no browser API for destroying contexts\n   */\n  destroy() {\n    let ext = this.gl.getExtension('STACKGL_destroy_context');\n    if (ext) {\n      ext.destroy();\n    }\n    // ext = this.gl.getExtension('WEBGL_lose_context');\n    // if (ext) {\n    //   // TODO - disconnect context lost callbacks?\n    //   ext.loseContext();\n    // }\n  }\n\n  // WEBGL SPECIFIC METHODS\n\n  /**\n   * Resize the canvas' drawing buffer.\n   *\n   * Can match the canvas CSS size, and optionally also consider devicePixelRatio\n   * Can be called every frame\n   *\n   * Regardless of size, the drawing buffer will always be scaled to the viewport, but\n   * for best visual results, usually set to either:\n   *  canvas CSS width x canvas CSS height\n   *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio\n   * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html\n   */\n  resize(options?: {width?: number; height?: number; useDevicePixels?: boolean | number}): void {\n    // Resize browser context .\n    if (this.gl.canvas) {\n      const devicePixelRatio = getDevicePixelRatio(options?.useDevicePixels);\n      setDevicePixelRatio(this.gl, devicePixelRatio, options);\n      return;\n    }\n\n    // Resize headless gl context\n    const ext = this.gl.getExtension('STACKGL_resize_drawingbuffer');\n    if (ext && options && `width` in options && `height` in options) {\n      ext.resize(options.width, options.height);\n    }\n  }\n\n  _createBuffer(props: BufferProps): WEBGLBuffer {\n    return new WEBGLBuffer(this.gl, props);\n  }\n\n  createTexture(props: Texture2DProps): Texture2D {\n    return new Texture2D(this, props);\n  }\n\n  createShader(props: ShaderProps): WEBGLShader {\n    return new WEBGLShader(this, props);\n  }\n\n  /**\n   * Offscreen Canvas Support: Commit the frame\n   * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/commit\n   * Chrome's offscreen canvas does not require gl.commit\n   */\n  commit(): void {\n    // @ts-expect-error gl.commit is not officially part of WebGLRenderingContext\n    if (this.offScreen && this.gl.commit) {\n      // @ts-expect-error gl.commit is not officially part of WebGLRenderingContext\n      this.gl.commit();\n    }\n  }\n\n  // PRIVATE METHODS\n\n  /**\n   * Creates a context giving access to the WebGL API\n   */\n  _createContext(options?: WebGLDeviceProps): WebGLRenderingContext {\n    const {width, height, canvas} = this.props;\n    // Get or create a canvas\n    const targetCanvas = getCanvas({canvas, width, height});\n    // Create a WebGL context in the canvas\n    return createBrowserContext(targetCanvas, options);\n  }\n}\n\n/*\nimport {\n  isWebGL, isWebGL2,\n  createGLContext,\n  instrumentGLContext,\n  getContextDebugInfo,\n  resizeGLContext\n} from '@luma.gl/gltools';\n\n// prettier-ignore\nimport {\n  Device, DeviceInfo, DeviceLimits,\n  Buffer, BufferProps\n} from '@luma.gl/api';\n\nimport {getWebGLDeviceInfo} from '../converters/webgl-device-info';\nimport {getWebGLLimits} from '../converters/webgl-limits';\nimport {getWebGLFeatures} from '../converters/webgl-features';\n\nexport default class WEBGLDevice implements Device {\n  readonly handle: WebGLRenderingContext;\n  readonly gl: WebGLRenderingContext;\n  readonly gl2: WebGL2RenderingContext | null;\n  readonly canvas: HTMLCanvasElement;\n\n  static isSupported(options: {canvas?: HTMLCanvasElement}): boolean {\n    const {canvas} = options;\n    let gl;\n    try {\n      gl = canvas && canvas.getContext(\"webgl\");\n      gl = gl && canvas && canvas.getContext(\"experimental-webgl\");\n    } catch (x) {\n      gl = null;\n    }\n    return Boolean(gl);\n  }\n\n  constructor(props = {}) {\n    const {canvas, swapChainFormat = \"bgra8unorm\"} = props;\n\n    const gl = createGLContext(props);\n    this.handle =\n    this.gl = gl;\n    this.gl2 = gl instanceof WebGL2RenderingContext ? gl : null;\n    this.canvas = canvas;\n  }\n\n  resize(width, height) {\n    resizeGLContext(this.gl);\n  }\n\n  getInfo(): DeviceInfo {\n    return getWebGLDeviceInfo(this.gl);\n  }\n\n  getLimits(): DeviceLimits {\n    return getWebGLLimits(this.gl, this.gl2);\n  }\n\n  getFeatures(): string[] {\n    return getWebGLFeatures(this.gl);\n  }\n\n  createBuffer(props: WebGPUBufferProps): WEBGLBuffer {\n    return new WEBGLBuffer(this.gl2 || this.gl, props);\n  }\n\n  createTexture(props: WebGPUTextureProps): WEBGLTexture {\n    return new WEBGLTexture(this, props);\n  }\n\n  createSampler(props: WebGPUSamplerProps): WEBGLSampler {\n    return new WEBGLSampler(this, props);\n  }\n\n  createShader(props: WebGPUShaderProps): WEBGLShader {\n    return new WEBGLShader(this, props);\n  }\n\n  createRenderPipeline(props: WebGPURenderPipelineProps): WEBGLPipeline {\n    return new WEBGLRenderPipeline(this, props);\n  }\n\n  createComputePipeline(props: WebGPUComputePipelineProps): WebGPUPipeline {\n    return new WebGPUComputePipeline(this, props);\n  }\n\n\n  // PRIVATE\n\n  _startFrame() {}\n\n  _endFrame() {}\n}\n*/\n"],"file":"webgl-device.js"}
+{"version":3,"sources":["../../../src/adapter/webgl-device.ts"],"names":["LOG_LEVEL","counter","WebGLDevice","props","clientWidth","clientHeight","devicePixelRatio","device","gl","log","warn","id","canvasContext","WebGLCanvasContext","handle","canvas","gl2","isWebGL2","isWebGL1","info","_version","copyState","args","debug","webgl2","throwOnError","level","Math","max","spector","message","type","vendor","renderer","probe","groupEnd","_features","_limits","_webglLimits","ext","getExtension","destroy","isContextLost","drawingBufferWidth","drawingBufferHeight","format","Error","ClassicBuffer","WEBGLTexture","WEBGLSampler","WEBGLShader","WEBGLFramebuffer","WEBGLRenderPipeline","WEBGLRenderPass","renderPass","beginRenderPass","framebuffer","getCurrentFramebuffer","endPass","WebGLRenderingContext","Device","isWebGL","groupCollapsed","CanvasContext","pageLoaded","WebGL2RenderingContext","Boolean","Number","isFinite"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nimport type {\n  DeviceProps,\n  DeviceInfo,\n  DeviceLimits,\n  DeviceFeature,\n  CanvasContextProps,\n  TextureFormat\n} from '@luma.gl/api';\nimport {Device, CanvasContext, log, assert} from '@luma.gl/api';\nimport {isBrowser} from '@probe.gl/env';\nimport {polyfillContext} from '../context/polyfill/polyfill-context';\nimport {trackContextState} from '../context/state-tracker/track-context-state';\nimport {ContextState} from '../context/context/context-state';\nimport {createBrowserContext} from '../context/context/create-context';\nimport {getDeviceInfo} from './device-helpers/get-device-info';\nimport {getDeviceFeatures} from './device-helpers/device-features';\nimport {getDeviceLimits, getWebGLLimits, WebGLLimits} from './device-helpers/device-limits';\nimport WebGLCanvasContext from './webgl-canvas-context';\nimport {loadSpectorJS, initializeSpectorJS} from '../context/debug/spector';\nimport {loadWebGLDeveloperTools, makeDebugContext} from '../context/debug/webgl-developer-tools';\nimport {\n  isTextureFormatSupported,\n  isTextureFormatRenderable,\n  isTextureFormatFilterable\n} from './converters/texture-formats';\n\n// WebGL classes\nimport type {\n  BufferProps,\n  ShaderProps,\n  Sampler,\n  SamplerProps,\n  TextureProps,\n  ExternalTexture,\n  ExternalTextureProps,\n  FramebufferProps,\n  RenderPipeline,\n  RenderPipelineProps,\n  ComputePipeline,\n  ComputePipelineProps,\n  RenderPass,\n  RenderPassProps,\n  ComputePass,\n  ComputePassProps\n} from '@luma.gl/api';\n\nimport ClassicBuffer from '../classic/buffer';\nimport WEBGLBuffer from './resources/webgl-buffer';\nimport WEBGLShader from './resources/webgl-shader';\nimport WEBGLSampler from './resources/webgl-sampler';\nimport WEBGLTexture from './resources/webgl-texture';\nimport WEBGLFramebuffer from './resources/webgl-framebuffer';\nimport WEBGLRenderPass from './resources/webgl-render-pass';\nimport WEBGLRenderPipeline from './resources/webgl-render-pipeline';\n\nconst LOG_LEVEL = 1;\n\nlet counter = 0;\n\n/** WebGPU style Device API for a WebGL context */\nexport default class WebGLDevice extends Device implements ContextState {\n  // Public API\n\n  static type: string = 'webgl';\n\n  static isSupported(): boolean {\n    return typeof WebGLRenderingContext !== 'undefined';\n  }\n\n  readonly info: DeviceInfo;\n  readonly canvasContext: WebGLCanvasContext;\n  readonly lost: Promise<{reason: 'destroyed'; message: string}>;\n  readonly handle: WebGLRenderingContext;\n\n  get features(): Set<DeviceFeature> {\n    this._features = this._features || getDeviceFeatures(this.gl);\n    return this._features;\n  }\n\n  get limits(): DeviceLimits {\n    this._limits = this._limits || getDeviceLimits(this.gl);\n    return this._limits;\n  }\n\n  // WebGL specific API\n\n  /** WebGL1 typed context. Can always be used. */\n  readonly gl: WebGLRenderingContext;\n  /** WebGL2 typed context. Need to check isWebGL2 or isWebGL1 before using. */\n  readonly gl2: WebGL2RenderingContext;\n  readonly debug: boolean = false;\n\n  /** `true` if this is a WebGL1 context. @note `false` if WebGL2 */\n  readonly isWebGL1: boolean;\n  /** `true` if this is a WebGL2 context. @note `false` if WebGL1 */\n  readonly isWebGL2: boolean;\n\n  get webglLimits(): WebGLLimits {\n    this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);\n    return this._webglLimits;\n  }\n\n  private _features: Set<DeviceFeature>;\n  private _limits: DeviceLimits;\n  private _webglLimits: WebGLLimits;\n\n  /** State used by luma.gl classes: TODO - move to canvasContext*/\n  readonly _canvasSizeInfo = {clientWidth: 0, clientHeight: 0, devicePixelRatio: 1};\n  /** State used by luma.gl classes */\n  readonly _extensions: Record<string, any> = {};\n  _polyfilled: boolean = false;\n\n  /** Instance of Spector.js (if initialized) */\n  spector;\n\n  /**\n   * Get a device instance from a GL context\n   * Creates and instruments the device if not already created\n   * @param gl\n   * @returns\n   */\n  static attach(gl: Device | WebGLRenderingContext | WebGL2RenderingContext): WebGLDevice {\n    if (gl instanceof WebGLDevice) {\n      return gl;\n    }\n    // @ts-expect-error\n    if (gl?.device instanceof Device) {\n      // @ts-expect-error\n      return gl.device as WebGLDevice;\n    }\n    if (!isWebGL(gl)) {\n      throw new Error('Invalid WebGLRenderingContext');\n    }\n    return new WebGLDevice({gl: gl as WebGLRenderingContext});\n  }\n\n  static async create(props?: DeviceProps): Promise<WebGLDevice> {\n    log.groupCollapsed(LOG_LEVEL, 'WebGLDevice created');\n\n    // Wait for page to load. Only wait when props. canvas is string\n    // to avoid setting page onload callback unless necessary\n    if (typeof props.canvas === 'string') {\n      await CanvasContext.pageLoaded;\n    }\n\n    // Load webgl and spector debug scripts from CDN if requested\n    if (props.debug) {\n      await loadWebGLDeveloperTools();\n    }\n    // @ts-expect-error spector not on props\n    if (props.spector) {\n      await loadSpectorJS();\n    }\n\n    log.probe(LOG_LEVEL, 'DOM is loaded')();\n    return new WebGLDevice(props);\n  }\n\n  constructor(props: DeviceProps) {\n    super(props);\n\n    // If attaching to an already attached context, return the attached device\n    // @ts-expect-error device is attached to context\n    const device: WebGLDevice | undefined = props.gl?.device;\n    if (device) {\n      log.warn(`WebGL context already attached to device ${device.id}`);\n      return device;\n    }\n\n    // Create and instrument context\n    this.canvasContext = new WebGLCanvasContext(this, props);\n\n    this.handle = props.gl || createBrowserContext(this.canvasContext.canvas, props);\n    this.gl = this.handle;\n    this.gl2 = this.gl as WebGL2RenderingContext;\n    this.isWebGL2 = isWebGL2(this.gl);\n    this.isWebGL1 = !this.isWebGL2;\n\n    // luma Device fields\n    this.info = getDeviceInfo(this.gl);\n\n    // @ts-expect-error Link webgl context back to device\n    this.gl.device = this;\n    // @ts-expect-error Annotate webgl context to handle \n    this.gl._version = this.isWebGL2 ? 2 : 1;\n\n    // Add subset of WebGL2 methods to WebGL1 context\n    polyfillContext(this.gl);\n    // Install context state tracking\n    trackContextState(this.gl, {copyState: false, log: (...args: any[]) => log.log(1, ...args)()});\n\n    // DEBUG contexts: Add debug instrumentation to the context, force log level to at least 1\n    if (isBrowser() && props.debug) {\n      this.gl = makeDebugContext(this.gl, {...props, webgl2: this.isWebGL2, throwOnError: true});\n      this.gl2 = this.gl as WebGL2RenderingContext;\n      this.debug = true;\n      log.level = Math.max(log.level, 1);\n      log.warn('WebGL debug mode activated. Performance reduced.')();\n    }\n\n    // @ts-expect-error spector not on props\n    if (isBrowser() && props.spector) {\n      const canvas = this.handle.canvas || (props.canvas as HTMLCanvasElement);\n      this.spector = initializeSpectorJS({...this.props, canvas});\n    }\n\n    // Log some debug info about the newly created context\n    const message = `\\\nCreated ${this.info.type}${this.debug ? ' debug' : ''} context: \\\n${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`;\n    log.probe(LOG_LEVEL, message)();\n\n    log.groupEnd(LOG_LEVEL)();\n  }\n\n  /**\n   * Destroys the context\n   * @note Has no effect for browser contexts, there is no browser API for destroying contexts\n   */\n  destroy() {\n    let ext = this.gl.getExtension('STACKGL_destroy_context');\n    if (ext) {\n      ext.destroy();\n    }\n    // ext = this.gl.getExtension('WEBGL_lose_context');\n    // if (ext) {\n    //   // TODO - disconnect context lost callbacks?\n    //   ext.loseContext();\n    // }\n  }\n\n  get isLost(): boolean {\n    return this.gl.isContextLost();\n  }\n\n  getSize(): [number, number] {\n    return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight];\n  }\n\n  isTextureFormatSupported(format: TextureFormat): boolean {\n    return isTextureFormatSupported(this.gl, format);\n  }\n\n  isTextureFormatFilterable(format: TextureFormat): boolean {\n    return isTextureFormatFilterable(this.gl, format);\n  }\n\n  isTextureFormatRenderable(format: TextureFormat): boolean {\n    return isTextureFormatRenderable(this.gl, format);\n  }\n\n  // WEBGL SPECIFIC METHODS\n\n  /** Returns a WebGL2RenderingContext or throws an error */\n  assertWebGL2(): WebGL2RenderingContext {\n    assert(this.isWebGL2, 'Requires WebGL2');\n    return this.gl2;\n  }\n\n  // IMPLEMENTATION OF ABSTRACT DEVICE\n\n  createCanvasContext(props?: CanvasContextProps): CanvasContext {\n    throw new Error('WebGL only supports a single canvas');\n  }\n\n  _createBuffer(props: BufferProps): WEBGLBuffer {\n    return new ClassicBuffer(this, props);\n  }\n\n  _createTexture(props: TextureProps): WEBGLTexture {\n    return new WEBGLTexture(this, props);\n  }\n\n  createExternalTexture(props: ExternalTextureProps): ExternalTexture {\n    throw new Error('createExternalTexture() not implemented'); // return new Program(props);\n  }\n\n  createSampler(props: SamplerProps): WEBGLSampler {\n    return new WEBGLSampler(this, props);\n  }\n\n  createShader(props: ShaderProps): WEBGLShader {\n    return new WEBGLShader(this, props);\n  }\n\n  createFramebuffer(props: FramebufferProps): WEBGLFramebuffer {\n    return new WEBGLFramebuffer(this, props);\n  }\n\n  createRenderPipeline(props: RenderPipelineProps): WEBGLRenderPipeline {\n    return new WEBGLRenderPipeline(this, props);\n  }\n\n  beginRenderPass(props: RenderPassProps): WEBGLRenderPass {\n    return new WEBGLRenderPass(this, props);\n  }\n\n  createComputePipeline(props?: ComputePipelineProps): ComputePipeline {\n    throw new Error('ComputePipeline not supported in WebGL');\n  }\n\n  beginComputePass(props: ComputePassProps): ComputePass {\n    throw new Error('compute shaders not supported in WebGL');\n  }\n\n  private renderPass: WEBGLRenderPass;\n\n  getDefaultRenderPass(): WEBGLRenderPass {\n    this.renderPass =\n      this.renderPass ||\n      this.beginRenderPass({\n        framebuffer: this.canvasContext.getCurrentFramebuffer()\n      });\n    return this.renderPass;\n  }\n\n  /**\n   * Offscreen Canvas Support: Commit the frame\n   * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/commit\n   * Chrome's offscreen canvas does not require gl.commit\n   */\n  submit(): void {\n    this.renderPass.endPass();\n    this.renderPass = null;\n    // this.canvasContext.commit();\n  }\n}\n\n/** Check if supplied parameter is a WebGLRenderingContext */\nfunction isWebGL(gl: any): boolean {\n  if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {\n    return true;\n  }\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && Number.isFinite(gl._version));\n}\n\n\n/** Check if supplied parameter is a WebGL2RenderingContext */\nfunction isWebGL2(gl: any): boolean {\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && gl._version === 2);\n}\n"],"file":"webgl-device.js"}