@luma.gl/webgl 8.5.8 → 8.6.0-alpha.2

package/dist/webgl-utils/texture-utils.js

@@ -0,0 +1,48 @@
+import { assert } from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import Texture2D from '../classes/texture-2d';
+import TextureCube from '../classes/texture-cube';
+import Texture3D from '../classes/texture-3d';
+import Framebuffer from '../classes/framebuffer';
+export function cloneTextureFrom(refTexture, overrides) {
+  assert(refTexture instanceof Texture2D || refTexture instanceof TextureCube || refTexture instanceof Texture3D);
+  const TextureType = refTexture.constructor;
+  const {
+    gl,
+    width,
+    height,
+    format,
+    type,
+    dataFormat,
+    border,
+    mipmaps
+  } = refTexture;
+  const textureOptions = Object.assign({
+    width,
+    height,
+    format,
+    type,
+    dataFormat,
+    border,
+    mipmaps
+  }, overrides);
+  return new TextureType(gl, textureOptions);
+}
+export function toFramebuffer(texture, opts) {
+  const {
+    gl,
+    width,
+    height,
+    id
+  } = texture;
+  const framebuffer = new Framebuffer(gl, Object.assign({}, opts, {
+    id: "framebuffer-for-".concat(id),
+    width,
+    height,
+    attachments: {
+      [GL.COLOR_ATTACHMENT0]: texture
+    }
+  }));
+  return framebuffer;
+}
+//# sourceMappingURL=texture-utils.js.map

package/dist/webgl-utils/texture-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/texture-utils.ts"],"names":["assert","GL","Texture2D","TextureCube","Texture3D","Framebuffer","cloneTextureFrom","refTexture","overrides","TextureType","constructor","gl","width","height","format","type","dataFormat","border","mipmaps","textureOptions","Object","assign","toFramebuffer","texture","opts","id","framebuffer","attachments","COLOR_ATTACHMENT0"],"mappings":"AACA,SAAQA,MAAR,QAAqB,cAArB;AACA,OAAOC,EAAP,MAAe,oBAAf;AAEA,OAAOC,SAAP,MAAsB,uBAAtB;AACA,OAAOC,WAAP,MAAwB,yBAAxB;AACA,OAAOC,SAAP,MAAsB,uBAAtB;AACA,OAAOC,WAAP,MAA4C,wBAA5C;AAKA,OAAO,SAASC,gBAAT,CAAiDC,UAAjD,EAAgEC,SAAhE,EAAoF;AACzFR,EAAAA,MAAM,CACJO,UAAU,YAAYL,SAAtB,IACEK,UAAU,YAAYJ,WADxB,IAEEI,UAAU,YAAYH,SAHpB,CAAN;AAMA,QAAMK,WAAW,GAAGF,UAAU,CAACG,WAA/B;AAEA,QAAM;AAACC,IAAAA,EAAD;AAAKC,IAAAA,KAAL;AAAYC,IAAAA,MAAZ;AAAoBC,IAAAA,MAApB;AAA4BC,IAAAA,IAA5B;AAAkCC,IAAAA,UAAlC;AAA8CC,IAAAA,MAA9C;AAAsDC,IAAAA;AAAtD,MAAiEX,UAAvE;AAEA,QAAMY,cAAc,GAAGC,MAAM,CAACC,MAAP,CACrB;AACET,IAAAA,KADF;AAEEC,IAAAA,MAFF;AAGEC,IAAAA,MAHF;AAIEC,IAAAA,IAJF;AAKEC,IAAAA,UALF;AAMEC,IAAAA,MANF;AAOEC,IAAAA;AAPF,GADqB,EAUrBV,SAVqB,CAAvB;AAeA,SAAO,IAAIC,WAAJ,CAAgBE,EAAhB,EAAoBQ,cAApB,CAAP;AACD;AAMD,OAAO,SAASG,aAAT,CAAuBC,OAAvB,EAAyCC,IAAzC,EAA+E;AACpF,QAAM;AAACb,IAAAA,EAAD;AAAKC,IAAAA,KAAL;AAAYC,IAAAA,MAAZ;AAAoBY,IAAAA;AAApB,MAA0BF,OAAhC;AACA,QAAMG,WAAW,GAAG,IAAIrB,WAAJ,CAClBM,EADkB,EAElBS,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBG,IAAlB,EAAwB;AACtBC,IAAAA,EAAE,4BAAqBA,EAArB,CADoB;AAEtBb,IAAAA,KAFsB;AAGtBC,IAAAA,MAHsB;AAItBc,IAAAA,WAAW,EAAE;AACX,OAAC1B,EAAE,CAAC2B,iBAAJ,GAAwBL;AADb;AAJS,GAAxB,CAFkB,CAApB;AAWA,SAAOG,WAAP;AACD","sourcesContent":["// TODO: Two subdirectories must not depend on each other (classes vs utils)!\nimport {assert} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport Texture from '../classes/texture';\nimport Texture2D from '../classes/texture-2d';\nimport TextureCube from '../classes/texture-cube';\nimport Texture3D from '../classes/texture-3d';\nimport Framebuffer, {FramebufferProps} from '../classes/framebuffer';\n\ntype TextureType = Texture2D | TextureCube | Texture3D;\n\n/** Clone a new texture object from a reference texture object. */\nexport function cloneTextureFrom<T extends TextureType>(refTexture: T, overrides?: any): T {\n  assert(\n    refTexture instanceof Texture2D ||\n      refTexture instanceof TextureCube ||\n      refTexture instanceof Texture3D\n  );\n\n  const TextureType = refTexture.constructor;\n\n  const {gl, width, height, format, type, dataFormat, border, mipmaps} = refTexture;\n\n  const textureOptions = Object.assign(\n    {\n      width,\n      height,\n      format,\n      type,\n      dataFormat,\n      border,\n      mipmaps\n    },\n    overrides\n  );\n\n  // TODO: move this to `Texture` class as instance method and use this.constructor\n  // @ts-expect-error\n  return new TextureType(gl, textureOptions);\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, opts?: FramebufferProps): Framebuffer {\n  const {gl, width, height, id} = texture;\n  const framebuffer = new Framebuffer(\n    gl,\n    Object.assign({}, opts, {\n      id: `framebuffer-for-${id}`,\n      width,\n      height,\n      attachments: {\n        [GL.COLOR_ATTACHMENT0]: texture\n      }\n    })\n  );\n  return framebuffer;\n}\n"],"file":"texture-utils.js"}

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

@@ -0,0 +1,43 @@
+import GL from '@luma.gl/constants';
+declare type TypedArrayConstructor = Float32ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor;
+/**
+ * Converts TYPED ARRAYS to corresponding GL constant
+ * Used to auto deduce gl parameter types
+ * @param {*} arrayOrType
+ * @returns
+ */
+export declare function getGLTypeFromTypedArray(arrayOrType: any): GL.BYTE | GL.UNSIGNED_BYTE | GL.SHORT | GL.UNSIGNED_SHORT | GL.INT | GL.UNSIGNED_INT | GL.FLOAT;
+/**
+ * Converts GL constant to corresponding TYPED ARRAY
+ * Used to auto deduce gl parameter types
+ * @param {*} glType
+ * @param {*} param1
+ * @returns
+ */
+export declare function getTypedArrayFromGLType(glType: any, 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
+ */
+export declare function flipRows(options: {
+    data: any;
+    width: any;
+    height: any;
+    bytesPerPixel?: number;
+    temp?: any;
+}): void;
+export declare function scalePixels(options: {
+    data: any;
+    width: any;
+    height: any;
+}): {
+    data: Uint8Array;
+    width: number;
+    height: number;
+};
+export {};
+//# sourceMappingURL=typed-array-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array-utils.d.ts","sourceRoot":"","sources":["../../src/webgl-utils/typed-array-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAIpC,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,KAAA,mGAuBlD;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"}

package/{src → dist}/webgl-utils/typed-array-utils.js

@@ -1,88 +1,100 @@
 import GL from '@luma.gl/constants';
-
 const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
-
-// Converts TYPED ARRAYS to corresponding GL constant
-// Used to auto deduce gl parameter types
 export function getGLTypeFromTypedArray(arrayOrType) {
-  // If typed array, look up constructor
   const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+
   switch (type) {
     case Float32Array:
       return GL.FLOAT;
+
     case Uint16Array:
       return GL.UNSIGNED_SHORT;
+
     case Uint32Array:
       return GL.UNSIGNED_INT;
+
     case Uint8Array:
       return GL.UNSIGNED_BYTE;
+
     case Uint8ClampedArray:
       return GL.UNSIGNED_BYTE;
+
     case Int8Array:
       return GL.BYTE;
+
     case Int16Array:
       return GL.SHORT;
+
     case Int32Array:
       return GL.INT;
+
     default:
       throw new Error(ERR_TYPE_DEDUCTION);
   }
 }
+export function getTypedArrayFromGLType(glType, options) {
+  const {
+    clamped = true
+  } = options || {};
 
-// Converts GL constant to corresponding TYPED ARRAY
-// Used to auto deduce gl parameter types
-
-/* eslint-disable complexity */
-export function getTypedArrayFromGLType(glType, {clamped = true} = {}) {
-  // Sorted in some order of likelihood to reduce amount of comparisons
   switch (glType) {
     case GL.FLOAT:
       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:
       return Uint16Array;
+
     case GL.UNSIGNED_INT:
       return Uint32Array;
+
     case GL.UNSIGNED_BYTE:
       return clamped ? Uint8ClampedArray : Uint8Array;
+
     case GL.BYTE:
       return Int8Array;
+
     case GL.SHORT:
       return Int16Array;
+
     case GL.INT:
       return Int32Array;
+
     default:
       throw new Error('Failed to deduce typed array type from GL constant');
   }
 }
-/* eslint-enable complexity */
-
-// 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
-export function flipRows({data, width, height, bytesPerPixel = 4, temp}) {
+export function flipRows(options) {
+  const {
+    data,
+    width,
+    height,
+    bytesPerPixel = 4,
+    temp
+  } = options;
   const bytesPerRow = width * bytesPerPixel;
+  const tempBuffer = temp || new Uint8Array(bytesPerRow);
 
-  // make a temp buffer to hold one row
-  temp = temp || new Uint8Array(bytesPerRow);
   for (let y = 0; y < height / 2; ++y) {
     const topOffset = y * bytesPerRow;
     const bottomOffset = (height - y - 1) * bytesPerRow;
-    // make copy of a row on the top half
-    temp.set(data.subarray(topOffset, topOffset + bytesPerRow));
-    // copy a row from the bottom half to the top
+    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));
     data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);
-    // copy the copy of the top half row to the bottom half
-    data.set(temp, bottomOffset);
+    data.set(tempBuffer, bottomOffset);
   }
 }
-
-export function scalePixels({data, width, height}) {
+export function scalePixels(options) {
+  const {
+    data,
+    width,
+    height
+  } = 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++) {
@@ -90,5 +102,11 @@ export function scalePixels({data, width, height}) {
       }
     }
   }
-  return {data: newData, width: newWidth, height: newHeight};
+
+  return {
+    data: newData,
+    width: newWidth,
+    height: newHeight
+  };
 }
+//# sourceMappingURL=typed-array-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/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":["import GL from '@luma.gl/constants';\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) {\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"}

package/dist/webgl-utils/webgl-info.ts.disabled

@@ -0,0 +1,135 @@
+// Feature detection for WebGL
+//
+// Provides a function that enables simple checking of which WebGL features are
+// available in an WebGL1 or WebGL2 environment.
+
+/* eslint-disable no-inline-comments, max-len */
+import isOldIE from './is-old-ie';
+import {assert} from './assert';
+
+const GL_VENDOR = 0x1f00;
+const GL_RENDERER = 0x1f01;
+const GL_VERSION = 0x1f02;
+const GL_SHADING_LANGUAGE_VERSION = 0x8b8c;
+
+// Defines luma.gl "feature" names and semantics
+const WEBGL_FEATURES = {
+  // GLSL extensions
+  GLSL_FRAG_DATA: ['WEBGL_draw_buffers', true], // TODO - name makes no sense in GLSL 3.00
+  GLSL_FRAG_DEPTH: ['EXT_frag_depth', true],
+  GLSL_DERIVATIVES: ['OES_standard_derivatives', true],
+  GLSL_TEXTURE_LOD: ['EXT_shader_texture_lod', true]
+};
+
+// Create a key-mirrored FEATURES array
+export const FEATURES = {
+  GLSL_FRAG_DATA: 'GLSL_FRAG_DATA',
+  GLSL_FRAG_DEPTH: 'GLSL_FRAG_DEPTH',
+  GLSL_DERIVATIVES: 'GLSL_DERIVATIVES',
+  GLSL_TEXTURE_LOD: 'GLSL_TEXTURE_LOD',
+};
+
+function isWebGL2(gl) {
+  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
+    return true;
+  }
+  return Boolean(gl && gl._version === 2);
+}
+
+export function getContextInfo(gl) {
+  const info = gl.getExtension('WEBGL_debug_renderer_info');
+  const vendor = gl.getParameter((info && info.UNMASKED_VENDOR_WEBGL) || GL_VENDOR);
+  const renderer = gl.getParameter((info && info.UNMASKED_RENDERER_WEBGL) || GL_RENDERER);
+  const gpuVendor = identifyGPUVendor(vendor, renderer);
+  const gpuInfo = {
+    gpuVendor,
+    vendor,
+    renderer,
+    version: gl.getParameter(GL_VERSION),
+    shadingLanguageVersion: gl.getParameter(GL_SHADING_LANGUAGE_VERSION)
+  };
+  return gpuInfo;
+}
+
+function identifyGPUVendor(vendor, renderer) {
+  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {
+    return 'NVIDIA';
+  }
+  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {
+    return 'INTEL';
+  }
+  if (vendor.match(/Apple/i) || renderer.match(/Apple/i)) {
+    return 'APPLE';
+  }
+  if (
+    vendor.match(/AMD/i) ||
+    renderer.match(/AMD/i) ||
+    vendor.match(/ATI/i) ||
+    renderer.match(/ATI/i)
+  ) {
+    return 'AMD';
+  }
+  return 'UNKNOWN';
+}
+
+const compiledGlslExtensions = {};
+
+// Enables feature detection in IE11 due to a bug where gl.getExtension may return true
+// but fail to compile when the extension is enabled in the shader. Specifically,
+// the OES_standard_derivatives and WEBGL_draw_buffers extensions fails to compile in IE11 even though its included
+// in the list of supported extensions.
+// opts allows user agent to be overridden for testing
+/*
+ * Inputs :
+ *  gl : WebGL context
+ *  cap : Key of WEBGL_FEATURES object identifying the extension
+ *  opts :
+ *   behavior : behavior of extension to be tested, by defualt `enable` is used
+ * Returns : true, if shader is compiled successfully, false otherwise
+ */
+export function canCompileGLGSExtension(gl, cap, opts: {behavior?} = {}) {
+  const feature = WEBGL_FEATURES[cap];
+  assert(feature, cap);
+
+  if (!isOldIE(opts)) {
+    return true;
+  }
+
+  if (cap in compiledGlslExtensions) {
+    return compiledGlslExtensions[cap];
+  }
+
+  const extensionName = feature[0];
+  const behavior = opts.behavior || 'enable';
+  const source = `#extension GL_${extensionName} : ${behavior}\nvoid main(void) {}`;
+
+  const shader = gl.createShader(gl.VERTEX_SHADER);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+  gl.deleteShader(shader);
+  compiledGlslExtensions[cap] = canCompile;
+  return canCompile;
+}
+
+// TODO - cache the value
+function getFeature(gl, cap) {
+  const feature = WEBGL_FEATURES[cap];
+  assert(feature, cap);
+
+  // Get extension name from table
+  const extensionName = isWebGL2(gl) ? feature[1] || feature[0] : feature[0];
+
+  // Check if the value is dependent on checking an extension
+  const value =
+    typeof extensionName === 'string' ? Boolean(gl.getExtension(extensionName)) : extensionName;
+
+  assert(value === false || value === true);
+
+  return value;
+}
+
+export function hasFeatures(gl, features) {
+  features = Array.isArray(features) ? features : [features];
+  return features.every((feature) => getFeature(gl, feature));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "8.5.8",
+  "version": "8.6.0-alpha.2",
   "description": "WebGL2 Classes",
   "license": "MIT",
   "publishConfig": {
@@ -16,9 +16,9 @@
     "animation",
     "3d"
   ],
-  "types": "src/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "files": [
     "src",
     "dist",
@@ -30,14 +30,14 @@
     "gl/wrap": false
   },
   "scripts": {
-    "pre-build": "npm run build-bundle && npm run build-bundle -- --env.dev",
+    "pre-build": "npm run build-bundle",
     "build-bundle": "webpack --display=minimal --config ../../scripts/bundle.config.js"
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/constants": "8.5.8",
-    "@luma.gl/gltools": "8.5.8",
-    "probe.gl": "^3.4.0"
+    "@luma.gl/api": "8.6.0-alpha.2",
+    "@luma.gl/constants": "8.6.0-alpha.2",
+    "@probe.gl/env": "3.5.0-alpha.5"
   },
-  "gitHead": "ec6897d6a3df73e30a4f31be904b2fba4fcac191"
+  "gitHead": "bdcebda76c1b4e47b127cdbd3f426ea6cbae44f1"
 }

package/src/api/device2.ts

@@ -0,0 +1,71 @@
+
+import {Stats} from '@probe.gl/stats';
+
+export type DeviceInfo = {
+  vendor: string,
+  renderer: string,
+  vendorMasked: string,
+  rendererMasked: string,
+  version: string,
+  shadingLanguage: string
+};
+
+/** Limits for a device */
+export type DeviceLimits = {
+  readonly maxTextureDimension1D?: number;
+  readonly maxTextureDimension2D?: number;
+  readonly maxTextureDimension3D?: number;
+  readonly maxTextureArrayLayers?: number;
+  readonly maxBindGroups: number;
+  readonly maxDynamicUniformBuffersPerPipelineLayout: number;
+  readonly maxDynamicStorageBuffersPerPipelineLayout: number;
+  readonly maxSampledTexturesPerShaderStage: number;
+  readonly maxSamplersPerShaderStage: number;
+  readonly maxStorageBuffersPerShaderStage: number;
+  readonly maxStorageTexturesPerShaderStage: number;
+  readonly maxUniformBuffersPerShaderStage: number;
+  readonly maxUniformBufferBindingSize: number;
+  readonly maxStorageBufferBindingSize?: number;
+  readonly minUniformBufferOffsetAlignment?: number;
+  readonly minStorageBufferOffsetAlignment?: number;
+  readonly maxVertexBuffers?: number;
+  readonly maxVertexAttributes?: number;
+  readonly maxVertexBufferArrayStride?: number;
+  readonly maxInterStageShaderComponents?: number;
+  readonly maxComputeWorkgroupStorageSize?: number;
+  readonly maxComputeInvocationsPerWorkgroup?: number;
+  readonly maxComputeWorkgroupSizeX?: number;
+  readonly maxComputeWorkgroupSizeY?: number;
+  readonly maxComputeWorkgroupSizeZ?: number;
+  readonly maxComputeWorkgroupsPerDimension?: number;
+};
+
+/**
+ * WebGPU Device/WebGL context abstraction
+ */
+export default abstract class Device {
+  private stats = new Map();
+
+  // readonly canvas: HTMLCanvasElement;
+
+  /** Check if this device type is supported on this platform */
+  // static isSupported(): boolean;
+
+  /** Create device of this type (asynchronous) */
+  // static async create(props?: object): Promise<Device>;
+
+  /** Attach to existing WebGPU device */
+  // static attach(device: WebGPUDevice, props?: object): Device;
+
+  /** Resize the context */
+  // resize(width: number, height: number): void;
+  abstract features: Set<string>;
+  abstract limits: DeviceLimits;
+
+  getStats(name: string): Stats {
+    if (!this.stats.has(name)) {
+      this.stats.set(name, new Stats({id: name}));
+    }
+    return this.stats.get(name);
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+const moduleExports = require('./index');
+globalThis.luma = globalThis.luma || {};
+module.exports = Object.assign(globalThis.luma, moduleExports);

package/src/classes/accessor.js

@@ -1,7 +1,6 @@
+import {assert, checkProps} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
 import {getTypedArrayFromGLType} from '../webgl-utils/typed-array-utils';
-import {assert} from '../utils/assert';
-import {checkProps} from '../utils/check-props';
 
 const DEFAULT_ACCESSOR_VALUES = {
   offset: 0,
@@ -45,7 +44,7 @@ export default class Accessor {
   }
 
   constructor(...accessors) {
-    accessors.forEach(accessor => this._assign(accessor)); // Merge in sequence
+    accessors.forEach((accessor) => this._assign(accessor)); // Merge in sequence
     Object.freeze(this);
   }