@luma.gl/webgl 8.5.9 → 8.6.0-alpha.3

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "8.5.9",
+  "version": "8.6.0-alpha.3",
   "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.9",
-    "@luma.gl/gltools": "8.5.9",
-    "probe.gl": "^3.4.0"
+    "@luma.gl/api": "8.6.0-alpha.3",
+    "@luma.gl/constants": "8.6.0-alpha.3",
+    "@probe.gl/env": "^3.5.0"
   },
-  "gitHead": "8c70c28a90b7507592a6029f51428f7397daed49"
+  "gitHead": "a808a90fb8d59b682f5b647b8caa819f26827512"
 }

package/src/adapter/converters/set-device-parameters.ts

@@ -0,0 +1,182 @@
+import {Device, Parameters, CompareFunction, StencilOperation, log} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import {WebGLDevice} from '@luma.gl/webgl';
+
+/** Set WebGPU Style Parameters */
+export function setDeviceParameters(device: Device, parameters: Parameters) {
+  const webglDevice = WebGLDevice.attach(device);
+  const {gl, gl2} = webglDevice;
+
+  // RASTERIZATION SETTINGS
+  if (parameters.cullMode) {
+    switch (parameters.cullMode) {
+      case 'none':
+        gl.disable(GL.CULL_FACE);
+        break;
+      case 'front':
+        gl.enable(GL.CULL_FACE);
+        gl.cullFace(GL.FRONT);
+        break;
+      case 'back':
+        gl.enable(GL.CULL_FACE);
+        gl.cullFace(GL.BACK);
+        break;
+    }
+  }
+
+  if (parameters.frontFace) {
+    gl.frontFace(map('frontFace', parameters.frontFace, {
+      ccw: GL.CCW,
+      cw: GL.CW
+    }));
+  }
+
+  if (parameters.depthBias !== undefined) {
+    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
+  }
+
+  // depthBiasSlopeScale: {
+  //   // Handled by depthBias
+  // },
+
+  // DEPTH STENCIL
+
+  if (parameters.depthWriteEnabled !== undefined) {
+    gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));
+  }
+
+ if (parameters.depthCompare) {
+    parameters.depthCompare !== 'always' ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST),
+    gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));
+  }
+
+  if (parameters.stencilWriteMask) {
+    const mask = parameters.stencilWriteMask;
+    gl.stencilMaskSeparate(GL.FRONT, mask);
+    gl.stencilMaskSeparate(GL.BACK, mask);
+  }
+
+  if (parameters.stencilReadMask) {
+    // stencilReadMask is handle inside stencil***Compare.
+    log.warn('stencilReadMask not supported under WebGL');
+  }
+
+  if (parameters.stencilCompare) {
+    const mask = parameters.stencilReadMask || 0xffffffff;
+    const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);
+    // TODO - ensure back doesn't overwrite
+    parameters.stencilCompare !== 'always' ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),
+    gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
+    gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
+  }
+
+  if (parameters.stencilPassOperation) {
+    const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);
+    const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);
+    const dpfail = convertStencilOperation('stencilDepthFailOperation', parameters.stencilDepthFailOperation);
+    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
+  }
+
+  // stencilDepthFailOperation() {
+  //   // handled by stencilPassOperation
+  // },
+
+  // stencilFailOperation() {
+  //   // handled by stencilPassOperation
+  // },
+
+  // COLOR STATE
+
+  // if (parameters.blend) {
+  //   gl.enable(GL.BLEND);
+
+  //   const blend = parameters.blend;
+
+  //   let colorEquation = (blend && blend.color && blend.color.operation) || 'add';
+  //   let alphaEquation = (blend && blend.alpha && blend.alpha.operation) || 'add';
+  //   gl.blendEquationSeparate(colorEquation, alphaEquation);
+
+  //   let colorSrcFactor = (blend && blend.color && blend.color.srcFactor) || 'one';
+  //   let colorDstFactor = (blend && blend.color && blend.color.dstFactor) || 'zero';
+  //   let alphaSrcFactor = (blend && blend.alpha && blend.alpha.srcFactor) || 'one';
+  //   let alphaDstFactor = (blend && blend.alpha && blend.alpha.dstFactor) || 'zero';
+  //   gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
+  // }
+}
+
+/*
+      rasterizationState: {
+        cullMode: "back",
+      },
+
+      depthStencilState: {
+        depthWriteEnabled: true,
+        depthCompare: "less",
+        format: "depth24plus-stencil8",
+      },
+
+      colorStates: [
+        {
+          format: "bgra8unorm",
+          // colorBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;
+          // colorBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;
+          // alphaBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;
+          // alphaBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;
+        },
+      ],
+    });
+*/
+
+
+export function convertCompareFunction(parameter, value: CompareFunction): number {
+  return map(parameter, value, {
+    'never': GL.NEVER,
+    'less': GL.LESS,
+    'equal': GL.EQUAL,
+    'less-equal': GL.LEQUAL,
+    'greater': GL.GREATER,
+    'not-equal': GL.NOTEQUAL,
+    'greater-equal': GL.GEQUAL,
+    'always': GL.ALWAYS
+  });
+}
+
+function convertStencilOperation(parameter, value: StencilOperation): number {
+  return map(parameter, value, {
+    'keep': GL.KEEP,
+    'zero': GL.ZERO,
+    'replace': GL.REPLACE,
+    'invert': GL.INVERT,
+    'increment-clamp': GL.INCR,
+    'decrement-clamp': GL.DECR,
+    'increment-wrap': GL.INCR_WRAP,
+    'decrement-wrap': GL.DECR_WRAP
+  });
+}
+
+function convertBlendOperationToEquation(parameter, value): number {
+  return map(parameter, value, {
+    'add': GL.FUNC_ADD,
+    'sub': GL.FUNC_SUBTRACT,
+    'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,
+    // When using a WebGL 2 context, the following values are available additionally:
+    'min': GL.MIN,
+    'max': GL.MAX
+  });
+}
+
+function message(parameter, value) {
+  return `Illegal parameter ${value} for ${parameter}`;
+}
+
+function map(parameter, value, valueMap) {
+  if (!(value in valueMap)) {
+    throw new Error(message(parameter, value));
+  }
+  return valueMap[value];
+}
+
+function mapBoolean(parameter, value) {
+  return value;
+}

package/src/adapter/converters/webgpu-texture-formats.ts

@@ -0,0 +1,167 @@
+import GL from '@luma.gl/constants';
+
+// Define local extension strings to optimize minification
+const SRGB = 'EXT_sRGB';
+const EXT_FLOAT_WEBGL1 = 'WEBGL.color_buffer_float';
+const EXT_FLOAT_WEBGL2 = 'EXT_color_buffer_float';
+const EXT_HALF_FLOAT_WEBGL1 = 'EXT_color_buffer_half_float';
+
+// const S3TC = 'WEBGL_compressed_texture_s3tc';
+// const PVRTC = 'WEBGL_compressed_texture_pvrtc';
+// const ES3 = 'WEBGL_compressed_texture_es3';
+// const ETC1 = 'WEBGL_compressed_texture_etc1';
+// const SRGB = 'EXT_sRGB';
+// const DEPTH = 'WEBGL_depth_texture';
+
+// NOTES:
+// - gl2: format requires WebGL2, when using a WebGL 1 context, color renderbuffer formats are limited
+// - b (bytes per pixel), for memory usage calculations.
+// - c (channels)
+// - p (packed)
+
+export const TEXTURE_FORMAT_DEFINITIONS = {
+  // 8-bit formats
+  'r8unorm': {b: 1, c: 1, gl: GL.R8, gl2: true},
+  'r8snorm': {b: 1, c: 1},
+  'r8uint': {b: 1, c: 1, gl: GL.R8UI, gl2: true},
+  'r8sint': {b: 1, c: 1, gl: GL.R8I, gl2: true},
+
+  // 16-bit formats
+  'r16uint': {b: 2, c: 1, gl: GL.R16UI, gl2: true},
+  'r16sint': {b: 2, c: 1, gl: GL.R16I, gl2: true},
+  'r16float': {b: 2, c: 1, gl: GL.R16F, gl2: EXT_FLOAT_WEBGL2},
+  'rg8unorm': {b: 2, c: 2, gl: GL.RG8, gl2: true},
+  'rg8snorm': {b: 2, c: 2},
+  'rg8uint': {b: 2, c: 2, gl: GL.RG8UI, gl2: true},
+  'rg8sint': {b: 2, c: 2, gl: GL.RG8I, gl2: true},
+
+  // Packed 16-bit formats
+  // 'rgba4norm?': {b: 2, c: 4, gl: GL.RGBA4, wgpu: false},
+  // 'rgb565norm?': {b: 2, c: 4, gl: GL.RGB565, wgpu: false},
+  // 'rgb5a1norm?': {b: 2, c: 4, gl: GL.RGB5_A1, wgpu: false},
+
+  // 24-bit formats
+  // 'rbg8norm?': {b: 3, c: 3, gl: GL.RGB8, gl2: true, wgpu: false},
+
+  // 32-bit formats
+  'r32uint': {b: 4, c: 1, gl: GL.R32UI, gl2: true, bpp: 4},
+  'r32sint': {b: 4, c: 1, gl: GL.R32I, gl2: true, bpp: 4},
+  'r32float': {b: 4, c: 1, gl: GL.R32F, gl2: EXT_FLOAT_WEBGL2, bpp: 4},
+  'rg16uint': {b: 4, c: 1, gl: GL.RG16UI, gl2: true, bpp: 4},
+  'rg16sint': {b: 4, c: 2, gl: GL.RG16I, gl2: true, bpp: 4},
+  // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
+  'rg16float': {b: 4, c: 2, gl: GL.RG16F, gl2: EXT_FLOAT_WEBGL2, bpp: 4},
+  'rgba8unorm': {b: 4, c: 2, gl: GL.RGBA8, gl2: true, bpp: 4},
+
+  'rgba8unorm-srgb': {b: 4, c: 4, gl: GL.SRGB8_ALPHA8, gl2: true, gl1: SRGB, bpp: 4},
+  'rgba8snorm': {b: 4, c: 4},
+  'rgba8uint': {b: 4, c: 4, gl: GL.RGBA8UI, gl2: true, bpp: 4},
+  'rgba8sint': {b: 4, c: 4, gl: GL.RGBA8I, gl2: true, bpp: 4},
+  'bgra8unorm': {b: 4, c: 4},
+  'bgra8unorm-srgb': {b: 4, c: 4},
+
+  // Packed 32-bit formats
+  'rgb9e5ufloat': {b: 4, c: 3, p: 1, gl: GL.RGB9_E5, gl2: true, gl1: 'WEBGL_color_buffer_half_float'},
+  'rg11b10ufloat': {b: 4, c: 3, p: 1, gl: GL.R11F_G11F_B10F, gl2: EXT_FLOAT_WEBGL2},
+  'rgb10a2unorm': {b: 4, c: 4, p: 1, gl: GL.RGB10_A2, gl2: true},
+  // webgl2 only
+  // '?rgb10a2unorm?': {b: 4, c: 4, p: 1, webgpu: false, gl: GL.RGB10_A2UI, gl2: true, bpp: 4},
+
+  // 64-bit formats
+  'rg32uint': {b: 8, c: 2, gl: GL.RG32UI, gl2: true},
+  'rg32sint': {b: 8, c: 2, gl: GL.RG32I, gl2: true},
+  'rg32float': {b: 8, c: 2, gl: GL.RG32F, gl2: EXT_FLOAT_WEBGL2},
+  'rgba16uint': {b: 8, c: 4, gl: GL.RGBA16UI, gl2: true},
+  'rgba16sint': {b: 8, c: 4, gl: GL.RGBA16I, gl2: true},
+  'rgba16float': {b: 8, c: 4, gl: GL.RGBA16F, gl2: EXT_FLOAT_WEBGL2},
+
+  // 96-bit formats
+  // {gl: GL.RGB32F, dataFormat: GL.RGB, types: [GL.FLOAT], gl2: true},
+
+  // 128-bit formats
+  'rgba32uint': {b: 16, c: 4, gl: GL.RGBA32UI, gl2: true},
+  'rgba32sint': {b: 16, c: 4, gl: GL.RGBA32I, gl2: true},
+  'rgba32float': {b: 16, c: 4, gl: GL.RGBA32F, gl2: EXT_FLOAT_WEBGL2}, // gl1: EXT_FLOAT_WEBGL1
+
+  // Depth and stencil formats
+  'stencil8': {b: 1, c: 1, gl: GL.STENCIL_INDEX8}, // 8 stencil bits
+  'depth16unorm': {b: 2, c: 1, gl: GL.DEPTH_COMPONENT16}, // 16 depth bits
+  'depth24plus': {b: 3, c: 1, gl: GL.DEPTH_COMPONENT24, gl2: true},
+  'depth24plus-stencil8': {b: 4, c: 2, p: 1, gl: GL.DEPTH24_STENCIL8, gl2: true},
+  'depth32float': {b: 4, c: 1, gl: GL.DEPTH_COMPONENT32F, gl2: true},
+
+  // "depth24unorm-stencil8" feature
+  'depth24unorm-stencil8': {b: 4, c: 2, p: 1, gl: GL.DEPTH_STENCIL},
+
+  // "depth32float-stencil8" feature
+  "depth32float-stencil8": {b: 5, c: 2, p: 1, gl: GL.DEPTH32F_STENCIL8, gl2: true},
+
+  // BC compressed formats usable if "texture-compression-bc" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  'bc1-rgba-unorm': {},
+  'bc1-rgba-unorm-srgb': {},
+  'bc2-rgba-unorm': {},
+  'bc2-rgba-unorm-srgb': {},
+  'bc3-rgba-unorm': {},
+  'bc3-rgba-unorm-srgb': {},
+  'bc4-r-unorm': {},
+  'bc4-r-snorm': {},
+  'bc5-rg-unorm': {},
+  'bc5-rg-snorm': {},
+  'bc6h-rgb-ufloat': {},
+  'bc6h-rgb-float': {},
+  'bc7-rgba-unorm': {},
+  'bc7-rgba-unorm-srgb': {}
+};
+
+////////////////////////////////////////////////////
+// Compressed formats
+
+// WEBGL_compressed_texture_s3tc
+
+// {gl: GL.COMPRESSED_RGB_S3TC_DXT1_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, compressed: true, gl1: S3TC},
+
+// WEBGL_compressed_texture_es3
+
+// {gl: GL.COMPRESSED_R11_EAC, compressed: true, gl1: ES3}, // RED
+// {gl: GL.COMPRESSED_SIGNED_R11_EAC, compressed: true, gl1: ES3}, // RED
+// {gl: GL.COMPRESSED_RG11_EAC, compressed: true, gl1: ES3}, // RG
+// {gl: GL.COMPRESSED_SIGNED_RG11_EAC, compressed: true, gl1: ES3}, // RG
+// {gl: GL.COMPRESSED_RGB8_ETC2, compressed: true, gl1: ES3}, // RGB
+// {gl: GL.COMPRESSED_RGBA8_ETC2_EAC, compressed: true, gl1: ES3}, // RBG
+// {gl: GL.COMPRESSED_SRGB8_ETC2, compressed: true, gl1: ES3}, // RGB
+// {gl: GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, compressed: true, gl1: ES3}, // RGBA
+// {gl: GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, compressed: true, gl1: ES3}, // RGBA
+// {gl: GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, compressed: true, gl1: ES3}, // RGBA
+/* WebGL2 guaranteed availability compressed formats?
+COMPRESSED_R11_EAC RED
+COMPRESSED_SIGNED_R11_EAC RED
+COMPRESSED_RG11_EAC RG
+COMPRESSED_SIGNED_RG11_EAC RG
+COMPRESSED_RGB8_ETC2 RGB
+COMPRESSED_SRGB8_ETC2 RGB
+COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA
+COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA
+COMPRESSED_RGBA8_ETC2_EAC RGBA
+COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
+*/
+
+// WEBGL_compressed_texture_pvrtc
+
+// {gl: GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, compressed: true, gl1: PVRTC},
+
+// WEBGL_compressed_texture_etc1
+
+// {gl: GL.COMPRESSED_RGB_ETC1_WEBGL, compressed: true, gl1: ETC1},
+
+// WEBGL_compressed_texture_atc
+
+// {gl: GL.COMPRESSED_RGB_ATC_WEBGL, compressed: true, gl1: ETC1},
+// {gl: GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, compressed: true, gl1: ETC1},
+// {gl: GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, compressed: true, gl1: ETC1}