@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.1

package/dist/classic/copy-and-blit.js

@@ -0,0 +1,192 @@
+import { assert, Texture, Framebuffer } from '@luma.gl/core';
+import { getGLTypeFromTypedArray, getTypedArrayFromGLType } from "./typed-array-utils.js";
+import { glFormatToComponents, glTypeToBytes } from "./format-utils.js";
+export function readPixelsToArray(source, options) {
+  var _framebuffer$colorAtt;
+  const {
+    sourceX = 0,
+    sourceY = 0,
+    sourceFormat = 6408,
+    sourceAttachment = 36064
+  } = options || {};
+  let {
+    target = null,
+    sourceWidth,
+    sourceHeight,
+    sourceType
+  } = options || {};
+  const {
+    framebuffer,
+    deleteFramebuffer
+  } = getFramebuffer(source);
+  assert(framebuffer);
+  const {
+    gl,
+    handle
+  } = framebuffer;
+  sourceWidth = sourceWidth || framebuffer.width;
+  sourceHeight = sourceHeight || framebuffer.height;
+  const attachment = sourceAttachment - 36064;
+  sourceType = sourceType || ((_framebuffer$colorAtt = framebuffer.colorAttachments[attachment]) === null || _framebuffer$colorAtt === void 0 ? void 0 : _framebuffer$colorAtt.type) || 5121;
+  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
+  sourceType = sourceType || getGLTypeFromTypedArray(target);
+  const prevHandle = gl.bindFramebuffer(36160, handle);
+  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+  gl.bindFramebuffer(36160, prevHandle || null);
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return target;
+}
+export function readPixelsToBuffer(source, options) {
+  const {
+    target,
+    sourceX = 0,
+    sourceY = 0,
+    sourceFormat = 6408,
+    targetByteOffset = 0
+  } = options || {};
+  let {
+    sourceWidth,
+    sourceHeight,
+    sourceType
+  } = options || {};
+  const {
+    framebuffer,
+    deleteFramebuffer
+  } = getFramebuffer(source);
+  assert(framebuffer);
+  sourceWidth = sourceWidth || framebuffer.width;
+  sourceHeight = sourceHeight || framebuffer.height;
+  const webglFramebuffer = framebuffer;
+  sourceType = sourceType || 5121;
+  let webglBufferTarget = target;
+  if (!webglBufferTarget) {
+    const components = glFormatToComponents(sourceFormat);
+    const byteCount = glTypeToBytes(sourceType);
+    const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
+    webglBufferTarget = webglFramebuffer.device.createBuffer({
+      byteLength
+    });
+  }
+  const commandEncoder = source.device.createCommandEncoder();
+  commandEncoder.copyTextureToBuffer({
+    source: source,
+    width: sourceWidth,
+    height: sourceHeight,
+    origin: [sourceX, sourceY],
+    destination: webglBufferTarget,
+    byteOffset: targetByteOffset
+  });
+  commandEncoder.destroy();
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return webglBufferTarget;
+}
+export function copyToTexture(source, target, options) {
+  const {
+    sourceX = 0,
+    sourceY = 0,
+    targetMipmaplevel = 0,
+    targetInternalFormat = 6408
+  } = options || {};
+  let {
+    targetX,
+    targetY,
+    targetZ,
+    width,
+    height
+  } = options || {};
+  const {
+    framebuffer,
+    deleteFramebuffer
+  } = getFramebuffer(source);
+  assert(framebuffer);
+  const webglFramebuffer = framebuffer;
+  const {
+    device,
+    handle
+  } = webglFramebuffer;
+  const isSubCopy = typeof targetX !== 'undefined' || typeof targetY !== 'undefined' || typeof targetZ !== 'undefined';
+  targetX = targetX || 0;
+  targetY = targetY || 0;
+  targetZ = targetZ || 0;
+  const prevHandle = device.gl.bindFramebuffer(36160, handle);
+  assert(target);
+  let texture = null;
+  let textureTarget;
+  if (target instanceof Texture) {
+    texture = target;
+    width = Number.isFinite(width) ? width : texture.width;
+    height = Number.isFinite(height) ? height : texture.height;
+    texture.bind(0);
+    textureTarget = texture.target;
+  } else {
+    textureTarget = target;
+  }
+  if (!isSubCopy) {
+    device.gl.copyTexImage2D(textureTarget, targetMipmaplevel, targetInternalFormat, sourceX, sourceY, width, height, 0);
+  } else {
+    switch (textureTarget) {
+      case 3553:
+      case 34067:
+        device.gl.copyTexSubImage2D(textureTarget, targetMipmaplevel, targetX, targetY, sourceX, sourceY, width, height);
+        break;
+      case 35866:
+      case 32879:
+        device.assertWebGL2();
+        device.gl2.copyTexSubImage3D(textureTarget, targetMipmaplevel, targetX, targetY, targetZ, sourceX, sourceY, width, height);
+        break;
+      default:
+    }
+  }
+  if (texture) {
+    texture.unbind();
+  }
+  device.gl.bindFramebuffer(36160, prevHandle || null);
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return texture;
+}
+function getFramebuffer(source) {
+  if (!(source instanceof Framebuffer)) {
+    return {
+      framebuffer: toFramebuffer(source),
+      deleteFramebuffer: true
+    };
+  }
+  return {
+    framebuffer: source,
+    deleteFramebuffer: false
+  };
+}
+export function toFramebuffer(texture, props) {
+  const {
+    device,
+    width,
+    height,
+    id
+  } = texture;
+  const framebuffer = device.createFramebuffer({
+    ...props,
+    id: `framebuffer-for-${id}`,
+    width,
+    height,
+    colorAttachments: [texture]
+  });
+  return framebuffer;
+}
+function getPixelArray(pixelArray, type, format, width, height) {
+  if (pixelArray) {
+    return pixelArray;
+  }
+  type = type || 5121;
+  const ArrayType = getTypedArrayFromGLType(type, {
+    clamped: false
+  });
+  const components = glFormatToComponents(format);
+  return new ArrayType(width * height * components);
+}
+//# sourceMappingURL=copy-and-blit.js.map

package/dist/classic/copy-and-blit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-and-blit.js","names":["assert","Texture","Framebuffer","getGLTypeFromTypedArray","getTypedArrayFromGLType","glFormatToComponents","glTypeToBytes","readPixelsToArray","source","options","_framebuffer$colorAtt","sourceX","sourceY","sourceFormat","sourceAttachment","target","sourceWidth","sourceHeight","sourceType","framebuffer","deleteFramebuffer","getFramebuffer","gl","handle","width","height","attachment","colorAttachments","type","getPixelArray","prevHandle","bindFramebuffer","readPixels","destroy","readPixelsToBuffer","targetByteOffset","webglFramebuffer","webglBufferTarget","components","byteCount","byteLength","device","createBuffer","commandEncoder","createCommandEncoder","copyTextureToBuffer","origin","destination","byteOffset","copyToTexture","targetMipmaplevel","targetInternalFormat","targetX","targetY","targetZ","isSubCopy","texture","textureTarget","Number","isFinite","bind","copyTexImage2D","copyTexSubImage2D","assertWebGL2","gl2","copyTexSubImage3D","unbind","toFramebuffer","props","id","createFramebuffer","pixelArray","format","ArrayType","clamped"],"sources":["../../src/classic/copy-and-blit.ts"],"sourcesContent":["// luma.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {assert, Buffer, Texture, Framebuffer, FramebufferProps} from '@luma.gl/core';\nimport {GL} from '@luma.gl/constants';\n\nimport {WEBGLTexture} from '../adapter/resources/webgl-texture';\nimport {WEBGLFramebuffer} from '../adapter/resources/webgl-framebuffer';\nimport {getGLTypeFromTypedArray, getTypedArrayFromGLType} from './typed-array-utils';\nimport {glFormatToComponents, glTypeToBytes} from './format-utils';\nimport {WEBGLBuffer} from '../adapter/resources/webgl-buffer';\n\n/**\n * Copies data from a type  or a Texture object into ArrayBuffer object.\n * App can provide targetPixelArray or have it auto allocated by this method\n *  newly allocated by this method unless provided by app.\n * @deprecated Use CommandEncoder.copyTextureToBuffer and Buffer.read\n * @note Slow requires roundtrip to GPU\n *\n * @param source\n * @param options\n * @returns pixel array,\n */\nexport function readPixelsToArray(\n  source: Framebuffer | Texture,\n  options?: {\n    sourceX?: number;\n    sourceY?: number;\n    sourceFormat?: number;\n    sourceAttachment?: number;\n    target?: Uint8Array | Uint16Array | Float32Array;\n    // following parameters are auto deduced if not provided\n    sourceWidth?: number;\n    sourceHeight?: number;\n    sourceType?: number;\n  }\n): Uint8Array | Uint16Array | Float32Array {\n  const {\n    sourceX = 0,\n    sourceY = 0,\n    sourceFormat = GL.RGBA,\n    sourceAttachment = GL.COLOR_ATTACHMENT0 // TODO - support gl.readBuffer\n  } = options || {};\n  let {\n    target = null,\n    // following parameters are auto deduced if not provided\n    sourceWidth,\n    sourceHeight,\n    sourceType\n  } = options || {};\n\n  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);\n  assert(framebuffer);\n  const {gl, handle} = framebuffer as WEBGLFramebuffer;\n  sourceWidth = sourceWidth || framebuffer.width;\n  sourceHeight = sourceHeight || framebuffer.height;\n\n  // TODO - Set and unset gl.readBuffer\n  // if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {\n  //   sourceAttachment = GL.FRONT;\n  // }\n\n  const attachment = sourceAttachment - GL.COLOR_ATTACHMENT0;\n  // assert(attachments[sourceAttachment]);\n\n  // Deduce the type from color attachment if not provided.\n  sourceType =\n    sourceType ||\n    (framebuffer.colorAttachments[attachment] as WEBGLTexture)?.type ||\n    GL.UNSIGNED_BYTE;\n\n  // Deduce type and allocated pixelArray if needed\n  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);\n\n  // Pixel array available, if necessary, deduce type from it.\n  sourceType = sourceType || getGLTypeFromTypedArray(target);\n\n  const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);\n  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);\n  // @ts-expect-error\n  gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n  if (deleteFramebuffer) {\n    framebuffer.destroy();\n  }\n  return target;\n}\n\n/**\n * Copies data from a Framebuffer or a Texture object into a Buffer object.\n * NOTE: doesn't wait for copy to be complete, it programs GPU to perform a DMA transffer.\n * @deprecated Use CommandEncoder\n * @param source\n * @param options\n */\nexport function readPixelsToBuffer(\n  source: Framebuffer | Texture,\n  options?: {\n    sourceX?: number;\n    sourceY?: number;\n    sourceFormat?: number;\n    target?: Buffer; // A new Buffer object is created when not provided.\n    targetByteOffset?: number; // byte offset in buffer object\n    // following parameters are auto deduced if not provided\n    sourceWidth?: number;\n    sourceHeight?: number;\n    sourceType?: number;\n  }\n): WEBGLBuffer {\n  const {target, sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA, targetByteOffset = 0} = options || {};\n  // following parameters are auto deduced if not provided\n  let {sourceWidth, sourceHeight, sourceType} = options || {};\n  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);\n  assert(framebuffer);\n  sourceWidth = sourceWidth || framebuffer.width;\n  sourceHeight = sourceHeight || framebuffer.height;\n\n  // Asynchronous read (PIXEL_PACK_BUFFER) is WebGL2 only feature\n  const webglFramebuffer = framebuffer as WEBGLFramebuffer;\n\n  // deduce type if not available.\n  sourceType = sourceType || GL.UNSIGNED_BYTE;\n\n  let webglBufferTarget = target as unknown as WEBGLBuffer | undefined;\n  if (!webglBufferTarget) {\n    // Create new buffer with enough size\n    const components = glFormatToComponents(sourceFormat);\n    const byteCount = glTypeToBytes(sourceType);\n    const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;\n    webglBufferTarget = webglFramebuffer.device.createBuffer({byteLength});\n  }\n\n  // TODO(donmccurdy): Do we have tests to confirm this is working?\n  const commandEncoder = source.device.createCommandEncoder();\n  commandEncoder.copyTextureToBuffer({\n    source: source as Texture,\n    width: sourceWidth,\n    height: sourceHeight,\n    origin: [sourceX, sourceY],\n    destination: webglBufferTarget,\n    byteOffset: targetByteOffset\n  });\n  commandEncoder.destroy();\n\n  if (deleteFramebuffer) {\n    framebuffer.destroy();\n  }\n\n  return webglBufferTarget;\n}\n\n/**\n * Copy a rectangle from a Framebuffer or Texture object into a texture (at an offset)\n * @deprecated Use CommandEncoder\n */\n// eslint-disable-next-line complexity, max-statements\nexport function copyToTexture(\n  source: Framebuffer | Texture,\n  target: Texture | GL,\n  options?: {\n    sourceX?: number;\n    sourceY?: number;\n\n    targetX?: number;\n    targetY?: number;\n    targetZ?: number;\n    targetMipmaplevel?: number;\n    targetInternalFormat?: number;\n\n    width?: number; // defaults to target width\n    height?: number; // defaults to target height\n  }\n): Texture {\n  const {\n    sourceX = 0,\n    sourceY = 0,\n    // attachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer\n    targetMipmaplevel = 0,\n    targetInternalFormat = GL.RGBA\n  } = options || {};\n  let {\n    targetX,\n    targetY,\n    targetZ,\n    width, // defaults to target width\n    height // defaults to target height\n  } = options || {};\n\n  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);\n  assert(framebuffer);\n  const webglFramebuffer = framebuffer as WEBGLFramebuffer;\n  const {device, handle} = webglFramebuffer;\n  const isSubCopy =\n    typeof targetX !== 'undefined' ||\n    typeof targetY !== 'undefined' ||\n    typeof targetZ !== 'undefined';\n  targetX = targetX || 0;\n  targetY = targetY || 0;\n  targetZ = targetZ || 0;\n  const prevHandle = device.gl.bindFramebuffer(GL.FRAMEBUFFER, handle);\n  // TODO - support gl.readBuffer (WebGL2 only)\n  // const prevBuffer = gl.readBuffer(attachment);\n  assert(target);\n  let texture = null;\n  let textureTarget: GL;\n  if (target instanceof Texture) {\n    texture = target;\n    width = Number.isFinite(width) ? width : texture.width;\n    height = Number.isFinite(height) ? height : texture.height;\n    texture.bind(0);\n    textureTarget = texture.target;\n  } else {\n    textureTarget = target;\n  }\n\n  if (!isSubCopy) {\n    device.gl.copyTexImage2D(\n      textureTarget,\n      targetMipmaplevel,\n      targetInternalFormat,\n      sourceX,\n      sourceY,\n      width,\n      height,\n      0 /* border must be 0 */\n    );\n  } else {\n    switch (textureTarget) {\n      case GL.TEXTURE_2D:\n      case GL.TEXTURE_CUBE_MAP:\n        device.gl.copyTexSubImage2D(\n          textureTarget,\n          targetMipmaplevel,\n          targetX,\n          targetY,\n          sourceX,\n          sourceY,\n          width,\n          height\n        );\n        break;\n      case GL.TEXTURE_2D_ARRAY:\n      case GL.TEXTURE_3D:\n        device.assertWebGL2();\n        device.gl2.copyTexSubImage3D(\n          textureTarget,\n          targetMipmaplevel,\n          targetX,\n          targetY,\n          targetZ,\n          sourceX,\n          sourceY,\n          width,\n          height\n        );\n        break;\n      default:\n    }\n  }\n  if (texture) {\n    texture.unbind();\n  }\n  // @ts-expect-error\n  device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n  if (deleteFramebuffer) {\n    framebuffer.destroy();\n  }\n  return texture;\n}\n\nfunction getFramebuffer(source: Texture | Framebuffer): {\n  framebuffer: Framebuffer;\n  deleteFramebuffer: boolean;\n} {\n  if (!(source instanceof Framebuffer)) {\n    return {framebuffer: toFramebuffer(source), deleteFramebuffer: true};\n  }\n  return {framebuffer: source, deleteFramebuffer: false};\n}\n\n/**\n * Wraps a given texture into a framebuffer object, that can be further used\n * to read data from the texture object.\n */\nexport function toFramebuffer(texture: Texture, props?: FramebufferProps): Framebuffer {\n  const {device, width, height, id} = texture;\n  const framebuffer = device.createFramebuffer({\n    ...props,\n    id: `framebuffer-for-${id}`,\n    width,\n    height,\n    colorAttachments: [texture]\n  });\n  return framebuffer;\n}\n\nfunction getPixelArray(\n  pixelArray,\n  type,\n  format,\n  width: number,\n  height: number\n): Uint8Array | Uint16Array | Float32Array {\n  if (pixelArray) {\n    return pixelArray;\n  }\n  // Allocate pixel array if not already available, using supplied type\n  type = type || GL.UNSIGNED_BYTE;\n  const ArrayType = getTypedArrayFromGLType(type, {clamped: false});\n  const components = glFormatToComponents(format);\n  // TODO - check for composite type (components = 1).\n  return new ArrayType(width * height * components) as Uint8Array | Uint16Array | Float32Array;\n}\n"],"mappings":"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"}

package/dist/classic/format-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function glFormatToComponents(format: any): 2 | 0 | 1 | 4 | 3;
+export declare function glTypeToBytes(type: any): 2 | 0 | 1 | 4;
+//# sourceMappingURL=format-utils.d.ts.map

package/dist/classic/format-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-utils.d.ts","sourceRoot":"","sources":["../../src/classic/format-utils.ts"],"names":[],"mappings":"AAOA,wBAAgB,oBAAoB,CAAC,MAAM,KAAA,qBAoB1C;AAGD,wBAAgB,aAAa,CAAC,IAAI,KAAA,iBAejC"}

package/dist/classic/format-utils.js

@@ -0,0 +1,37 @@
+import { assert } from '@luma.gl/core';
+export function glFormatToComponents(format) {
+  switch (format) {
+    case 6406:
+    case 33326:
+    case 6403:
+      return 1;
+    case 33328:
+    case 33319:
+      return 2;
+    case 6407:
+    case 34837:
+      return 3;
+    case 6408:
+    case 34836:
+      return 4;
+    default:
+      assert(false);
+      return 0;
+  }
+}
+export function glTypeToBytes(type) {
+  switch (type) {
+    case 5121:
+      return 1;
+    case 33635:
+    case 32819:
+    case 32820:
+      return 2;
+    case 5126:
+      return 4;
+    default:
+      assert(false);
+      return 0;
+  }
+}
+//# sourceMappingURL=format-utils.js.map

package/dist/classic/format-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-utils.js","names":["assert","glFormatToComponents","format","glTypeToBytes","type"],"sources":["../../src/classic/format-utils.ts"],"sourcesContent":["// luma.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {assert} from '@luma.gl/core';\nimport {GL} from '@luma.gl/constants';\n\n// Returns number of components in a specific readPixels WebGL format\nexport function glFormatToComponents(format) {\n  switch (format) {\n    case GL.ALPHA:\n    case GL.R32F:\n    case GL.RED:\n      return 1;\n    case GL.RG32F:\n    case GL.RG:\n      return 2;\n    case GL.RGB:\n    case GL.RGB32F:\n      return 3;\n    case GL.RGBA:\n    case GL.RGBA32F:\n      return 4;\n    // TODO: Add support for additional WebGL2 formats\n    default:\n      assert(false);\n      return 0;\n  }\n}\n\n// Return byte count for given readPixels WebGL type\nexport function glTypeToBytes(type) {\n  switch (type) {\n    case GL.UNSIGNED_BYTE:\n      return 1;\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return 2;\n    case GL.FLOAT:\n      return 4;\n    // TODO: Add support for additional WebGL2 types\n    default:\n      assert(false);\n      return 0;\n  }\n}\n"],"mappings":"AAGA,SAAQA,MAAM,QAAO,eAAe;AAIpC,OAAO,SAASC,oBAAoBA,CAACC,MAAM,EAAE;EAC3C,QAAQA,MAAM;IACZ;IACA;IACA;MACE,OAAO,CAAC;IACV;IACA;MACE,OAAO,CAAC;IACV;IACA;MACE,OAAO,CAAC;IACV;IACA;MACE,OAAO,CAAC;IAEV;MACEF,MAAM,CAAC,KAAK,CAAC;MACb,OAAO,CAAC;EACZ;AACF;AAGA,OAAO,SAASG,aAAaA,CAACC,IAAI,EAAE;EAClC,QAAQA,IAAI;IACV;MACE,OAAO,CAAC;IACV;IACA;IACA;MACE,OAAO,CAAC;IACV;MACE,OAAO,CAAC;IAEV;MACEJ,MAAM,CAAC,KAAK,CAAC;MACb,OAAO,CAAC;EACZ;AACF"}

package/dist/classic/typed-array-utils.d.ts

@@ -1,44 +1,44 @@
-import { TypedArray } from '@luma.gl/api';
-import { GLType } from '../types/webgl';
-declare type TypedArrayConstructor = Float32ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor;
+import { TypedArray, TypedArrayConstructor } from '@luma.gl/core';
+import { GLDataType, GLPixelType } from '@luma.gl/constants';
 /**
  * Converts TYPED ARRAYS to corresponding GL constant
  * Used to auto deduce gl parameter types
- * @param {*} arrayOrType
+ * @deprecated Use getDataTypeFromTypedArray
+ * @param arrayOrType
  * @returns
  */
-export declare function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLType;
+export declare function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLDataType;
 /**
  * Converts GL constant to corresponding TYPED ARRAY
  * Used to auto deduce gl parameter types
- * @param {*} glType
- * @param {*} param1
+ * @deprecated Use getTypedArrayFromDataType
+ * @param glType
+ * @param param1
  * @returns
  */
-export declare function getTypedArrayFromGLType(glType: any, options?: {
+export declare function getTypedArrayFromGLType(glType: GLDataType | GLPixelType, options?: {
     clamped?: boolean;
 }): TypedArrayConstructor;
 /**
  * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)
  * https: *stackoverflow.com/questions/41969562/
  * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels
- * @param {*} param0
+ * @param param0
  */
 export declare function flipRows(options: {
-    data: any;
-    width: any;
-    height: any;
+    data: TypedArray;
+    width: number;
+    height: number;
     bytesPerPixel?: number;
-    temp?: any;
+    temp?: Uint8Array;
 }): void;
 export declare function scalePixels(options: {
-    data: any;
-    width: any;
-    height: any;
+    data: TypedArray;
+    width: number;
+    height: number;
 }): {
     data: Uint8Array;
     width: number;
     height: number;
 };
-export {};
 //# sourceMappingURL=typed-array-utils.d.ts.map

package/dist/classic/typed-array-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed-array-utils.d.ts","sourceRoot":"","sources":["../../src/classic/typed-array-utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC,OAAO,EAAC,MAAM,EAAC,MAAM,gBAAgB,CAAA;AAIrC,aAAK,qBAAqB,GACtB,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,4BAA4B,GAC5B,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,CAAC;AAE1B;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,UAAU,GAAG,MAAM,CAuBvE;AAED;;;;;;GAMG;AAEH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,GAAG,EACX,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACA,qBAAqB,CAwBvB;AAED;;;;;GAKG;AACF,wBAAgB,QAAQ,CAAC,OAAO,EAAE;IACjC,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,GAAG,CAAC;IACX,MAAM,EAAE,GAAG,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ,GAAG,IAAI,CAgBP;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE;IACnC,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,GAAG,CAAC;IACX,MAAM,EAAE,GAAG,CAAC;CACb,GAAG;IACF,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAaA"}
+{"version":3,"file":"typed-array-utils.d.ts","sourceRoot":"","sources":["../../src/classic/typed-array-utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,UAAU,EAAE,qBAAqB,EAAC,MAAM,eAAe,CAAC;AAChE,OAAO,EAAK,UAAU,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAI/D;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,CAuB3E;AAED;;;;;;;GAOG;AAEH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,GAAG,WAAW,EAChC,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACA,qBAAqB,CAwBvB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE;IAChC,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB,GAAG,IAAI,CAgBP;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE;IACnC,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG;IACF,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAaA"}

package/dist/classic/typed-array-utils.js

@@ -1,33 +1,23 @@
-import GL from '@luma.gl/constants';
 const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
 export function getGLTypeFromTypedArray(arrayOrType) {
   const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
-
   switch (type) {
     case Float32Array:
-      return GL.FLOAT;
-
+      return 5126;
     case Uint16Array:
-      return GL.UNSIGNED_SHORT;
-
+      return 5123;
     case Uint32Array:
-      return GL.UNSIGNED_INT;
-
+      return 5125;
     case Uint8Array:
-      return GL.UNSIGNED_BYTE;
-
+      return 5121;
     case Uint8ClampedArray:
-      return GL.UNSIGNED_BYTE;
-
+      return 5121;
     case Int8Array:
-      return GL.BYTE;
-
+      return 5120;
     case Int16Array:
-      return GL.SHORT;
-
+      return 5122;
     case Int32Array:
-      return GL.INT;
-
+      return 5124;
     default:
       throw new Error(ERR_TYPE_DEDUCTION);
   }
@@ -36,32 +26,24 @@ export function getTypedArrayFromGLType(glType, options) {
   const {
     clamped = true
   } = options || {};
-
   switch (glType) {
-    case GL.FLOAT:
+    case 5126:
       return Float32Array;
-
-    case GL.UNSIGNED_SHORT:
-    case GL.UNSIGNED_SHORT_5_6_5:
-    case GL.UNSIGNED_SHORT_4_4_4_4:
-    case GL.UNSIGNED_SHORT_5_5_5_1:
+    case 5123:
+    case 33635:
+    case 32819:
+    case 32820:
       return Uint16Array;
-
-    case GL.UNSIGNED_INT:
+    case 5125:
       return Uint32Array;
-
-    case GL.UNSIGNED_BYTE:
+    case 5121:
       return clamped ? Uint8ClampedArray : Uint8Array;
-
-    case GL.BYTE:
+    case 5120:
       return Int8Array;
-
-    case GL.SHORT:
+    case 5122:
       return Int16Array;
-
-    case GL.INT:
+    case 5124:
       return Int32Array;
-
     default:
       throw new Error('Failed to deduce typed array type from GL constant');
   }
@@ -76,7 +58,6 @@ export function flipRows(options) {
   } = options;
   const bytesPerRow = width * bytesPerPixel;
   const tempBuffer = temp || new Uint8Array(bytesPerRow);
-
   for (let y = 0; y < height / 2; ++y) {
     const topOffset = y * bytesPerRow;
     const bottomOffset = (height - y - 1) * bytesPerRow;
@@ -94,7 +75,6 @@ export function scalePixels(options) {
   const newWidth = Math.round(width / 2);
   const newHeight = Math.round(height / 2);
   const newData = new Uint8Array(newWidth * newHeight * 4);
-
   for (let y = 0; y < newHeight; y++) {
     for (let x = 0; x < newWidth; x++) {
       for (let c = 0; c < 4; c++) {
@@ -102,7 +82,6 @@ export function scalePixels(options) {
       }
     }
   }
-
   return {
     data: newData,
     width: newWidth,

package/dist/classic/typed-array-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/classic/typed-array-utils.ts"],"names":["GL","ERR_TYPE_DEDUCTION","getGLTypeFromTypedArray","arrayOrType","type","ArrayBuffer","isView","constructor","Float32Array","FLOAT","Uint16Array","UNSIGNED_SHORT","Uint32Array","UNSIGNED_INT","Uint8Array","UNSIGNED_BYTE","Uint8ClampedArray","Int8Array","BYTE","Int16Array","SHORT","Int32Array","INT","Error","getTypedArrayFromGLType","glType","options","clamped","UNSIGNED_SHORT_5_6_5","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","flipRows","data","width","height","bytesPerPixel","temp","bytesPerRow","tempBuffer","y","topOffset","bottomOffset","set","subarray","copyWithin","scalePixels","newWidth","Math","round","newHeight","newData","x","c"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\n\nimport {TypedArray} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {GLType} from '../types/webgl'\n\nconst ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';\n\ntype TypedArrayConstructor =\n  | Float32ArrayConstructor\n  | Uint16ArrayConstructor\n  | Uint32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Uint8ClampedArrayConstructor\n  | Int8ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor;\n\n/**\n * Converts TYPED ARRAYS to corresponding GL constant\n * Used to auto deduce gl parameter types\n * @param {*} arrayOrType\n * @returns\n */\nexport function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLType {\n  // If typed array, look up constructor\n  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n  switch (type) {\n    case Float32Array:\n      return GL.FLOAT;\n    case Uint16Array:\n      return GL.UNSIGNED_SHORT;\n    case Uint32Array:\n      return GL.UNSIGNED_INT;\n    case Uint8Array:\n      return GL.UNSIGNED_BYTE;\n    case Uint8ClampedArray:\n      return GL.UNSIGNED_BYTE;\n    case Int8Array:\n      return GL.BYTE;\n    case Int16Array:\n      return GL.SHORT;\n    case Int32Array:\n      return GL.INT;\n    default:\n      throw new Error(ERR_TYPE_DEDUCTION);\n  }\n}\n\n/**\n * Converts GL constant to corresponding TYPED ARRAY\n * Used to auto deduce gl parameter types\n * @param {*} glType\n * @param {*} param1\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function getTypedArrayFromGLType(\n  glType: any,\n  options?: {\n    clamped?: boolean;\n  }\n): TypedArrayConstructor {\n  const {clamped = true} = options || {};\n  // Sorted in some order of likelihood to reduce amount of comparisons\n  switch (glType) {\n    case GL.FLOAT:\n      return Float32Array;\n    case GL.UNSIGNED_SHORT:\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return Uint16Array;\n    case GL.UNSIGNED_INT:\n      return Uint32Array;\n    case GL.UNSIGNED_BYTE:\n      return clamped ? Uint8ClampedArray : Uint8Array;\n    case GL.BYTE:\n      return Int8Array;\n    case GL.SHORT:\n      return Int16Array;\n    case GL.INT:\n      return Int32Array;\n    default:\n      throw new Error('Failed to deduce typed array type from GL constant');\n  }\n}\n\n/**\n * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)\n * https: *stackoverflow.com/questions/41969562/\n * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels\n * @param {*} param0\n */\n export function flipRows(options: {\n  data: any;\n  width: any;\n  height: any;\n  bytesPerPixel?: number;\n  temp?: any;\n}): void {\n  const {data, width, height, bytesPerPixel = 4, temp} = options;\n  const bytesPerRow = width * bytesPerPixel;\n\n  // make a temp buffer to hold one row\n  const tempBuffer = temp || new Uint8Array(bytesPerRow);\n  for (let y = 0; y < height / 2; ++y) {\n    const topOffset = y * bytesPerRow;\n    const bottomOffset = (height - y - 1) * bytesPerRow;\n    // make copy of a row on the top half\n    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));\n    // copy a row from the bottom half to the top\n    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);\n    // copy the copy of the top half row to the bottom half\n    data.set(tempBuffer, bottomOffset);\n  }\n}\n\n\nexport function scalePixels(options: {\n  data: any;\n  width: any;\n  height: any;\n}): {\n  data: Uint8Array;\n  width: number;\n  height: number;\n} {\n  const {data, width, height} = options;\n  const newWidth = Math.round(width / 2);\n  const newHeight = Math.round(height / 2);\n  const newData = new Uint8Array(newWidth * newHeight * 4);\n  for (let y = 0; y < newHeight; y++) {\n    for (let x = 0; x < newWidth; x++) {\n      for (let c = 0; c < 4; c++) {\n        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];\n      }\n    }\n  }\n  return {data: newData, width: newWidth, height: newHeight};\n}\n"],"file":"typed-array-utils.js"}
+{"version":3,"file":"typed-array-utils.js","names":["ERR_TYPE_DEDUCTION","getGLTypeFromTypedArray","arrayOrType","type","ArrayBuffer","isView","constructor","Float32Array","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray","Int8Array","Int16Array","Int32Array","Error","getTypedArrayFromGLType","glType","options","clamped","flipRows","data","width","height","bytesPerPixel","temp","bytesPerRow","tempBuffer","y","topOffset","bottomOffset","set","subarray","copyWithin","scalePixels","newWidth","Math","round","newHeight","newData","x","c"],"sources":["../../src/classic/typed-array-utils.ts"],"sourcesContent":["// luma.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {TypedArray, TypedArrayConstructor} from '@luma.gl/core';\nimport {GL, GLDataType, GLPixelType} from '@luma.gl/constants';\n\nconst ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';\n\n/**\n * Converts TYPED ARRAYS to corresponding GL constant\n * Used to auto deduce gl parameter types\n * @deprecated Use getDataTypeFromTypedArray\n * @param arrayOrType\n * @returns\n */\nexport function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLDataType {\n  // If typed array, look up constructor\n  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n  switch (type) {\n    case Float32Array:\n      return GL.FLOAT;\n    case Uint16Array:\n      return GL.UNSIGNED_SHORT;\n    case Uint32Array:\n      return GL.UNSIGNED_INT;\n    case Uint8Array:\n      return GL.UNSIGNED_BYTE;\n    case Uint8ClampedArray:\n      return GL.UNSIGNED_BYTE;\n    case Int8Array:\n      return GL.BYTE;\n    case Int16Array:\n      return GL.SHORT;\n    case Int32Array:\n      return GL.INT;\n    default:\n      throw new Error(ERR_TYPE_DEDUCTION);\n  }\n}\n\n/**\n * Converts GL constant to corresponding TYPED ARRAY\n * Used to auto deduce gl parameter types\n * @deprecated Use getTypedArrayFromDataType\n * @param glType\n * @param param1\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function getTypedArrayFromGLType(\n  glType: GLDataType | GLPixelType,\n  options?: {\n    clamped?: boolean;\n  }\n): TypedArrayConstructor {\n  const {clamped = true} = options || {};\n  // Sorted in some order of likelihood to reduce amount of comparisons\n  switch (glType) {\n    case GL.FLOAT:\n      return Float32Array;\n    case GL.UNSIGNED_SHORT:\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return Uint16Array;\n    case GL.UNSIGNED_INT:\n      return Uint32Array;\n    case GL.UNSIGNED_BYTE:\n      return clamped ? Uint8ClampedArray : Uint8Array;\n    case GL.BYTE:\n      return Int8Array;\n    case GL.SHORT:\n      return Int16Array;\n    case GL.INT:\n      return Int32Array;\n    default:\n      throw new Error('Failed to deduce typed array type from GL constant');\n  }\n}\n\n/**\n * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)\n * https: *stackoverflow.com/questions/41969562/\n * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels\n * @param param0\n */\nexport function flipRows(options: {\n  data: TypedArray;\n  width: number;\n  height: number;\n  bytesPerPixel?: number;\n  temp?: Uint8Array;\n}): void {\n  const {data, width, height, bytesPerPixel = 4, temp} = options;\n  const bytesPerRow = width * bytesPerPixel;\n\n  // make a temp buffer to hold one row\n  const tempBuffer = temp || new Uint8Array(bytesPerRow);\n  for (let y = 0; y < height / 2; ++y) {\n    const topOffset = y * bytesPerRow;\n    const bottomOffset = (height - y - 1) * bytesPerRow;\n    // make copy of a row on the top half\n    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));\n    // copy a row from the bottom half to the top\n    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);\n    // copy the copy of the top half row to the bottom half\n    data.set(tempBuffer, bottomOffset);\n  }\n}\n\n\nexport function scalePixels(options: {\n  data: TypedArray;\n  width: number;\n  height: number;\n}): {\n  data: Uint8Array;\n  width: number;\n  height: number;\n} {\n  const {data, width, height} = options;\n  const newWidth = Math.round(width / 2);\n  const newHeight = Math.round(height / 2);\n  const newData = new Uint8Array(newWidth * newHeight * 4);\n  for (let y = 0; y < newHeight; y++) {\n    for (let x = 0; x < newWidth; x++) {\n      for (let c = 0; c < 4; c++) {\n        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];\n      }\n    }\n  }\n  return {data: newData, width: newWidth, height: newHeight};\n}\n"],"mappings":"AAMA,MAAMA,kBAAkB,GAAG,+CAA+C;AAS1E,OAAO,SAASC,uBAAuBA,CAACC,WAAuB,EAAc;EAE3E,MAAMC,IAAI,GAAGC,WAAW,CAACC,MAAM,CAACH,WAAW,CAAC,GAAGA,WAAW,CAACI,WAAW,GAAGJ,WAAW;EACpF,QAAQC,IAAI;IACV,KAAKI,YAAY;MACf;IACF,KAAKC,WAAW;MACd;IACF,KAAKC,WAAW;MACd;IACF,KAAKC,UAAU;MACb;IACF,KAAKC,iBAAiB;MACpB;IACF,KAAKC,SAAS;MACZ;IACF,KAAKC,UAAU;MACb;IACF,KAAKC,UAAU;MACb;IACF;MACE,MAAM,IAAIC,KAAK,CAACf,kBAAkB,CAAC;EACvC;AACF;AAWA,OAAO,SAASgB,uBAAuBA,CACrCC,MAAgC,EAChCC,OAEC,EACsB;EACvB,MAAM;IAACC,OAAO,GAAG;EAAI,CAAC,GAAGD,OAAO,IAAI,CAAC,CAAC;EAEtC,QAAQD,MAAM;IACZ;MACE,OAAOV,YAAY;IACrB;IACA;IACA;IACA;MACE,OAAOC,WAAW;IACpB;MACE,OAAOC,WAAW;IACpB;MACE,OAAOU,OAAO,GAAGR,iBAAiB,GAAGD,UAAU;IACjD;MACE,OAAOE,SAAS;IAClB;MACE,OAAOC,UAAU;IACnB;MACE,OAAOC,UAAU;IACnB;MACE,MAAM,IAAIC,KAAK,CAAC,oDAAoD,CAAC;EACzE;AACF;AAQA,OAAO,SAASK,QAAQA,CAACF,OAMxB,EAAQ;EACP,MAAM;IAACG,IAAI;IAAEC,KAAK;IAAEC,MAAM;IAAEC,aAAa,GAAG,CAAC;IAAEC;EAAI,CAAC,GAAGP,OAAO;EAC9D,MAAMQ,WAAW,GAAGJ,KAAK,GAAGE,aAAa;EAGzC,MAAMG,UAAU,GAAGF,IAAI,IAAI,IAAIf,UAAU,CAACgB,WAAW,CAAC;EACtD,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,MAAM,GAAG,CAAC,EAAE,EAAEK,CAAC,EAAE;IACnC,MAAMC,SAAS,GAAGD,CAAC,GAAGF,WAAW;IACjC,MAAMI,YAAY,GAAG,CAACP,MAAM,GAAGK,CAAC,GAAG,CAAC,IAAIF,WAAW;IAEnDC,UAAU,CAACI,GAAG,CAACV,IAAI,CAACW,QAAQ,CAACH,SAAS,EAAEA,SAAS,GAAGH,WAAW,CAAC,CAAC;IAEjEL,IAAI,CAACY,UAAU,CAACJ,SAAS,EAAEC,YAAY,EAAEA,YAAY,GAAGJ,WAAW,CAAC;IAEpEL,IAAI,CAACU,GAAG,CAACJ,UAAU,EAAEG,YAAY,CAAC;EACpC;AACF;AAGA,OAAO,SAASI,WAAWA,CAAChB,OAI3B,EAIC;EACA,MAAM;IAACG,IAAI;IAAEC,KAAK;IAAEC;EAAM,CAAC,GAAGL,OAAO;EACrC,MAAMiB,QAAQ,GAAGC,IAAI,CAACC,KAAK,CAACf,KAAK,GAAG,CAAC,CAAC;EACtC,MAAMgB,SAAS,GAAGF,IAAI,CAACC,KAAK,CAACd,MAAM,GAAG,CAAC,CAAC;EACxC,MAAMgB,OAAO,GAAG,IAAI7B,UAAU,CAACyB,QAAQ,GAAGG,SAAS,GAAG,CAAC,CAAC;EACxD,KAAK,IAAIV,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGU,SAAS,EAAEV,CAAC,EAAE,EAAE;IAClC,KAAK,IAAIY,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,QAAQ,EAAEK,CAAC,EAAE,EAAE;MACjC,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;QAC1BF,OAAO,CAAC,CAACX,CAAC,GAAGO,QAAQ,GAAGK,CAAC,IAAI,CAAC,GAAGC,CAAC,CAAC,GAAGpB,IAAI,CAAC,CAACO,CAAC,GAAG,CAAC,GAAGN,KAAK,GAAGkB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAGC,CAAC,CAAC;MAC7E;IACF;EACF;EACA,OAAO;IAACpB,IAAI,EAAEkB,OAAO;IAAEjB,KAAK,EAAEa,QAAQ;IAAEZ,MAAM,EAAEe;EAAS,CAAC;AAC5D"}

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

@@ -1,22 +1,21 @@
-/// <reference types="offscreencanvas" />
 /**
  * ContextProps
-* @param webgl2 Set to false to not create a WebGL2 context (force webgl1)
-* @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)
-* @param onContextLost
-* @param onContextRestored
-*
-* BROWSER CONTEXT PARAMETERS
-* @param debug Instrument context (at the expense of performance).
-* @param alpha Default render target has an alpha buffer.
-* @param depth Default render target has a depth buffer of at least 16 bits.
-* @param stencil Default render target has a stencil buffer of at least 8 bits.
-* @param antialias Boolean that indicates whether or not to perform anti-aliasing.
-* @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.
-* @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten
-* @param failIfMajorPerformanceCaveat Do not create if the system performance is low.
-*/
-declare type ContextProps = {
+ * @param webgl2 Set to false to not create a WebGL2 context (force webgl1)
+ * @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)
+ * @param onContextLost
+ * @param onContextRestored
+ *
+ * BROWSER CONTEXT PARAMETERS
+ * @param debug Instrument context (at the expense of performance).
+ * @param alpha Default render target has an alpha buffer.
+ * @param depth Default render target has a depth buffer of at least 16 bits.
+ * @param stencil Default render target has a stencil buffer of at least 8 bits.
+ * @param antialias Boolean that indicates whether or not to perform anti-aliasing.
+ * @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.
+ * @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten
+ * @param failIfMajorPerformanceCaveat Do not create if the system performance is low.
+ */
+type ContextProps = {
     type?: 'webgl' | 'webgl1' | 'webgl2' | string;
     webgl1?: boolean;
     webgl2?: boolean;
@@ -34,7 +33,7 @@ declare type ContextProps = {
 /**
  * Create a WebGL context for a canvas
  * Note calling this multiple time on the same canvas does return the same context
-* @param canvas A canvas element or offscreen canvas
+ * @param canvas A canvas element or offscreen canvas
  */
 export declare function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGLRenderingContext;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"create-browser-context.d.ts","sourceRoot":"","sources":["../../../src/context/context/create-browser-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,CAiD7H"}
+{"version":3,"file":"create-browser-context.d.ts","sourceRoot":"","sources":["../../../src/context/context/create-browser-context.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,KAAK,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,GAAG,kBAAkB,GAAG,WAAW,CAAC;IAC/D,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAYF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,iBAAiB,GAAG,eAAe,EAC3C,KAAK,EAAE,YAAY,GAClB,qBAAqB,CAiEvB"}

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

@@ -6,56 +6,48 @@ const DEFAULT_CONTEXT_PROPS = {
   onContextRestored: () => console.info('WebGL context restored')
 };
 export function createBrowserContext(canvas, props) {
-  props = { ...DEFAULT_CONTEXT_PROPS,
+  props = {
+    ...DEFAULT_CONTEXT_PROPS,
     ...props
   };
   let errorMessage = null;
-
   const onCreateError = error => errorMessage = error.statusMessage || errorMessage;
-
   canvas.addEventListener('webglcontextcreationerror', onCreateError, false);
   let gl = null;
-
   if (props.type === 'webgl2') {
-    props = { ...props,
+    props = {
+      ...props,
       webgl1: false
     };
   }
-
   if (props.type === 'webgl1') {
-    props = { ...props,
+    props = {
+      ...props,
       webgl2: false
     };
   }
-
-  if (props.webgl2) {
-    gl = gl || canvas.getContext('webgl2', props);
+  if (!gl && props.webgl2) {
+    gl = canvas.getContext('webgl2', props);
   }
-
-  if (props.webgl1) {
-    gl = gl || canvas.getContext('webgl', props);
+  if (!gl && props.webgl1) {
+    gl = canvas.getContext('webgl', props);
   }
-
   canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);
-
   if (!gl) {
-    throw new Error("Failed to create ".concat(props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL', " context: ").concat(errorMessage || 'Unknown error'));
+    throw new Error(`Failed to create ${props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL'} context: ${errorMessage || 'Unknown error'}`);
   }
-
   if (props.onContextLost) {
     const {
       onContextLost
     } = props;
     canvas.addEventListener('webglcontextlost', event => onContextLost(event), false);
   }
-
   if (props.onContextRestored) {
     const {
       onContextRestored
     } = props;
     canvas.addEventListener('webglcontextrestored', event => onContextRestored(event), false);
   }
-
   return gl;
 }
 //# sourceMappingURL=create-browser-context.js.map