@deephaven/chart 0.104.1-virtual-webgl.11 → 0.105.0

package/dist/virtual-webgl.js

@@ -1,915 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-// Copied from https://github.com/greggman/virtual-webgl
-// Used to show many WebGL plots on the same page
-// https://github.com/plotly/plotly.js/?tab=readme-ov-file#need-to-have-several-webgl-graphs-on-a-page
-/*
- * Copyright 2018, Gregg Tavares.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following disclaimer
- *    in the documentation and/or other materials provided with the
- *    distribution.
- *
- *  * Neither the name of Gregg Tavares. nor the names of his
- *    contributors may be used to endorse or promote products derived from
- *    this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-export function initializeVirtualWebGL() {
-  var settings = {
-    disableWebGL2: false,
-    compositorCreator() {}
-  };
-  var canvasToVirtualContextMap = new Map();
-  var extensionInfo = {
-    webgl_draw_buffers: {
-      wrapperFnMakerFn: makeWEBGL_draw_buffersWrapper,
-      saveRestoreMakerFn: makeWEBGL_drawBuffersSaveRestoreHelper
-    },
-    oes_vertex_array_object: {
-      wrapperFnMakerFn: makeOES_vertex_array_objectWrapper
-    },
-    angle_instanced_arrays: {
-      wrapperFnMakerFn: makeANGLE_instanced_arraysWrapper
-    }
-  };
-  var extensionSaveRestoreHelpersArray = [];
-  var extensionSaveRestoreHelpers = {};
-  var currentVirtualContext = null;
-  var someContextsNeedRendering;
-  var sharedWebGLContext = document.createElement('canvas').getContext('webgl');
-  var sharedVAOExtension = sharedWebGLContext.getExtension('OES_vertex_array_object');
-  var sharedInstanceExtension = sharedWebGLContext.getExtension('ANGLE_instanced_arrays');
-  var numAttributes = sharedWebGLContext.getParameter(sharedWebGLContext.MAX_VERTEX_ATTRIBS);
-  var numTextureUnits = sharedWebGLContext.getParameter(sharedWebGLContext.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-  var numDrawBuffers;
-  var baseState = makeDefaultState(300, 150);
-  var vs = "\n  attribute vec4 position;\n  varying vec2 v_texcoord;\n  void main() {\n    gl_Position = position;\n    v_texcoord = position.xy * .5 + .5;\n  }\n  ";
-  var fs = "\n  precision mediump float;\n  varying vec2 v_texcoord;\n  uniform sampler2D u_tex;\n  void main() {\n    gl_FragColor = texture2D(u_tex, v_texcoord);\n  }\n  ";
-  var fs2 = "\n  precision mediump float;\n  varying vec2 v_texcoord;\n  uniform sampler2D u_tex;\n  void main() {\n    gl_FragColor = texture2D(u_tex, v_texcoord);\n    gl_FragColor.rgb *= gl_FragColor.a;\n  }\n  ";
-  var premultplyAlphaTrueProgram = createProgram(sharedWebGLContext, [vs, fs]);
-  var premultplyAlphaFalseProgram = createProgram(sharedWebGLContext, [vs, fs2]);
-  if (sharedVAOExtension) {
-    var vao = sharedVAOExtension.createVertexArrayOES();
-    sharedVAOExtension.bindVertexArrayOES(vao);
-    baseState.vertexArray = vao;
-  }
-  {
-    var gl = sharedWebGLContext;
-    var positionLoc = 0; // hard coded in createProgram
-
-    var buffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]), gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(positionLoc);
-    gl.vertexAttribPointer(positionLoc, 2, gl.FLOAT, false, 0, 0);
-  }
-  saveAllState(baseState);
-  HTMLCanvasElement.prototype.getContext = function (origFn) {
-    return function (type, contextAttributes) {
-      if (type === 'webgl' || type === 'experimental-webgl') {
-        return createOrGetVirtualWebGLContext(this, type, contextAttributes);
-      } else if (type === 'webgl2' && settings.disableWebGL2) {
-        return null;
-      }
-      return origFn.call(this, type, contextAttributes);
-    };
-  }(HTMLCanvasElement.prototype.getContext);
-  function valueOrDefault(value, defaultValue) {
-    return value === undefined ? defaultValue : value;
-  }
-  function errorDisposedContext(fnName) {
-    return function () {
-      throw new Error("tried to call ".concat(fnName, " on disposed context"));
-    };
-  }
-  class DefaultCompositor {
-    constructor(canvas) {
-      this._ctx = canvas.getContext('2d');
-    }
-    composite(gl, texture, canvas, contextAttributes) {
-      // note: not entirely sure what to do here. We need this canvas to be at least as large
-      // as the canvas we're drawing to. Resizing a canvas is slow so I think just making
-      // sure we never get smaller than the largest canvas. At the moment though I'm too lazy
-      // to make it smaller.
-      var ctx = this._ctx;
-      var width = canvas.width;
-      var height = canvas.height;
-      var maxWidth = Math.max(gl.canvas.width, width);
-      var maxHeight = Math.max(gl.canvas.height, height);
-      if (gl.canvas.width !== maxWidth || gl.canvas.height !== maxHeight) {
-        gl.canvas.width = maxWidth;
-        gl.canvas.height = maxHeight;
-      }
-      gl.viewport(0, 0, width, height);
-      gl.useProgram(contextAttributes.premultipliedAlpha ? premultplyAlphaTrueProgram : premultplyAlphaFalseProgram);
-
-      // draw the drawingbuffer's texture to the offscreen canvas
-      gl.bindTexture(gl.TEXTURE_2D, texture);
-      gl.drawArrays(gl.TRIANGLES, 0, 6);
-
-      // copy it to target canvas
-      ctx.globalCompositeOperation = 'copy';
-      ctx.drawImage(gl.canvas, 0, maxHeight - height, width, height,
-      // src rect
-      0, 0, width, height); // dest rect
-    }
-
-    dispose() {}
-  }
-  class VirtualWebGLContext {
-    constructor(canvas) {
-      var contextAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var compositor = arguments.length > 2 ? arguments[2] : undefined;
-      var disposeHelper = arguments.length > 3 ? arguments[3] : undefined;
-      var gl = sharedWebGLContext;
-      this.canvas = canvas;
-      // Should use Symbols or someting to hide these variables from the outside.
-
-      this._compositor = compositor;
-      this._disposeHelper = disposeHelper;
-      this._extensions = {};
-      // based on context attributes and canvas.width, canvas.height
-      // create a texture and framebuffer
-      this._drawingbufferTexture = gl.createTexture();
-      this._drawingbufferFramebuffer = gl.createFramebuffer();
-      this._contextAttributes = {
-        alpha: valueOrDefault(contextAttributes.alpha, true),
-        antialias: false,
-        depth: valueOrDefault(contextAttributes.depth, true),
-        failIfMajorPerformanceCaveat: false,
-        premultipliedAlpha: valueOrDefault(contextAttributes.premultipliedAlpha, true),
-        stencil: valueOrDefault(contextAttributes.stencil, false)
-      };
-      this._preserveDrawingbuffer = valueOrDefault(contextAttributes.preserveDrawingBuffer, false);
-      var oldTexture = gl.getParameter(gl.TEXTURE_BINDING_2D);
-      var oldFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
-      gl.bindTexture(gl.TEXTURE_2D, this._drawingbufferTexture);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-      // this._drawingbufferTexture.id = canvas.id;
-      // this._drawingbufferFramebuffer.id = canvas.id;
-
-      gl.bindFramebuffer(gl.FRAMEBUFFER, this._drawingbufferFramebuffer);
-      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._drawingbufferTexture, 0);
-      if (this._contextAttributes.depth) {
-        var oldRenderbuffer = gl.getParameter(gl.RENDERBUFFER_BINDING);
-        this._depthRenderbuffer = gl.createRenderbuffer();
-        gl.bindRenderbuffer(gl.RENDERBUFFER, this._depthRenderbuffer);
-        var attachmentPoint = this._contextAttributes.stencil ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
-        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachmentPoint, gl.RENDERBUFFER, this._depthRenderbuffer);
-        gl.bindRenderbuffer(gl.RENDERBUFFER, oldRenderbuffer);
-      }
-      gl.bindTexture(gl.TEXTURE_2D, oldTexture);
-      gl.bindFramebuffer(gl.FRAMEBUFFER, oldFramebuffer);
-
-      // remember all WebGL state (default bindings, default texture units,
-      // default attributes and/or vertex shade object, default program,
-      // default blend, stencil, zbuffer, culling, viewport etc... state
-      this._state = makeDefaultState(canvas.width, canvas.height);
-      this._state.framebuffer = this._drawingbufferFramebuffer;
-      if (sharedVAOExtension) {
-        this._state.vertexArray = sharedVAOExtension.createVertexArrayOES();
-        this._defaultVertexArray = this._state.vertexArray;
-      }
-    }
-    dispose() {
-      this._disposeHelper();
-      var gl = sharedWebGLContext;
-      gl.deleteFramebuffer(this._drawingbufferFramebuffer);
-      gl.deleteTexture(this._drawingbufferTexture);
-      if (this._depthRenderbuffer) {
-        gl.deleteRenderbuffer(this._depthRenderbuffer);
-      }
-      if (this._compositor.dispose) {
-        this._compositor.dispose();
-      }
-      for (var [key, value] of Object.entries(this)) {
-        if (typeof value === 'function') {
-          this[key] = errorDisposedContext(key);
-        }
-      }
-      for (var [_key, _value] of Object.entries(VirtualWebGLContext.prototype)) {
-        if (typeof _value === 'function') {
-          this[_key] = errorDisposedContext(_key);
-        }
-      }
-    }
-    get drawingBufferWidth() {
-      return this.canvas.width;
-    }
-    get drawingBufferHeight() {
-      return this.canvas.height;
-    }
-    composite(gl) {
-      this._compositor.composite(gl, this._drawingbufferTexture, this.canvas, this._contextAttributes);
-      if (!this._preserveDrawingbuffer) {
-        this._needClear = true;
-      }
-    }
-  }
-  function makeDefaultState(width, height) {
-    var gl = WebGLRenderingContext;
-    var state = {
-      arrayBuffer: null,
-      renderbuffer: null,
-      framebuffer: null,
-      blend: false,
-      cullFace: false,
-      depthTest: false,
-      dither: false,
-      polygonOffsetFill: false,
-      sampleAlphaToCoverage: false,
-      sampleCoverage: false,
-      scissorTest: false,
-      stencilTest: false,
-      activeTexture: gl.TEXTURE0,
-      packAlignment: 4,
-      unpackAlignment: 4,
-      unpackColorspaceConversion: gl.BROWSER_DEFAULT_WEBGL,
-      unpackFlipY: 0,
-      unpackPremultiplyAlpha: 0,
-      currentProgram: null,
-      viewport: [0, 0, width, height],
-      scissor: [0, 0, 0, 0],
-      blendSrcRgb: gl.ONE,
-      blendDstRgb: gl.ZERO,
-      blendSrcAlpha: gl.ONE,
-      blendDstAlpha: gl.ZERO,
-      blendEquationRgb: gl.FUNC_ADD,
-      blendEquationAlpha: gl.FUNC_ADD,
-      blendColor: [0, 0, 0, 0],
-      colorClearValue: [0, 0, 0, 0],
-      colorMask: [true, true, true, true],
-      cullFaceMode: gl.BACK,
-      depthClearValue: 1,
-      depthFunc: gl.LESS,
-      depthRange: [0, 1],
-      depthMask: true,
-      frontFace: gl.CCW,
-      generateMipmapHint: gl.DONT_CARE,
-      lineWidth: 1,
-      polygonOffsetFactor: 0,
-      polygonOffsetUnits: 0,
-      sampleCoverageValue: 1,
-      sampleCoverageUnits: false,
-      stencilBackFail: gl.KEEP,
-      stencilBackFunc: gl.ALWAYS,
-      stencilBackPassDepthFail: gl.KEEP,
-      stencilBackPassDepthPass: gl.KEEP,
-      stencilBackRef: 0,
-      stencilBackValueMask: 0xffffffff,
-      stencilBackWriteMask: 0xffffffff,
-      stencilClearValue: 0,
-      stencilFail: gl.KEEP,
-      stencilFunc: gl.ALWAYS,
-      stencilPassDepthFail: gl.KEEP,
-      stencilPassDepthPass: gl.KEEP,
-      stencilRef: 0,
-      stencilValueMask: 0xffffffff,
-      stencilWriteMask: 0xffffffff,
-      textureUnits: []
-    };
-    if (sharedVAOExtension) {
-      state.vertexArray = null;
-    } else {
-      state.elementArrayBuffer = null;
-      state.attributes = [];
-      for (var i = 0; i < numAttributes; ++i) {
-        var attrib = {
-          buffer: null,
-          enabled: false,
-          size: 4,
-          stride: 0,
-          type: gl.FLOAT,
-          normalized: false,
-          value: [0, 0, 0, 1]
-        };
-        if (sharedInstanceExtension) {
-          attrib.divisor = 0;
-        }
-        state.attributes.push(attrib);
-      }
-    }
-    for (var _i = 0; _i < numTextureUnits; ++_i) {
-      state.textureUnits.push({
-        texture2D: null,
-        textureCubemap: null
-      });
-    }
-    return state;
-  }
-
-  // copy all WebGL constants and functions to the prototype of
-  // VirtualWebGLContext
-  for (var key in WebGLRenderingContext.prototype) {
-    var propDesc = Object.getOwnPropertyDescriptor(WebGLRenderingContext.prototype, key);
-    if (propDesc.get) {
-      // it's a getter/setter ?
-      var virtualPropDesc = Object.getOwnPropertyDescriptor(VirtualWebGLContext.prototype, key);
-      if (!virtualPropDesc) {
-        console.warn("WebGLRenderingContext.".concat(key, " is not supported"));
-      }
-      continue;
-    }
-    switch (key) {
-      default:
-        {
-          var value = WebGLRenderingContext.prototype[key];
-          var newValue = value;
-          switch (key) {
-            case 'getContextAttributes':
-              newValue = virtualGetContextAttributes;
-              break;
-            case 'getExtension':
-              newValue = createGetExtensionWrapper(value);
-              break;
-            case 'bindFramebuffer':
-              newValue = virtualBindFramebuffer;
-              break;
-            case 'getParameter':
-              newValue = virtualGetParameter;
-              break;
-            case 'readPixels':
-              newValue = virtualReadPixels;
-              break;
-            case 'clear':
-            case 'drawArrays':
-            case 'drawElements':
-              newValue = createDrawWrapper(value);
-              break;
-            default:
-              if (typeof value === 'function') {
-                newValue = createWrapper(value);
-              }
-              break;
-          }
-          VirtualWebGLContext.prototype[key] = newValue;
-          break;
-        }
-    }
-  }
-  function createGetExtensionWrapper(origFn) {
-    return function (extensionName) {
-      extensionName = extensionName.toLowerCase();
-      // just like the real context each extension needs a virtual class because each use
-      // of the extension might be modified (as in people adding properties to it)
-      var existingExt = this._extensions[extensionName];
-      if (existingExt) {
-        return existingExt;
-      }
-      var ext = origFn.call(sharedWebGLContext, extensionName);
-      var wrapperInfo = extensionInfo[extensionName] || {};
-      var wrapperFnMakerFn = wrapperInfo.wrapperFnMakerFn || (() => {
-        console.log('trying to get extension:', extensionName);
-      });
-      var saveRestoreHelper = extensionSaveRestoreHelpers[extensionName];
-      if (!saveRestoreHelper) {
-        var saveRestoreMakerFn = wrapperInfo.saveRestoreMakerFn;
-        if (saveRestoreMakerFn) {
-          var saveRestore = saveRestoreMakerFn(ext);
-          extensionSaveRestoreHelpers[extensionName] = saveRestore;
-          extensionSaveRestoreHelpersArray.push(saveRestore);
-        }
-      }
-      var wrapper = {
-        _context: this
-      };
-      for (var _key2 in ext) {
-        var _value2 = ext[_key2];
-        if (typeof _value2 === 'function') {
-          _value2 = wrapperFnMakerFn(ext, _value2, extensionName);
-        }
-        wrapper[_key2] = _value2;
-      }
-      this._extensions[extensionName] = wrapper;
-      return wrapper;
-    };
-  }
-  function isFramebufferBindingNull(vctx) {
-    return vctx._state.framebuffer === vctx._drawingbufferFramebuffer;
-  }
-  function makeOES_vertex_array_objectWrapper(ext, origFn, name) {
-    switch (name) {
-      case 'bindVertexArrayOES':
-        return virutalbindVertexArrayOES;
-    }
-    return function () {
-      makeCurrentContext(this._context);
-      resizeCanvasIfChanged(this._context);
-      for (var _len = arguments.length, args = new Array(_len), _key3 = 0; _key3 < _len; _key3++) {
-        args[_key3] = arguments[_key3];
-      }
-      return origFn.call(ext, ...args);
-    };
-  }
-  function virutalbindVertexArrayOES(vao) {
-    makeCurrentContext(this._context);
-    resizeCanvasIfChanged(this._context);
-    if (!vao) {
-      vao = this._context._defaultVertexArray;
-    }
-    sharedVAOExtension.bindVertexArrayOES(vao);
-  }
-  function makeANGLE_instanced_arraysWrapper(ext, origFn, name) {
-    switch (name) {
-      case 'drawArraysInstancedANGLE':
-      case 'drawElementsInstancedANGLE':
-        return createExtDrawWrapper(ext, origFn);
-        break;
-    }
-    return function () {
-      makeCurrentContext(this._context);
-      resizeCanvasIfChanged(this._context);
-      for (var _len2 = arguments.length, args = new Array(_len2), _key4 = 0; _key4 < _len2; _key4++) {
-        args[_key4] = arguments[_key4];
-      }
-      return origFn.call(ext, ...args);
-    };
-  }
-  function createExtDrawWrapper(ext, origFn) {
-    return function () {
-      // a rendering function was called so we need to copy are drawingBuffer
-      // to the canvas for this context after the current event.
-      beforeDraw(this._context);
-      for (var _len3 = arguments.length, args = new Array(_len3), _key5 = 0; _key5 < _len3; _key5++) {
-        args[_key5] = arguments[_key5];
-      }
-      var result = origFn.call(exts, ...args);
-      afterDraw(this._context);
-      return result;
-    };
-  }
-  function makeWEBGL_draw_buffersWrapper(ext, origFn, name) {
-    var gl = sharedWebGLContext;
-    var backBuffer = [gl.COLOR_ATTACHMENT0];
-    return function (drawingBuffers) {
-      makeCurrentContext(this._context);
-      resizeCanvasIfChanged(this._context);
-      // if the virtual context is bound to canvas then fake it
-      if (isFramebufferBindingNull(this._context)) {
-        // this really isn't checking everything
-        // for example if the user passed in array.length != 1
-        // then we are supposed to generate an error
-        if (drawingBuffers[0] === gl.BACK) {
-          drawingBuffers = backBuffer;
-        }
-      }
-      origFn.call(ext, drawingBuffers);
-    };
-  }
-  function makeWEBGL_drawBuffersSaveRestoreHelper(ext) {
-    var gl = sharedWebGLContext;
-    var maxDrawBuffers = gl.getParameter(ext.MAX_DRAW_BUFFERS_WEBGL);
-    var defaultBackDrawBuffers = [gl.BACK];
-    var defaultFBDrawBuffers = [gl.COLOR_ATTACHMENT0];
-    for (var i = 1; i < maxDrawBuffers; ++i) {
-      defaultFBDrawBuffers.push(gl.NONE);
-    }
-    function initDrawBufferState(state) {
-      state.drawBuffers = state.framebuffer ? defaultFBDrawBuffers.slice() : defaultBackDrawBuffers.slice();
-    }
-    function save(state) {
-      if (!state.drawBuffers) {
-        initDrawBufferState(state);
-      }
-      // remember state.framebuffer is only null for the offscreen canvas
-      var drawBuffers = state.drawBuffers;
-      for (var _i2 = 0; _i2 < drawBuffers.length; ++_i2) {
-        drawBuffers[_i2] = gl.getParameter(ext.DRAW_BUFFER0_WEBGL + _i2);
-      }
-    }
-    function restore(state) {
-      if (!state.drawBuffers) {
-        initDrawBufferState(state);
-      }
-      ext.drawBuffersWEBGL(state.drawBuffers);
-    }
-    return {
-      save,
-      restore
-    };
-  }
-  function virtualGetContextAttributes() {
-    return this._contextAttributes;
-  }
-  function virtualReadPixels() {
-    makeCurrentContext(this);
-    resizeCanvasIfChanged(this);
-    clearIfNeeded(this);
-    var gl = sharedWebGLContext;
-    return gl.readPixels(...arguments);
-  }
-  function virtualGetParameter(pname) {
-    makeCurrentContext(this);
-    resizeCanvasIfChanged(this);
-    var gl = sharedWebGLContext;
-    var value = gl.getParameter(pname);
-    switch (pname) {
-      case gl.FRAMEBUFFER_BINDING:
-        if (value === this._drawingbufferFramebuffer) {
-          return null;
-        }
-        break;
-      case 0x8825:
-        // DRAW_BUFFER0_WEBGL
-        if (isFramebufferBindingNull(this)) {
-          if (value === gl.COLOR_ATTACHMENT0) {
-            return gl.BACK;
-          }
-        }
-        break;
-      case 0x85b5:
-        // VERTEX_ARRAY_BINDING_OES
-        if (value === this._defaultVertexArray) {
-          return null;
-        }
-        break;
-    }
-    return value;
-  }
-  function virtualBindFramebuffer(bindpoint, framebuffer) {
-    makeCurrentContext(this);
-    resizeCanvasIfChanged(this);
-    var gl = sharedWebGLContext;
-    if (bindpoint === WebGLRenderingContext.FRAMEBUFFER) {
-      if (framebuffer === null) {
-        // bind our drawingBuffer
-        framebuffer = this._drawingbufferFramebuffer;
-      }
-    }
-    gl.bindFramebuffer(bindpoint, framebuffer);
-    this._state.framebuffer = framebuffer;
-  }
-  function createWrapper(origFn) {
-    // lots of optimization could happen here depending on specific functions
-    return function () {
-      makeCurrentContext(this);
-      resizeCanvasIfChanged(this);
-      for (var _len4 = arguments.length, args = new Array(_len4), _key6 = 0; _key6 < _len4; _key6++) {
-        args[_key6] = arguments[_key6];
-      }
-      return origFn.call(sharedWebGLContext, ...args);
-    };
-  }
-  function clearIfNeeded(vctx) {
-    if (vctx._needClear) {
-      vctx._needClear = false;
-      var _gl = sharedWebGLContext;
-      _gl.bindFramebuffer(_gl.FRAMEBUFFER, vctx._drawingbufferFramebuffer);
-      _gl.disable(_gl.SCISSOR_TEST);
-      _gl.clear(_gl.COLOR_BUFFER_BIT | _gl.DEPTH_BUFFER_BIT | _gl.STENCIL_BUFFER_BIT);
-      enableDisable(_gl, _gl.SCISSOR_TEST, vctx._state.scissorTest);
-      _gl.bindFramebuffer(_gl.FRAMEBUFFER, vctx._state.framebuffer);
-    }
-  }
-  function beforeDraw(vctx) {
-    makeCurrentContext(vctx);
-    resizeCanvasIfChanged(vctx);
-    clearIfNeeded(vctx);
-  }
-  function afterDraw(vctx) {
-    if (isFramebufferBindingNull(vctx)) {
-      vctx._needComposite = true;
-      if (!someContextsNeedRendering) {
-        someContextsNeedRendering = true;
-        setTimeout(renderAllDirtyVirtualCanvases, 0);
-      }
-    }
-  }
-  function createDrawWrapper(origFn) {
-    return function () {
-      // a rendering function was called so we need to copy are drawingBuffer
-      // to the canvas for this context after the current event.
-      beforeDraw(this);
-      for (var _len5 = arguments.length, args = new Array(_len5), _key7 = 0; _key7 < _len5; _key7++) {
-        args[_key7] = arguments[_key7];
-      }
-      var result = origFn.call(sharedWebGLContext, ...args);
-      afterDraw(this);
-      return result;
-    };
-  }
-  function makeCurrentContext(vctx) {
-    if (currentVirtualContext === vctx) {
-      return;
-    }
-
-    // save all current WebGL state on the previous current virtual context
-    if (currentVirtualContext) {
-      saveAllState(currentVirtualContext._state, currentVirtualContext);
-    }
-
-    // restore all state for the new context
-    restoreAllState(vctx._state, vctx);
-
-    // check if the current state is supposed to be rendering to the canvas.
-    // if so bind vctx._drawingbuffer
-
-    currentVirtualContext = vctx;
-  }
-  function resizeCanvasIfChanged(vctx) {
-    var width = vctx.canvas.width;
-    var height = vctx.canvas.height;
-    if (width !== vctx._width || height !== vctx._height) {
-      vctx._width = width;
-      vctx._height = height;
-      var _gl2 = sharedWebGLContext;
-      var oldTexture = _gl2.getParameter(_gl2.TEXTURE_BINDING_2D);
-      var format = vctx._contextAttributes.alpha ? _gl2.RGBA : _gl2.RGB;
-      _gl2.bindTexture(_gl2.TEXTURE_2D, vctx._drawingbufferTexture);
-      _gl2.texImage2D(_gl2.TEXTURE_2D, 0, format, width, height, 0, format, _gl2.UNSIGNED_BYTE, null);
-      _gl2.bindTexture(_gl2.TEXTURE_2D, oldTexture);
-      if (vctx._depthRenderbuffer) {
-        var oldRenderbuffer = _gl2.getParameter(_gl2.RENDERBUFFER_BINDING);
-        var internalFormat = vctx._contextAttributes.stencil ? _gl2.DEPTH_STENCIL : _gl2.DEPTH_COMPONENT16;
-        _gl2.bindRenderbuffer(_gl2.RENDERBUFFER, vctx._depthRenderbuffer);
-        _gl2.renderbufferStorage(_gl2.RENDERBUFFER, internalFormat, width, height);
-        _gl2.bindRenderbuffer(_gl2.RENDERBUFFER, oldRenderbuffer);
-      }
-    }
-  }
-  function createOrGetVirtualWebGLContext(canvas, type, contextAttributes) {
-    // check if this canvas already has a context
-    var existingVirtualCtx = canvasToVirtualContextMap.get(canvas);
-    if (existingVirtualCtx) {
-      return existingVirtualCtx;
-    }
-    var compositor = settings.compositorCreator(canvas, type, contextAttributes) || new DefaultCompositor(canvas, type, contextAttributes);
-    var newVirtualCtx = new VirtualWebGLContext(canvas, contextAttributes, compositor, () => {
-      canvasToVirtualContextMap.delete(canvas);
-    });
-    canvasToVirtualContextMap.set(canvas, newVirtualCtx);
-    return newVirtualCtx;
-  }
-  function createProgram(gl, shaderSources) {
-    var program = gl.createProgram();
-    [gl.VERTEX_SHADER, gl.FRAGMENT_SHADER].forEach((type, ndx) => {
-      var shader = gl.createShader(type);
-      gl.shaderSource(shader, shaderSources[ndx]);
-      gl.compileShader(shader);
-      if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-        console.error(gl.getShaderInfoLog(shader)); // eslint-disable-line
-      }
-
-      gl.attachShader(program, shader);
-    });
-    gl.bindAttribLocation(program, 0, 'position');
-    gl.linkProgram(program);
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-      console.error(gl.getProgramInfoLog(program)); // eslint-disable-line
-    }
-
-    return program;
-  }
-  function saveAllState(state, vctx) {
-    // save all WebGL state (current bindings, current texture units,
-    // current attributes and/or vertex shade object, current program,
-    // current blend, stencil, zbuffer, culling, viewport etc... state
-    var gl = sharedWebGLContext;
-    state.activeTexture = gl.getParameter(gl.ACTIVE_TEXTURE);
-
-    // save texture units
-    for (var i = 0; i < numTextureUnits; ++i) {
-      gl.activeTexture(gl.TEXTURE0 + i);
-      var unit = state.textureUnits[i];
-      unit.texture2D = gl.getParameter(gl.TEXTURE_BINDING_2D);
-      unit.textureCubemap = gl.getParameter(gl.TEXTURE_BINDING_CUBE_MAP);
-    }
-
-    // bindings
-    state.arrayBuffer = gl.getParameter(gl.ARRAY_BUFFER_BINDING);
-    state.renderbuffer = gl.getParameter(gl.RENDERBUFFER_BINDING);
-    state.framebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
-
-    // save attributes
-    if (sharedVAOExtension) {
-      state.vertexArray = gl.getParameter(sharedVAOExtension.VERTEX_ARRAY_BINDING_OES);
-    } else {
-      for (var _i3 = 0; _i3 < numAttributes; ++_i3) {
-        var attrib = state.attributes[_i3];
-        attrib.buffer = gl.getVertexAttrib(_i3, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING);
-        attrib.enabled = gl.getVertexAttrib(_i3, gl.VERTEX_ATTRIB_ARRAY_ENABLED);
-        attrib.size = gl.getVertexAttrib(_i3, gl.VERTEX_ATTRIB_ARRAY_SIZE);
-        attrib.stride = gl.getVertexAttrib(_i3, gl.VERTEX_ATTRIB_ARRAY_STRIDE);
-        attrib.type = gl.getVertexAttrib(_i3, gl.VERTEX_ATTRIB_ARRAY_TYPE);
-        attrib.normalized = gl.getVertexAttrib(_i3, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED);
-        attrib.value = gl.getVertexAttrib(_i3, gl.CURRENT_VERTEX_ATTRIB);
-        attrib.offset = gl.getVertexAttribOffset(_i3, gl.VERTEX_ATTRIB_ARRAY_POINTER);
-        if (sharedInstanceExtension) {
-          attrib.divisor = gl.getVertexAttrib(_i3, sharedInstanceExtension.VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
-        }
-      }
-      state.elementArrayBuffer = gl.getParameter(gl.ELEMENT_ARRAY_BUFFER_BINDING);
-    }
-    state.blend = gl.getParameter(gl.BLEND);
-    state.cullFace = gl.getParameter(gl.CULL_FACE);
-    state.depthTest = gl.getParameter(gl.DEPTH_TEST);
-    state.dither = gl.getParameter(gl.DITHER);
-    state.polygonOffsetFill = gl.getParameter(gl.POLYGON_OFFSET_FILL);
-    state.sampleAlphaToCoverage = gl.getParameter(gl.SAMPLE_ALPHA_TO_COVERAGE);
-    state.sampleCoverage = gl.getParameter(gl.SAMPLE_COVERAGE);
-    state.scissorTest = gl.getParameter(gl.SCISSOR_TEST);
-    state.stencilTest = gl.getParameter(gl.STENCIL_TEST);
-    state.packAlignment = gl.getParameter(gl.PACK_ALIGNMENT);
-    state.unpackAlignment = gl.getParameter(gl.UNPACK_ALIGNMENT);
-    state.unpackColorspaceConversion = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);
-    state.unpackFlipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);
-    state.unpackPremultiplyAlpha = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);
-    state.currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-    state.viewport = gl.getParameter(gl.VIEWPORT);
-    state.scissor = gl.getParameter(gl.SCISSOR_BOX);
-    state.blendSrcRgb = gl.getParameter(gl.BLEND_SRC_RGB);
-    state.blendDstRgb = gl.getParameter(gl.BLEND_DST_RGB);
-    state.blendSrcAlpha = gl.getParameter(gl.BLEND_SRC_ALPHA);
-    state.blendDstAlpha = gl.getParameter(gl.BLEND_DST_ALPHA);
-    state.blendEquationRgb = gl.getParameter(gl.BLEND_EQUATION_RGB);
-    state.blendEquationAlpha = gl.getParameter(gl.BLEND_EQUATION_ALPHA);
-    state.blendColor = gl.getParameter(gl.BLEND_COLOR);
-    state.colorClearValue = gl.getParameter(gl.COLOR_CLEAR_VALUE);
-    state.colorMask = gl.getParameter(gl.COLOR_WRITEMASK);
-    state.cullFaceMode = gl.getParameter(gl.CULL_FACE_MODE);
-    state.depthClearValue = gl.getParameter(gl.DEPTH_CLEAR_VALUE);
-    state.depthFunc = gl.getParameter(gl.DEPTH_FUNC);
-    state.depthRange = gl.getParameter(gl.DEPTH_RANGE);
-    state.depthMask = gl.getParameter(gl.DEPTH_WRITEMASK);
-    state.frontFace = gl.getParameter(gl.FRONT_FACE);
-    state.generateMipmapHint = gl.getParameter(gl.GENERATE_MIPMAP_HINT);
-    state.lineWidth = gl.getParameter(gl.LINE_WIDTH);
-    state.polygonOffsetFactor = gl.getParameter(gl.POLYGON_OFFSET_FACTOR);
-    state.polygonOffsetUnits = gl.getParameter(gl.POLYGON_OFFSET_UNITS);
-    state.sampleCoverageValue = gl.getParameter(gl.SAMPLE_COVERAGE_VALUE);
-    state.sampleCoverageUnits = gl.getParameter(gl.SAMPLE_COVERAGE_INVERT);
-    state.stencilBackFail = gl.getParameter(gl.STENCIL_BACK_FAIL);
-    state.stencilBackFunc = gl.getParameter(gl.STENCIL_BACK_FUNC);
-    state.stencilBackPassDepthFail = gl.getParameter(gl.STENCIL_BACK_PASS_DEPTH_FAIL);
-    state.stencilBackPassDepthPass = gl.getParameter(gl.STENCIL_BACK_PASS_DEPTH_PASS);
-    state.stencilBackRef = gl.getParameter(gl.STENCIL_BACK_REF);
-    state.stencilBackValueMask = gl.getParameter(gl.STENCIL_BACK_VALUE_MASK);
-    state.stencilBackWriteMask = gl.getParameter(gl.STENCIL_BACK_WRITEMASK);
-    state.stencilClearValue = gl.getParameter(gl.STENCIL_CLEAR_VALUE);
-    state.stencilFail = gl.getParameter(gl.STENCIL_FAIL);
-    state.stencilFunc = gl.getParameter(gl.STENCIL_FUNC);
-    state.stencilPassDepthFail = gl.getParameter(gl.STENCIL_PASS_DEPTH_FAIL);
-    state.stencilPassDepthPass = gl.getParameter(gl.STENCIL_PASS_DEPTH_PASS);
-    state.stencilRef = gl.getParameter(gl.STENCIL_REF);
-    state.stencilValueMask = gl.getParameter(gl.STENCIL_VALUE_MASK);
-    state.stencilWriteMask = gl.getParameter(gl.STENCIL_WRITEMASK);
-    for (var fns of extensionSaveRestoreHelpersArray) {
-      fns.save(state, vctx);
-    }
-  }
-  function restoreAllState(state, vctx) {
-    // restore all WebGL state (current bindings, current texture units,
-    // current attributes and/or vertex shade object, current program,
-    // current blend, stencil, zbuffer, culling, viewport etc... state
-    // save all WebGL state (current bindings, current texture units,
-    // current attributes and/or vertex shade object, current program,
-    // current blend, stencil, zbuffer, culling, viewport etc... state
-    var gl = sharedWebGLContext;
-
-    // restore texture units
-    for (var i = 0; i < numTextureUnits; ++i) {
-      gl.activeTexture(gl.TEXTURE0 + i);
-      var unit = state.textureUnits[i];
-      gl.bindTexture(gl.TEXTURE_2D, unit.texture2D);
-      gl.bindTexture(gl.TEXTURE_CUBE_MAP, unit.textureCubemap);
-    }
-    gl.activeTexture(state.activeTexture);
-
-    // restore attributes
-    if (sharedVAOExtension) {
-      sharedVAOExtension.bindVertexArrayOES(state.vertexArray);
-    } else {
-      for (var _i4 = 0; _i4 < numAttributes; ++_i4) {
-        var attrib = state.attributes[_i4];
-        if (attrib.enabled) {
-          gl.enableVertexAttribArray(_i4);
-        } else {
-          gl.disableVertexAttribArray(_i4);
-        }
-        gl.vertexAttrib4fv(_i4, attrib.value);
-        gl.bindBuffer(gl.ARRAY_BUFFER, attrib.buffer);
-        gl.vertexAttribPointer(_i4, attrib.size, attrib.type, attrib.normalized, attrib.stride, attrib.offset);
-        if (sharedInstanceExtension) {
-          sharedInstanceExtension.vertexAttribDivisorANGLE(_i4, attrib.divisor);
-        }
-      }
-      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, state.elementArrayBuffer);
-    }
-
-    // bindings'
-    gl.bindBuffer(gl.ARRAY_BUFFER, state.arrayBuffer);
-    gl.bindRenderbuffer(gl.RENDERBUFFER, state.renderbuffer);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, state.framebuffer);
-    enableDisable(gl, gl.BLEND, state.blend);
-    enableDisable(gl, gl.CULL_FACE, state.cullFace);
-    enableDisable(gl, gl.DEPTH_TEST, state.depthTest);
-    enableDisable(gl, gl.DITHER, state.dither);
-    enableDisable(gl, gl.POLYGON_OFFSET_FILL, state.polygonOffsetFill);
-    enableDisable(gl, gl.SAMPLE_ALPHA_TO_COVERAGE, state.sampleAlphaToCoverage);
-    enableDisable(gl, gl.SAMPLE_COVERAGE, state.sampleCoverage);
-    enableDisable(gl, gl.SCISSOR_TEST, state.scissorTest);
-    enableDisable(gl, gl.STENCIL_TEST, state.stencilTest);
-    gl.pixelStorei(gl.PACK_ALIGNMENT, state.packAlignment);
-    gl.pixelStorei(gl.UNPACK_ALIGNMENT, state.unpackAlignment);
-    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, state.unpackColorspaceConversion);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, state.unpackFlipY);
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, state.unpackPremultiplyAlpha);
-    gl.useProgram(state.currentProgram);
-    gl.viewport(...state.viewport);
-    gl.scissor(...state.scissor);
-    gl.blendFuncSeparate(state.blendSrcRgb, state.blendDstRgb, state.blendSrcAlpha, state.blendDstAlpha);
-    gl.blendEquationSeparate(state.blendEquationRgb, state.blendEquationAlpha);
-    gl.blendColor(...state.blendColor);
-    gl.clearColor(...state.colorClearValue);
-    gl.colorMask(...state.colorMask);
-    gl.cullFace(state.cullFaceMode);
-    gl.clearDepth(state.depthClearValue);
-    gl.depthFunc(state.depthFunc);
-    gl.depthRange(...state.depthRange);
-    gl.depthMask(state.depthMask);
-    gl.frontFace(state.frontFace);
-    gl.hint(gl.GENERATE_MIPMAP_HINT, state.generateMipmapHint);
-    gl.lineWidth(state.lineWidth);
-    gl.polygonOffset(state.polygonOffsetFactor, state.polygonOffsetUnits);
-    gl.sampleCoverage(state.sampleCoverageValue, state.sampleCoverageUnits);
-    gl.stencilFuncSeparate(gl.BACK, state.stencilBackFunc, state.stencilBackRef, state.stencilBackValueMask);
-    gl.stencilFuncSeparate(gl.FRONT, state.stencilFunc, state.stencilRef, state.stencilValueMask);
-    gl.stencilOpSeparate(gl.BACK, state.stencilBackFail, state.stencilBackPassDepthFail, state.stencilBackPassDepthPass);
-    gl.stencilOpSeparate(gl.FRONT, state.stencilFail, state.stencilPassDepthFail, state.stencilPassDepthPass);
-    gl.stencilMaskSeparate(gl.BACK, state.stencilBackWriteMask);
-    gl.stencilMaskSeparate(gl.FRONT, state.stencilWriteMask);
-    gl.clearStencil(state.stencilClearValue);
-    for (var fns of extensionSaveRestoreHelpersArray) {
-      fns.restore(state, vctx);
-    }
-  }
-  function enableDisable(gl, feature, enable) {
-    if (enable) {
-      gl.enable(feature);
-    } else {
-      gl.disable(feature);
-    }
-  }
-  function renderAllDirtyVirtualCanvases() {
-    if (!someContextsNeedRendering) {
-      return;
-    }
-    someContextsNeedRendering = false;
-
-    // save all current WebGL state on the previous current virtual context
-    if (currentVirtualContext) {
-      saveAllState(currentVirtualContext._state, currentVirtualContext);
-      currentVirtualContext = null;
-    }
-
-    // set the state back to the one for drawing the canvas
-    restoreAllState(baseState);
-    for (var vctx of canvasToVirtualContextMap.values()) {
-      if (!vctx._needComposite) {
-        continue;
-      }
-      vctx._needComposite = false;
-      vctx.composite(sharedWebGLContext);
-    }
-  }
-  window.requestAnimationFrame = function (origFn) {
-    return function (callback) {
-      return origFn.call(window, time => {
-        var result = callback(time);
-        renderAllDirtyVirtualCanvases();
-        return result;
-      });
-    };
-  }(window.requestAnimationFrame);
-  function setup(options) {
-    Object.assign(settings, options);
-  }
-  window.virtualWebGL = {
-    setup
-  };
-}
-//# sourceMappingURL=virtual-webgl.js.map