@luma.gl/webgl 9.0.0-alpha.5 → 9.0.0-alpha.7

package/src/adapter/resources/webgl-texture.ts

@@ -10,11 +10,12 @@ import {
   Sampler,
   SamplerProps,
   SamplerParameters,
+  TypedArray,
   isObjectEmpty
 } from '@luma.gl/api';
 import {Texture, cast, log, assert, isPowerOfTwo, loadImage} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import type {WebGLSamplerParameters} from '../../types/webgl';
+import type {GLSamplerParameters} from '../../types/webgl';
 import {withParameters} from '../../context/state-tracker/with-parameters';
 import {
   getWebGLTextureFormat,
@@ -31,22 +32,31 @@ import WEBGLSampler from './webgl-sampler';
 
 export type {TextureProps};
 
+export type TextureSourceData = 
+  TypedArray |
+  ImageData |
+  HTMLImageElement |
+  HTMLCanvasElement |
+  ImageBitmap |
+  HTMLVideoElement
+  ;
+
 type SetImageDataOptions = {
   target?: number;
   level?: number;
   dataFormat?: any;
-  width: number;
-  height: number;
+  width?: number;
+  height?: number;
   depth?: number;
-  format: any;
+  format?: any;
   type?: any;
   offset?: number;
-  data: any;
+  data: any; // TextureSourceData;
   compressed?: boolean;
   parameters?: Record<GL, any>;
   /** @deprecated */
   pixels?: any;
-};
+}
 
 /**
  * @param {*} pixels, data -
@@ -92,10 +102,10 @@ type SetSubImageDataOptions = {
 type SetImageData3DOptions = {
   level?: number;
   dataFormat?: any;
-  width: number;
-  height: number;
+  width?: number;
+  height?: number;
   depth?: number;
-  format: any;
+  format?: any;
   type?: any;
   offset?: number;
   data: any;
@@ -189,8 +199,8 @@ export default class WEBGLTexture extends Texture {
       this.gl.deleteTexture(this.handle);
       this.removeStats();
       this.trackDeallocatedMemory('Texture');
-      // @ts-expect-error
-      this.handle = null;
+      // this.handle = null;
+      this.destroyed = true;
     }
   }
 
@@ -714,7 +724,7 @@ export default class WEBGLTexture extends Texture {
 
   // HELPER METHODS
 
-  _deduceParameters(opts) {
+  _deduceParameters(opts: TextureProps) {
     const {format, data} = opts;
     let {width, height, dataFormat, type, compressed} = opts;
 
@@ -857,18 +867,20 @@ export default class WEBGLTexture extends Texture {
   }
 
   /** Image 3D copies from Typed Array or WebGLBuffer */
-  setImageData3D({
-    level = 0,
-    dataFormat,
-    format,
-    type, // = GL.UNSIGNED_BYTE,
-    width,
-    height,
-    depth = 1,
-    offset = 0,
-    data,
-    parameters = {}  as Record<GL, any> as Record<GL, any>
-  }: SetImageData3DOptions) {
+  setImageData3D(options: SetImageData3DOptions) {
+    const {
+      level = 0,
+      dataFormat,
+      format,
+      type, // = GL.UNSIGNED_BYTE,
+      width,
+      height,
+      depth = 1,
+      offset = 0,
+      data,
+      parameters = {}
+    } = options;
+
     this.trackDeallocatedMemory('Texture');
 
     this.gl.bindTexture(this.target, this.handle);
@@ -928,7 +940,7 @@ export default class WEBGLTexture extends Texture {
    * Sets sampler parameters on texture
    * @note: Applies NPOT workaround if appropriate
    */
-  _setSamplerParameters(parameters: WebGLSamplerParameters) {
+  _setSamplerParameters(parameters: GLSamplerParameters) {
     // Work around WebGL1 sampling restrictions on NPOT textures
     if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
       parameters = updateSamplerParametersForNPOT(parameters);

package/src/adapter/webgl-canvas-context.ts

@@ -12,7 +12,7 @@ import WEBGLFramebuffer from './resources/webgl-framebuffer';
 export default class WebGLCanvasContext extends CanvasContext {
   readonly device: WebGLDevice;
   presentationSize: [number, number];
-  private _framebuffer: WEBGLFramebuffer;
+  private _framebuffer: WEBGLFramebuffer | null = null;
 
   constructor(device: WebGLDevice, props: CanvasContextProps) {
     // Note: Base class creates / looks up the canvas (unless under Node.js)

package/src/adapter/webgl-device.ts

@@ -12,7 +12,8 @@ import {isBrowser} from '@probe.gl/env';
 import {polyfillContext} from '../context/polyfill/polyfill-context';
 import {trackContextState} from '../context/state-tracker/track-context-state';
 import {ContextState} from '../context/context/context-state';
-import {createBrowserContext} from '../context/context/create-context';
+import {createBrowserContext} from '../context/context/create-browser-context';
+import {createHeadlessContext, isHeadlessGLRegistered} from '../context/context/create-headless-context';
 import {getDeviceInfo} from './device-helpers/get-device-info';
 import {getDeviceFeatures} from './device-helpers/device-features';
 import {getDeviceLimits, getWebGLLimits, WebGLLimits} from './device-helpers/device-limits';
@@ -65,7 +66,7 @@ export default class WebGLDevice extends Device implements ContextState {
   static type: string = 'webgl';
 
   static isSupported(): boolean {
-    return typeof WebGLRenderingContext !== 'undefined';
+    return typeof WebGLRenderingContext !== 'undefined' || isHeadlessGLRegistered();
   }
 
   readonly info: DeviceInfo;
@@ -171,7 +172,11 @@ export default class WebGLDevice extends Device implements ContextState {
     // Create and instrument context
     this.canvasContext = new WebGLCanvasContext(this, props);
 
-    this.handle = props.gl || createBrowserContext(this.canvasContext.canvas, props);
+    let gl = props.gl;
+    gl = gl || (isBrowser() && createBrowserContext(this.canvasContext.canvas, props));
+    gl = gl || (!isBrowser() && createHeadlessContext(props));
+
+    this.handle = gl;
     this.gl = this.handle;
     this.gl2 = this.gl as WebGL2RenderingContext;
     this.isWebGL2 = isWebGL2(this.gl);
@@ -187,8 +192,15 @@ export default class WebGLDevice extends Device implements ContextState {
 
     // Add subset of WebGL2 methods to WebGL1 context
     polyfillContext(this.gl);
+
     // Install context state tracking
-    trackContextState(this.gl, {copyState: false, log: (...args: any[]) => log.log(1, ...args)()});
+    // @ts-expect-error - hidden parameters
+    const {enable = true, copyState = false} = props;
+    trackContextState(this.gl, {
+      enable,
+      copyState, 
+      log: (...args: any[]) => log.log(1, ...args)()
+    });
 
     // DEBUG contexts: Add debug instrumentation to the context, force log level to at least 1
     if (isBrowser() && props.debug) {

package/src/classic/buffer.ts

@@ -111,8 +111,8 @@ export default class ClassicBuffer extends WEBGLBuffer {
       this.removeStats();
       this.trackDeallocatedMemory();
       this.gl.deleteBuffer(this.handle);
-      // @ts-expect-error
-      this.handle = null;
+      // this.handle = null;
+      this.destroyed = true;
     }
   }
 
@@ -264,7 +264,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
     // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type
     gl.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);
     gl.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);
-    gl2.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl2?.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
     gl.bindBuffer(GL.COPY_READ_BUFFER, null);
     gl.bindBuffer(GL.COPY_WRITE_BUFFER, null);
 
@@ -314,7 +314,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
 
     // Use GL.COPY_READ_BUFFER to avoid disturbing other targets and locking type
     this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);
-    this.gl2.getBufferSubData(GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
+    this.gl2?.getBufferSubData(GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
     this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
 
     // TODO - update local `data` if offsets are 0
@@ -340,10 +340,10 @@ export default class ClassicBuffer extends WEBGLBuffer {
     // uniform buffer state. Instead indexed bindings need to be made.
     if (target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER) {
       if (size !== undefined) {
-        this.gl2.bindBufferRange(target, index, this.handle, offset, size);
+        this.gl2?.bindBufferRange(target, index, this.handle, offset, size);
       } else {
         assert(offset === 0); // Make sure offset wasn't supplied
-        this.gl2.bindBufferBase(target, index, this.handle);
+        this.gl2?.bindBufferBase(target, index, this.handle);
       }
     } else {
       this.gl.bindBuffer(target, this.handle);
@@ -356,7 +356,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
     const {target = this.target, index = this.accessor && this.accessor.index} = options || {};
     const isIndexedBuffer = target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER;
     if (isIndexedBuffer) {
-      this.gl2.bindBufferBase(target, index, null);
+      this.gl2?.bindBufferBase(target, index, null);
     } else {
       this.gl.bindBuffer(target, null);
     }

package/src/classic/typed-array-utils.ts

@@ -1,4 +1,6 @@
-import {TypedArray} from '@luma.gl/api/types';
+// luma.gl, MIT license
+
+import {TypedArray} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
 import {GLType} from '../types/webgl'
 

package/src/context/context/{create-context.ts → create-browser-context.ts}

@@ -55,7 +55,7 @@ const DEFAULT_CONTEXT_PROPS: ContextProps = {
   canvas.addEventListener('webglcontextcreationerror', onCreateError, false);
 
   // Create the desired context
-  let gl = null;
+  let gl: WebGLRenderingContext | null = null;
 
   if (props.type === 'webgl2') {
     props = {...props, webgl1: false};
@@ -66,10 +66,10 @@ const DEFAULT_CONTEXT_PROPS: ContextProps = {
 
   // Prefer webgl2 over webgl1 if both are acceptable
   if (props.webgl2) {
-    gl = gl || canvas.getContext('webgl2', props);
+    gl = gl || canvas.getContext('webgl2', props) as WebGL2RenderingContext | null;
   }
   if (props.webgl1) {
-    gl = gl || canvas.getContext('webgl', props);
+    gl = gl || canvas.getContext('webgl', props) as WebGLRenderingContext | null;
   }
 
   // TODO are we removing this listener before giving it a chance to fire?
@@ -83,8 +83,12 @@ const DEFAULT_CONTEXT_PROPS: ContextProps = {
     );
   }
 
-  canvas.addEventListener('webglcontextlost', props.onContextLost, false);
-  canvas.addEventListener('webglcontextrestored', props.onContextRestored, false);
+  if (props.onContextLost) {
+    canvas.addEventListener('webglcontextlost', props.onContextLost, false);
+  }
+  if (props.onContextRestored) {
+    canvas.addEventListener('webglcontextrestored', props.onContextRestored, false);
+  }
 
   return gl;
 }

package/src/context/context/create-headless-context.ts

@@ -0,0 +1,48 @@
+const ERR_HEADLESSGL_FAILED =
+  'Failed to create WebGL context in Node.js, headless gl returned null';
+
+const ERR_HEADLESSGL_LOAD = `\
+  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL \
+  contexts can not be created. This may not be an error. For example, this is a \
+  typical configuration for isorender applications running on the server.`;
+
+const CONTEXT_DEFAULTS = {
+  width: 1,
+  height: 1,
+  debug: true,
+  throwOnError: false
+};
+
+/** Duck typing for the main headless gl export, a function to create contexts */
+export type HeadlessGL = (width: number, height: number, options: Record<string, unknown>) => WebGLRenderingContext;
+
+let headlessGL: HeadlessGL | null = null; 
+
+/** By importing `gl` and registering it with this function, contexts can be created under Node.js */
+export function registerHeadlessGL(headlessgl: HeadlessGL) {
+  headlessGL = headlessgl;
+}
+
+/** @returns true if headless gl is registered */
+export function isHeadlessGLRegistered(): boolean {
+  return headlessGL !== null;
+}
+
+/** Create headless gl context (for running under Node.js) */
+export function createHeadlessContext(options?: Record<string, any>): WebGLRenderingContext {
+  options = {...CONTEXT_DEFAULTS, ...options};
+
+  const {width, height, webgl1, webgl2} = options;
+
+  if (webgl2 && !webgl1) {
+    throw new Error('headless-gl does not support WebGL2');
+  }
+  if (!headlessGL) {
+    throw new Error(ERR_HEADLESSGL_LOAD);
+  }
+  const gl = headlessGL(width, height, options);
+  if (!gl) {
+    throw new Error(ERR_HEADLESSGL_FAILED);
+  }
+  return gl;
+}

package/src/context/context/device-pixels.ts

@@ -53,16 +53,22 @@ export function cssToDeviceRatio(gl: WebGLRenderingContext): number {
 
 // use devicePixelRatio to set canvas width and height
 export function setDevicePixelRatio(gl: WebGLRenderingContext, devicePixelRatio: number, options: {width?: number, height?: number} = {}) {
+  if (!(gl.canvas instanceof HTMLCanvasElement)) {
+    return;
+  }
+
+  const canvas: HTMLCanvasElement = gl.canvas;
+
   // NOTE: if options.width and options.height not used remove in v8
-  let clientWidth = 'width' in options ? options.width : gl.canvas.clientWidth;
-  let clientHeight = 'height' in options ? options.height : gl.canvas.clientHeight;
+  let clientWidth = 'width' in options ? options.width : canvas.clientWidth;
+  let clientHeight = 'height' in options ? options.height : canvas.clientHeight;
 
   if (!clientWidth || !clientHeight) {
     log.log(1, 'Canvas clientWidth/clientHeight is 0')();
-    // by forcing devicePixel ratio to 1, we do not scale gl.canvas.width and height in each frame.
+    // by forcing devicePixel ratio to 1, we do not scale canvas.width and height in each frame.
     devicePixelRatio = 1;
-    clientWidth = gl.canvas.width || 1;
-    clientHeight = gl.canvas.height || 1;
+    clientWidth = canvas.width || 1;
+    clientHeight = canvas.height || 1;
   }
 
   const contextState = getContextState(gl);
@@ -77,8 +83,8 @@ export function setDevicePixelRatio(gl: WebGLRenderingContext, devicePixelRatio:
 
     const canvasWidth = Math.floor(clientWidth * clampedPixelRatio);
     const canvasHeight = Math.floor(clientHeight * clampedPixelRatio);
-    gl.canvas.width = canvasWidth;
-    gl.canvas.height = canvasHeight;
+    canvas.width = canvasWidth;
+    canvas.height = canvasHeight;
 
     // Note: when devicePixelRatio is too high, it is possible we might hit system limit for
     // drawing buffer width and hight, in those cases they get clamped and resulting aspect ration may not be maintained
@@ -90,8 +96,8 @@ export function setDevicePixelRatio(gl: WebGLRenderingContext, devicePixelRatio:
         gl.drawingBufferHeight / clientHeight
       );
 
-      gl.canvas.width = Math.floor(clientWidth * clampedPixelRatio);
-      gl.canvas.height = Math.floor(clientHeight * clampedPixelRatio);
+      canvas.width = Math.floor(clientWidth * clampedPixelRatio);
+      canvas.height = Math.floor(clientHeight * clampedPixelRatio);
     }
 
     Object.assign(contextState._canvasSizeInfo, {clientWidth, clientHeight, devicePixelRatio});

package/src/context/debug/spector.ts

@@ -32,7 +32,7 @@ export async function loadSpectorJS(props?: SpectorProps) {
     try {
       await loadScript(SPECTOR_CDN_URL);
     } catch(error) {
-      log.warn(error)
+      log.warn(String(error))
     }
   }
 }

package/src/context/debug/webgl-developer-tools.ts

@@ -14,7 +14,7 @@ type DebugContextProps = {
 const DEFAULT_DEBUG_CONTEXT_PROPS: Required<DebugContextProps> = {
   debug: true,
   throwOnError: false,
-  break: undefined,
+  break: [],
   webgl2: false,
 }
 

package/src/context/parameters/unified-parameter-api.ts

@@ -21,7 +21,10 @@ export type {GLParameters};
  * @note requires a `cache` object to be set on the context (gl.state.cache)
  * This object is used to fill in any missing values for composite setter functions
  */
-export function setParameters(device: Device | WebGLRenderingContext, parameters: GLParameters): void {
+export function setParameters(
+  device: Device | WebGLRenderingContext,
+  parameters: GLParameters
+): void {
   const webglDevice = WebGLDevice.attach(device);
   const gl = webglDevice.gl;
 
@@ -74,7 +77,10 @@ export function setParameters(device: Device | WebGLRenderingContext, parameters
 
 /**
  * Reads the entire WebGL state from a context
- * @returns - a newly created map, with values keyed by GL parameters
+
+  // default to querying all parameters
+
+  * @returns - a newly created map, with values keyed by GL parameters
  *
  * @note Copies the state from a context (gl.getParameter should not be overriden)
  * Reads the entire WebGL state from a context
@@ -83,13 +89,10 @@ export function setParameters(device: Device | WebGLRenderingContext, parameters
  * considered a very slow operation, to be used only if/when a context already manipulated
  * by external code needs to be synchronized for the first time
  */
-export function getParameters(gl: WebGLRenderingContext, parameters?: Record<keyof GLParameters, any>): GLParameters;
-export function getParameters(gl: WebGLRenderingContext, parameters?: (keyof GLParameters)[]): GLParameters;
-export function getParameters(gl: WebGLRenderingContext, parameters: keyof GLParameters): GLParameters;
-
-export function getParameters(gl, parameters) {
-  // default to querying all parameters
-  parameters = parameters || GL_PARAMETER_DEFAULTS;
+export function getParameters(
+  gl: WebGLRenderingContext,
+  parameters: keyof GLParameters | (keyof GLParameters)[] | GLParameters = GL_PARAMETER_DEFAULTS
+): GLParameters {
   // support both arrays of parameters and objects (keys represent parameters)
 
   if (typeof parameters === 'number') {

package/src/context/polyfill/polyfill-context.ts

@@ -65,7 +65,7 @@ function polyfillExtension(gl: WebGLRenderingContext, {extension, target, target
   for (const key of Object.keys(defaults)) {
     const extKey = `${key}${suffix}`;
 
-    let polyfill = null;
+    let polyfill: Function | null = null;
     if (key === 'meta') {
       // ignore
     } else if (typeof gl[key] === 'function') {

package/src/context/polyfill/polyfill-table.ts

@@ -81,7 +81,7 @@ export const WEBGL2_CONTEXT_POLYFILLS = {
     getQueryParameter(handle, pname) {
       return this.getQueryObject(handle, pname);
     },
-    getQueryObject: () => {}
+    getQueryObject: (handle: unknown, pname: unknown) => {}
   }
 };
 

package/src/context/state-tracker/track-context-state.ts

@@ -54,7 +54,7 @@ class GLState {
     let valueChanged = false;
     let oldValue; // = undefined
 
-    const oldValues: {[key: number | string]: any} = this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1];
+    const oldValues: {[key: number | string]: any} | null = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
 
     for (const key in values) {
       assert(key !== undefined);

package/src/index.ts

@@ -8,13 +8,16 @@
 import '@luma.gl/api';
 import './init'
 
+// Types
+export type {WebGLLimits} from './adapter/device-helpers/device-limits';
+
+export {registerHeadlessGL} from './context/context/create-headless-context';
+
+// WebGL adapter classes
 export {default as WebGLDevice} from './adapter/webgl-device';
 export {default as WebGLCanvasContext} from './adapter/webgl-canvas-context';
 
-// Legacy WebGL Classes - will be moved to gltools
-export {default as Accessor} from './classic/accessor';
-export type {ClassicBufferProps as BufferProps} from './classic/buffer';
-export {default as Buffer} from './classic/buffer';
+// WebGL Resource classes
 export {default as WEBGLResource, default as WebGLResource} from './adapter/objects/webgl-resource';
 export {default as WEBGLBuffer} from './adapter/resources/webgl-buffer';
 export {default as WEBGLTexture} from './adapter/resources/webgl-texture';
@@ -24,16 +27,21 @@ export {default as WEBGLSampler} from './adapter/resources/webgl-sampler';
 export {default as WEBGLFramebuffer} from './adapter/resources/webgl-framebuffer';
 
 export {default as WEBGLRenderPipeline} from './adapter/resources/webgl-render-pipeline';
-
 // export {default as WEBGLComputePipeline} from './adapter/resources/webgl-compute-pipeline';
 export {default as WEBGLCommandEncoder} from './adapter/resources/webgl-command-encoder';
 export {default as WEBGLRenderPass} from './adapter/resources/webgl-render-pass';
 //export {default as WEBGLComputePass} from './adapter/resources/webgl-compute-pass';
 
+// non-api resources
 export type {RenderbufferProps} from './adapter/objects/webgl-renderbuffer';
 export {default as WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
 export {default as WEBGLVertexArrayObject} from './adapter/objects/webgl-vertex-array-object';
 
+// WebGL adapter classes (Legacy, will be moved to gltools)
+export {default as Accessor} from './classic/accessor';
+export type {ClassicBufferProps, ClassicBufferProps as BufferProps} from './classic/buffer';
+export {default as ClassicBuffer, default as Buffer} from './classic/buffer';
+
 export {
   isWebGL,
   isWebGL2,

package/src/types/webgl.ts

@@ -120,7 +120,7 @@ export type GLStencilOp =
   | GL.INVERT;
 
 /** Parameters for textures and samplers */
-export type WebGLSamplerParameters = {
+export type GLSamplerParameters = {
   [GL.TEXTURE_WRAP_S]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
   [GL.TEXTURE_WRAP_T]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
   [GL.TEXTURE_WRAP_R]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
@@ -241,7 +241,7 @@ export type GLFunctionParameters = {
   clearDepth?: number;
   clearStencil?: number;
 
-  colorMask?: [boolean, boolean, boolean, boolean];
+  colorMask?: [boolean, boolean, boolean, boolean] | boolean[];
 
   cull?: boolean;
   cullFace?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;
@@ -281,4 +281,4 @@ export type GLFunctionParameters = {
 };
 
 /** WebGL style parameters object (with both GL constants and function style fields) */
-export type GLParameters = GLValueParameters | GLFunctionParameters;
+export type GLParameters = GLValueParameters & GLFunctionParameters;

package/dist/context/context/create-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-context.d.ts","sourceRoot":"","sources":["../../../src/context/context/create-context.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;EAgBE;AACF,aAAK,YAAY,GAAG;IAClB,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACvC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC3C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,eAAe,CAAC,EAAE,SAAS,GAAI,kBAAkB,GAAG,WAAW,CAAC;IAChE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAC;AAUF;;;;GAIG;AACF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,EAAE,KAAK,EAAE,YAAY,GAAG,qBAAqB,CAyC7H"}

package/dist/context/context/create-context.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/context/create-context.ts"],"names":["DEFAULT_CONTEXT_PROPS","webgl2","webgl1","powerPreference","onContextLost","console","error","onContextRestored","info","createBrowserContext","canvas","props","errorMessage","onCreateError","statusMessage","addEventListener","gl","type","getContext","removeEventListener","Error"],"mappings":"AAmCA,MAAMA,qBAAmC,GAAG;AAC1CC,EAAAA,MAAM,EAAE,IADkC;AAE1CC,EAAAA,MAAM,EAAE,IAFkC;AAG1CC,EAAAA,eAAe,EAAE,kBAHyB;AAI1CC,EAAAA,aAAa,EAAE,MAAMC,OAAO,CAACC,KAAR,CAAc,oBAAd,CAJqB;AAK1CC,EAAAA,iBAAiB,EAAE,MAAMF,OAAO,CAACG,IAAR,CAAa,wBAAb;AALiB,CAA5C;AAaC,OAAO,SAASC,oBAAT,CAA8BC,MAA9B,EAA2EC,KAA3E,EAAuH;AAC5HA,EAAAA,KAAK,GAAG,EAAC,GAAGX,qBAAJ;AAA2B,OAAGW;AAA9B,GAAR;AAGD,MAAIC,YAAY,GAAG,IAAnB;;AACA,QAAMC,aAAa,GAAIP,KAAD,IAAYM,YAAY,GAAGN,KAAK,CAACQ,aAAN,IAAuBF,YAAxE;;AACAF,EAAAA,MAAM,CAACK,gBAAP,CAAwB,2BAAxB,EAAqDF,aAArD,EAAoE,KAApE;AAGA,MAAIG,EAAE,GAAG,IAAT;;AAEA,MAAIL,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,GAAG,EAAC,GAAGA,KAAJ;AAAWT,MAAAA,MAAM,EAAE;AAAnB,KAAR;AACD;;AACD,MAAIS,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,GAAG,EAAC,GAAGA,KAAJ;AAAWV,MAAAA,MAAM,EAAE;AAAnB,KAAR;AACD;;AAGD,MAAIU,KAAK,CAACV,MAAV,EAAkB;AAChBe,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,QAAlB,EAA4BP,KAA5B,CAAX;AACD;;AACD,MAAIA,KAAK,CAACT,MAAV,EAAkB;AAChBc,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,OAAlB,EAA2BP,KAA3B,CAAX;AACD;;AAGDD,EAAAA,MAAM,CAACS,mBAAP,CAA2B,2BAA3B,EAAwDN,aAAxD,EAAuE,KAAvE;;AAEA,MAAI,CAACG,EAAL,EAAS;AACP,UAAM,IAAII,KAAJ,4BACgBT,KAAK,CAACV,MAAN,IAAgB,CAACU,KAAK,CAACT,MAAvB,GAAgC,QAAhC,GAA2C,OAD3D,uBAEFU,YAAY,IAAI,eAFd,EAAN;AAKD;;AAEDF,EAAAA,MAAM,CAACK,gBAAP,CAAwB,kBAAxB,EAA4CJ,KAAK,CAACP,aAAlD,EAAiE,KAAjE;AACAM,EAAAA,MAAM,CAACK,gBAAP,CAAwB,sBAAxB,EAAgDJ,KAAK,CAACJ,iBAAtD,EAAyE,KAAzE;AAEA,SAAOS,EAAP;AACD","sourcesContent":["// luma.gl, MIT license\n\n/**\n * ContextProps\n* @param webgl2 Set to false to not create a WebGL2 context (force webgl1)\n* @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)\n* @param onContextLost\n* @param onContextRestored\n*\n* BROWSER CONTEXT PARAMETERS\n* @param debug Instrument context (at the expense of performance).\n* @param alpha Default render target has an alpha buffer.\n* @param depth Default render target has a depth buffer of at least 16 bits.\n* @param stencil Default render target has a stencil buffer of at least 8 bits.\n* @param antialias Boolean that indicates whether or not to perform anti-aliasing.\n* @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n* @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten\n* @param failIfMajorPerformanceCaveat Do not create if the system performance is low.\n*/\ntype ContextProps = {\n  type?: 'webgl' | 'webgl1' | 'webgl2' | string;\n  webgl1?: boolean;\n  webgl2?: boolean;\n  onContextLost?: (event: Event) => void;\n  onContextRestored?: (event: Event) => void;\n  alpha?: boolean; // indicates if the canvas contains an alpha buffer.\n  desynchronized?: boolean; // hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop\n  antialias?: boolean; // indicates whether or not to perform anti-aliasing.\n  depth?: boolean; // indicates that the drawing buffer has a depth buffer of at least 16 bits.\n  failIfMajorPerformanceCaveat?: boolean, // indicates if a context will be created if the system performance is low or if no hardware GPU is available.\n  powerPreference?: 'default' |  'high-performance' | 'low-power',\n  premultipliedAlpha?: boolean, // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n  preserveDrawingBuffer?: boolean // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.\n};\n\nconst DEFAULT_CONTEXT_PROPS: ContextProps = {\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  powerPreference: 'high-performance', // After all, most apps are using WebGL for performance reasons\n  onContextLost: () => console.error('WebGL context lost'),\n  onContextRestored: () => console.info('WebGL context restored'),\n};\n\n/**\n * Create a WebGL context for a canvas\n * Note calling this multiple time on the same canvas does return the same context\n* @param canvas A canvas element or offscreen canvas\n */\n export function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGLRenderingContext {\n   props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n  // Try to extract any extra information about why context creation failed\n  let errorMessage = null;\n  const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n  canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n  // Create the desired context\n  let gl = null;\n\n  if (props.type === 'webgl2') {\n    props = {...props, webgl1: false};\n  }\n  if (props.type === 'webgl1') {\n    props = {...props, webgl2: false};\n  }\n\n  // Prefer webgl2 over webgl1 if both are acceptable\n  if (props.webgl2) {\n    gl = gl || canvas.getContext('webgl2', props);\n  }\n  if (props.webgl1) {\n    gl = gl || canvas.getContext('webgl', props);\n  }\n\n  // TODO are we removing this listener before giving it a chance to fire?\n  canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n  if (!gl) {\n    throw new Error(\n      `Failed to create ${props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL'} context: ${\n        errorMessage || 'Unknown error'\n      }`\n    );\n  }\n\n  canvas.addEventListener('webglcontextlost', props.onContextLost, false);\n  canvas.addEventListener('webglcontextrestored', props.onContextRestored, false);\n\n  return gl;\n}\n\n/* TODO - can we call this asynchronously to catch the error events?\nexport async function createBrowserContextAsync(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): Promise<WebGLRenderingContext> {\n  props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n // Try to extract any extra information about why context creation failed\n let errorMessage = null;\n const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n const gl = createBrowserContext(canvas, props);\n\n // Give the listener a chance to fire\n await new Promise(resolve => setTimeout(resolve, 0));\n\n canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n return gl;\n}\n*/\n"],"file":"create-context.js"}

package/dist/es5/context/context/create-context.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/context/context/create-context.ts"],"names":["DEFAULT_CONTEXT_PROPS","webgl2","webgl1","powerPreference","onContextLost","console","error","onContextRestored","info","createBrowserContext","canvas","props","errorMessage","onCreateError","statusMessage","addEventListener","gl","type","getContext","removeEventListener","Error"],"mappings":";;;;;;;;;;;;;;;AAmCA,IAAMA,qBAAmC,GAAG;AAC1CC,EAAAA,MAAM,EAAE,IADkC;AAE1CC,EAAAA,MAAM,EAAE,IAFkC;AAG1CC,EAAAA,eAAe,EAAE,kBAHyB;AAI1CC,EAAAA,aAAa,EAAE;AAAA,WAAMC,OAAO,CAACC,KAAR,CAAc,oBAAd,CAAN;AAAA,GAJ2B;AAK1CC,EAAAA,iBAAiB,EAAE;AAAA,WAAMF,OAAO,CAACG,IAAR,CAAa,wBAAb,CAAN;AAAA;AALuB,CAA5C;;AAaQ,SAASC,oBAAT,CAA8BC,MAA9B,EAA2EC,KAA3E,EAAuH;AAC5HA,EAAAA,KAAK,mCAAOX,qBAAP,GAAiCW,KAAjC,CAAL;AAGD,MAAIC,YAAY,GAAG,IAAnB;;AACA,MAAMC,aAAa,GAAG,SAAhBA,aAAgB,CAACP,KAAD;AAAA,WAAYM,YAAY,GAAGN,KAAK,CAACQ,aAAN,IAAuBF,YAAlD;AAAA,GAAtB;;AACAF,EAAAA,MAAM,CAACK,gBAAP,CAAwB,2BAAxB,EAAqDF,aAArD,EAAoE,KAApE;AAGA,MAAIG,EAAE,GAAG,IAAT;;AAEA,MAAIL,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,mCAAOA,KAAP;AAAcT,MAAAA,MAAM,EAAE;AAAtB,MAAL;AACD;;AACD,MAAIS,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,mCAAOA,KAAP;AAAcV,MAAAA,MAAM,EAAE;AAAtB,MAAL;AACD;;AAGD,MAAIU,KAAK,CAACV,MAAV,EAAkB;AAChBe,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,QAAlB,EAA4BP,KAA5B,CAAX;AACD;;AACD,MAAIA,KAAK,CAACT,MAAV,EAAkB;AAChBc,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,OAAlB,EAA2BP,KAA3B,CAAX;AACD;;AAGDD,EAAAA,MAAM,CAACS,mBAAP,CAA2B,2BAA3B,EAAwDN,aAAxD,EAAuE,KAAvE;;AAEA,MAAI,CAACG,EAAL,EAAS;AACP,UAAM,IAAII,KAAJ,4BACgBT,KAAK,CAACV,MAAN,IAAgB,CAACU,KAAK,CAACT,MAAvB,GAAgC,QAAhC,GAA2C,OAD3D,uBAEFU,YAAY,IAAI,eAFd,EAAN;AAKD;;AAEDF,EAAAA,MAAM,CAACK,gBAAP,CAAwB,kBAAxB,EAA4CJ,KAAK,CAACP,aAAlD,EAAiE,KAAjE;AACAM,EAAAA,MAAM,CAACK,gBAAP,CAAwB,sBAAxB,EAAgDJ,KAAK,CAACJ,iBAAtD,EAAyE,KAAzE;AAEA,SAAOS,EAAP;AACD","sourcesContent":["// luma.gl, MIT license\n\n/**\n * ContextProps\n* @param webgl2 Set to false to not create a WebGL2 context (force webgl1)\n* @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)\n* @param onContextLost\n* @param onContextRestored\n*\n* BROWSER CONTEXT PARAMETERS\n* @param debug Instrument context (at the expense of performance).\n* @param alpha Default render target has an alpha buffer.\n* @param depth Default render target has a depth buffer of at least 16 bits.\n* @param stencil Default render target has a stencil buffer of at least 8 bits.\n* @param antialias Boolean that indicates whether or not to perform anti-aliasing.\n* @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n* @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten\n* @param failIfMajorPerformanceCaveat Do not create if the system performance is low.\n*/\ntype ContextProps = {\n  type?: 'webgl' | 'webgl1' | 'webgl2' | string;\n  webgl1?: boolean;\n  webgl2?: boolean;\n  onContextLost?: (event: Event) => void;\n  onContextRestored?: (event: Event) => void;\n  alpha?: boolean; // indicates if the canvas contains an alpha buffer.\n  desynchronized?: boolean; // hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop\n  antialias?: boolean; // indicates whether or not to perform anti-aliasing.\n  depth?: boolean; // indicates that the drawing buffer has a depth buffer of at least 16 bits.\n  failIfMajorPerformanceCaveat?: boolean, // indicates if a context will be created if the system performance is low or if no hardware GPU is available.\n  powerPreference?: 'default' |  'high-performance' | 'low-power',\n  premultipliedAlpha?: boolean, // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n  preserveDrawingBuffer?: boolean // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.\n};\n\nconst DEFAULT_CONTEXT_PROPS: ContextProps = {\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  powerPreference: 'high-performance', // After all, most apps are using WebGL for performance reasons\n  onContextLost: () => console.error('WebGL context lost'),\n  onContextRestored: () => console.info('WebGL context restored'),\n};\n\n/**\n * Create a WebGL context for a canvas\n * Note calling this multiple time on the same canvas does return the same context\n* @param canvas A canvas element or offscreen canvas\n */\n export function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGLRenderingContext {\n   props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n  // Try to extract any extra information about why context creation failed\n  let errorMessage = null;\n  const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n  canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n  // Create the desired context\n  let gl = null;\n\n  if (props.type === 'webgl2') {\n    props = {...props, webgl1: false};\n  }\n  if (props.type === 'webgl1') {\n    props = {...props, webgl2: false};\n  }\n\n  // Prefer webgl2 over webgl1 if both are acceptable\n  if (props.webgl2) {\n    gl = gl || canvas.getContext('webgl2', props);\n  }\n  if (props.webgl1) {\n    gl = gl || canvas.getContext('webgl', props);\n  }\n\n  // TODO are we removing this listener before giving it a chance to fire?\n  canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n  if (!gl) {\n    throw new Error(\n      `Failed to create ${props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL'} context: ${\n        errorMessage || 'Unknown error'\n      }`\n    );\n  }\n\n  canvas.addEventListener('webglcontextlost', props.onContextLost, false);\n  canvas.addEventListener('webglcontextrestored', props.onContextRestored, false);\n\n  return gl;\n}\n\n/* TODO - can we call this asynchronously to catch the error events?\nexport async function createBrowserContextAsync(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): Promise<WebGLRenderingContext> {\n  props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n // Try to extract any extra information about why context creation failed\n let errorMessage = null;\n const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n const gl = createBrowserContext(canvas, props);\n\n // Give the listener a chance to fire\n await new Promise(resolve => setTimeout(resolve, 0));\n\n canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n return gl;\n}\n*/\n"],"file":"create-context.js"}

package/dist/esm/context/context/create-context.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/context/context/create-context.ts"],"names":["DEFAULT_CONTEXT_PROPS","webgl2","webgl1","powerPreference","onContextLost","console","error","onContextRestored","info","createBrowserContext","canvas","props","errorMessage","onCreateError","statusMessage","addEventListener","gl","type","getContext","removeEventListener","Error"],"mappings":"AAmCA,MAAMA,qBAAmC,GAAG;AAC1CC,EAAAA,MAAM,EAAE,IADkC;AAE1CC,EAAAA,MAAM,EAAE,IAFkC;AAG1CC,EAAAA,eAAe,EAAE,kBAHyB;AAI1CC,EAAAA,aAAa,EAAE,MAAMC,OAAO,CAACC,KAAR,CAAc,oBAAd,CAJqB;AAK1CC,EAAAA,iBAAiB,EAAE,MAAMF,OAAO,CAACG,IAAR,CAAa,wBAAb;AALiB,CAA5C;AAaC,OAAO,SAASC,oBAAT,CAA8BC,MAA9B,EAA2EC,KAA3E,EAAuH;AAC5HA,EAAAA,KAAK,GAAG,EAAC,GAAGX,qBAAJ;AAA2B,OAAGW;AAA9B,GAAR;AAGD,MAAIC,YAAY,GAAG,IAAnB;;AACA,QAAMC,aAAa,GAAIP,KAAD,IAAYM,YAAY,GAAGN,KAAK,CAACQ,aAAN,IAAuBF,YAAxE;;AACAF,EAAAA,MAAM,CAACK,gBAAP,CAAwB,2BAAxB,EAAqDF,aAArD,EAAoE,KAApE;AAGA,MAAIG,EAAE,GAAG,IAAT;;AAEA,MAAIL,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,GAAG,EAAC,GAAGA,KAAJ;AAAWT,MAAAA,MAAM,EAAE;AAAnB,KAAR;AACD;;AACD,MAAIS,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,GAAG,EAAC,GAAGA,KAAJ;AAAWV,MAAAA,MAAM,EAAE;AAAnB,KAAR;AACD;;AAGD,MAAIU,KAAK,CAACV,MAAV,EAAkB;AAChBe,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,QAAlB,EAA4BP,KAA5B,CAAX;AACD;;AACD,MAAIA,KAAK,CAACT,MAAV,EAAkB;AAChBc,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,OAAlB,EAA2BP,KAA3B,CAAX;AACD;;AAGDD,EAAAA,MAAM,CAACS,mBAAP,CAA2B,2BAA3B,EAAwDN,aAAxD,EAAuE,KAAvE;;AAEA,MAAI,CAACG,EAAL,EAAS;AACP,UAAM,IAAII,KAAJ,4BACgBT,KAAK,CAACV,MAAN,IAAgB,CAACU,KAAK,CAACT,MAAvB,GAAgC,QAAhC,GAA2C,OAD3D,uBAEFU,YAAY,IAAI,eAFd,EAAN;AAKD;;AAEDF,EAAAA,MAAM,CAACK,gBAAP,CAAwB,kBAAxB,EAA4CJ,KAAK,CAACP,aAAlD,EAAiE,KAAjE;AACAM,EAAAA,MAAM,CAACK,gBAAP,CAAwB,sBAAxB,EAAgDJ,KAAK,CAACJ,iBAAtD,EAAyE,KAAzE;AAEA,SAAOS,EAAP;AACD","sourcesContent":["// luma.gl, MIT license\n\n/**\n * ContextProps\n* @param webgl2 Set to false to not create a WebGL2 context (force webgl1)\n* @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)\n* @param onContextLost\n* @param onContextRestored\n*\n* BROWSER CONTEXT PARAMETERS\n* @param debug Instrument context (at the expense of performance).\n* @param alpha Default render target has an alpha buffer.\n* @param depth Default render target has a depth buffer of at least 16 bits.\n* @param stencil Default render target has a stencil buffer of at least 8 bits.\n* @param antialias Boolean that indicates whether or not to perform anti-aliasing.\n* @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n* @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten\n* @param failIfMajorPerformanceCaveat Do not create if the system performance is low.\n*/\ntype ContextProps = {\n  type?: 'webgl' | 'webgl1' | 'webgl2' | string;\n  webgl1?: boolean;\n  webgl2?: boolean;\n  onContextLost?: (event: Event) => void;\n  onContextRestored?: (event: Event) => void;\n  alpha?: boolean; // indicates if the canvas contains an alpha buffer.\n  desynchronized?: boolean; // hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop\n  antialias?: boolean; // indicates whether or not to perform anti-aliasing.\n  depth?: boolean; // indicates that the drawing buffer has a depth buffer of at least 16 bits.\n  failIfMajorPerformanceCaveat?: boolean, // indicates if a context will be created if the system performance is low or if no hardware GPU is available.\n  powerPreference?: 'default' |  'high-performance' | 'low-power',\n  premultipliedAlpha?: boolean, // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n  preserveDrawingBuffer?: boolean // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.\n};\n\nconst DEFAULT_CONTEXT_PROPS: ContextProps = {\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  powerPreference: 'high-performance', // After all, most apps are using WebGL for performance reasons\n  onContextLost: () => console.error('WebGL context lost'),\n  onContextRestored: () => console.info('WebGL context restored'),\n};\n\n/**\n * Create a WebGL context for a canvas\n * Note calling this multiple time on the same canvas does return the same context\n* @param canvas A canvas element or offscreen canvas\n */\n export function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGLRenderingContext {\n   props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n  // Try to extract any extra information about why context creation failed\n  let errorMessage = null;\n  const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n  canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n  // Create the desired context\n  let gl = null;\n\n  if (props.type === 'webgl2') {\n    props = {...props, webgl1: false};\n  }\n  if (props.type === 'webgl1') {\n    props = {...props, webgl2: false};\n  }\n\n  // Prefer webgl2 over webgl1 if both are acceptable\n  if (props.webgl2) {\n    gl = gl || canvas.getContext('webgl2', props);\n  }\n  if (props.webgl1) {\n    gl = gl || canvas.getContext('webgl', props);\n  }\n\n  // TODO are we removing this listener before giving it a chance to fire?\n  canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n  if (!gl) {\n    throw new Error(\n      `Failed to create ${props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL'} context: ${\n        errorMessage || 'Unknown error'\n      }`\n    );\n  }\n\n  canvas.addEventListener('webglcontextlost', props.onContextLost, false);\n  canvas.addEventListener('webglcontextrestored', props.onContextRestored, false);\n\n  return gl;\n}\n\n/* TODO - can we call this asynchronously to catch the error events?\nexport async function createBrowserContextAsync(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): Promise<WebGLRenderingContext> {\n  props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n // Try to extract any extra information about why context creation failed\n let errorMessage = null;\n const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n const gl = createBrowserContext(canvas, props);\n\n // Give the listener a chance to fire\n await new Promise(resolve => setTimeout(resolve, 0));\n\n canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n return gl;\n}\n*/\n"],"file":"create-context.js"}