@luma.gl/webgl 9.0.0-alpha.21 → 9.0.0-alpha.24

package/src/classic/copy-and-blit.ts

@@ -0,0 +1,189 @@
+// luma.gl, MIT license
+import {assert, Texture, Framebuffer, FramebufferProps} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+
+import {ClassicBuffer as Buffer} from './buffer';
+import {WEBGLTexture}  from  '../adapter/resources/webgl-texture';
+import {WEBGLFramebuffer} from '../adapter/resources/webgl-framebuffer';
+import {withParameters} from '../context/state-tracker/with-parameters';
+import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from './typed-array-utils';
+import {glFormatToComponents, glTypeToBytes} from './format-utils';
+
+/**
+ * Copies data from a type  or a Texture object into ArrayBuffer object.
+ * App can provide targetPixelArray or have it auto allocated by this method
+ *  newly allocated by this method unless provided by app.
+ * @deprecated Use CommandEncoder.copyTextureToBuffer and Buffer.read
+ * @note Slow requires roundtrip to GPU
+ *
+ * @param source
+ * @param options
+ * @returns pixel array,
+ */
+export function readPixelsToArray(
+  source: Framebuffer | Texture,
+  options?: {
+    sourceX?: number;
+    sourceY?: number;
+    sourceFormat?: number;
+    sourceAttachment?: number;
+    target?: Uint8Array | Uint16Array | Float32Array;
+    // following parameters are auto deduced if not provided
+    sourceWidth?: number;
+    sourceHeight?: number;
+    sourceType?: number;
+  }
+): Uint8Array | Uint16Array | Float32Array {
+  const {sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA} = options || {};
+  let {
+    sourceAttachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer
+    target = null,
+    // following parameters are auto deduced if not provided
+    sourceWidth,
+    sourceHeight,
+    sourceType
+  } = options || {};
+
+  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);
+  assert(framebuffer);
+  const {gl, handle} = framebuffer as WEBGLFramebuffer;
+  sourceWidth = sourceWidth || framebuffer.width;
+  sourceHeight = sourceHeight || framebuffer.height;
+
+  // TODO - Set and unset gl.readBuffer
+  if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {
+    sourceAttachment = GL.FRONT;
+  }
+
+  const attachment = sourceAttachment - GL.COLOR_ATTACHMENT0;
+  // assert(attachments[sourceAttachment]);
+
+  // Deduce the type from color attachment if not provided.
+  sourceType = sourceType || (framebuffer.colorAttachments[attachment] as WEBGLTexture).type;
+
+  // Deduce type and allocated pixelArray if needed
+  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
+
+  // Pixel array available, if necessary, deduce type from it.
+  sourceType = sourceType || getGLTypeFromTypedArray(target);
+
+  const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+  // @ts-expect-error
+  gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return target;
+}
+
+/**
+ * Copies data from a Framebuffer or a Texture object into a Buffer object.
+ * NOTE: doesn't wait for copy to be complete, it programs GPU to perform a DMA transffer.
+ * @param source
+ * @param options
+ */
+export function readPixelsToBuffer(
+  source: Framebuffer | Texture,
+  options?: {
+    sourceX?: number;
+    sourceY?: number;
+    sourceFormat?: number;
+    target?: Buffer; // A new Buffer object is created when not provided.
+    targetByteOffset?: number; // byte offset in buffer object
+    // following parameters are auto deduced if not provided
+    sourceWidth?: number;
+    sourceHeight?: number;
+    sourceType?: number;
+  }
+): Buffer {
+  const {sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA, targetByteOffset = 0} = options || {};
+  // following parameters are auto deduced if not provided
+  let {target, sourceWidth, sourceHeight, sourceType} = options || {};
+  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);
+  assert(framebuffer);
+  sourceWidth = sourceWidth || framebuffer.width;
+  sourceHeight = sourceHeight || framebuffer.height;
+
+  // Asynchronous read (PIXEL_PACK_BUFFER) is WebGL2 only feature
+  const webglFramebuffer = framebuffer as WEBGLFramebuffer;
+  const gl2 = webglFramebuffer.device.assertWebGL2();
+
+  // deduce type if not available.
+  sourceType = sourceType || (target ? target.type : GL.UNSIGNED_BYTE);
+
+  if (!target) {
+    // Create new buffer with enough size
+    const components = glFormatToComponents(sourceFormat);
+    const byteCount = glTypeToBytes(sourceType);
+    const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
+    target = new Buffer(gl2, {byteLength, accessor: {type: sourceType, size: components}});
+  }
+
+  // @ts-expect-error
+  target.bind({target: GL.PIXEL_PACK_BUFFER});
+  withParameters(gl2, {framebuffer}, () => {
+    gl2.readPixels(
+      sourceX,
+      sourceY,
+      sourceWidth,
+      sourceHeight,
+      sourceFormat,
+      sourceType,
+      targetByteOffset
+    );
+  });
+  target.unbind({target: GL.PIXEL_PACK_BUFFER});
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+
+  return target;
+}
+
+function getFramebuffer(source: Texture | Framebuffer): {
+  framebuffer: Framebuffer;
+  deleteFramebuffer: boolean;
+} {
+  if (!(source instanceof Framebuffer)) {
+    return {framebuffer: toFramebuffer(source), deleteFramebuffer: true};
+  }
+  return {framebuffer: source, deleteFramebuffer: false};
+}
+
+/**
+ * Wraps a given texture into a framebuffer object, that can be further used
+ * to read data from the texture object.
+ */
+export function toFramebuffer(texture: Texture, props?: FramebufferProps): Framebuffer {
+  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: number,
+  height: number
+): Uint8Array | Uint16Array | Float32Array {
+  if (pixelArray) {
+    return pixelArray;
+  }
+  // Allocate pixel array if not already available, using supplied type
+  type = type || GL.UNSIGNED_BYTE;
+  const ArrayType = getTypedArrayFromGLType(type, {clamped: false});
+  const components = glFormatToComponents(format);
+  // TODO - check for composite type (components = 1).
+  return new ArrayType(width * height * components) as Uint8Array | Uint16Array | Float32Array;
+}

package/src/classic/format-utils.ts

@@ -0,0 +1,43 @@
+import {assert} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+
+// Returns number of components in a specific readPixels WebGL format
+export function glFormatToComponents(format) {
+  switch (format) {
+    case GL.ALPHA:
+    case GL.R32F:
+    case GL.RED:
+      return 1;
+    case GL.RG32F:
+    case GL.RG:
+      return 2;
+    case GL.RGB:
+    case GL.RGB32F:
+      return 3;
+    case GL.RGBA:
+    case GL.RGBA32F:
+      return 4;
+    // TODO: Add support for additional WebGL2 formats
+    default:
+      assert(false);
+      return 0;
+  }
+}
+
+// Return byte count for given readPixels WebGL type
+export function glTypeToBytes(type) {
+  switch (type) {
+    case GL.UNSIGNED_BYTE:
+      return 1;
+    case GL.UNSIGNED_SHORT_5_6_5:
+    case GL.UNSIGNED_SHORT_4_4_4_4:
+    case GL.UNSIGNED_SHORT_5_5_5_1:
+      return 2;
+    case GL.FLOAT:
+      return 4;
+    // TODO: Add support for additional WebGL2 types
+    default:
+      assert(false);
+      return 0;
+  }
+}

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

@@ -1,28 +1,17 @@
 // luma.gl, MIT license
 
-import {TypedArray} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {GLType} from '../types/webgl'
+import {TypedArray, TypedArrayConstructor} from '@luma.gl/api';
+import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';
 
 const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
 
-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
+ * @param arrayOrType
  * @returns
  */
-export function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLType {
+export function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLDataType {
   // If typed array, look up constructor
   const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
   switch (type) {
@@ -50,13 +39,13 @@ export function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLType {
 /**
  * Converts GL constant to corresponding TYPED ARRAY
  * Used to auto deduce gl parameter types
- * @param {*} glType
- * @param {*} param1
+ * @param glType
+ * @param param1
  * @returns
  */
 // eslint-disable-next-line complexity
 export function getTypedArrayFromGLType(
-  glType: any,
+  glType: GLDataType | GLPixelType,
   options?: {
     clamped?: boolean;
   }
@@ -90,14 +79,14 @@ export function getTypedArrayFromGLType(
  * 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 function flipRows(options: {
-  data: any;
-  width: any;
-  height: any;
+  data: TypedArray;
+  width: number;
+  height: number;
   bytesPerPixel?: number;
-  temp?: any;
+  temp?: Uint8Array;
 }): void {
   const {data, width, height, bytesPerPixel = 4, temp} = options;
   const bytesPerRow = width * bytesPerPixel;
@@ -118,9 +107,9 @@ export function flipRows(options: {
 
 
 export function scalePixels(options: {
-  data: any;
-  width: any;
-  height: any;
+  data: TypedArray;
+  width: number;
+  height: number;
 }): {
   data: Uint8Array;
   width: number;

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

@@ -2,21 +2,21 @@
 
 /**
  * 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.
-*/
+ * @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;
@@ -27,10 +27,10 @@ type ContextProps = {
   desynchronized?: boolean; // hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop
   antialias?: boolean; // indicates whether or not to perform anti-aliasing.
   depth?: boolean; // indicates that the drawing buffer has a depth buffer of at least 16 bits.
-  failIfMajorPerformanceCaveat?: boolean, // indicates if a context will be created if the system performance is low or if no hardware GPU is available.
-  powerPreference?: 'default' |  'high-performance' | 'low-power',
-  premultipliedAlpha?: boolean, // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.
-  preserveDrawingBuffer?: boolean // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.
+  failIfMajorPerformanceCaveat?: boolean; // indicates if a context will be created if the system performance is low or if no hardware GPU is available.
+  powerPreference?: 'default' | 'high-performance' | 'low-power';
+  premultipliedAlpha?: boolean; // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.
+  preserveDrawingBuffer?: boolean; // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.
 };
 
 const DEFAULT_CONTEXT_PROPS: ContextProps = {
@@ -40,24 +40,27 @@ const DEFAULT_CONTEXT_PROPS: ContextProps = {
   // eslint-disable-next-line no-console
   onContextLost: () => console.error('WebGL context lost'),
   // eslint-disable-next-line no-console
-  onContextRestored: () => console.info('WebGL context restored'),
+  onContextRestored: () => console.info('WebGL context restored')
 };
 
 /**
  * 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 function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGLRenderingContext {
+export function createBrowserContext(
+  canvas: HTMLCanvasElement | OffscreenCanvas,
+  props: ContextProps
+): WebGLRenderingContext {
   props = {...DEFAULT_CONTEXT_PROPS, ...props};
 
   // Try to extract any extra information about why context creation failed
   let errorMessage = null;
-  const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);
+  const onCreateError = error => (errorMessage = error.statusMessage || errorMessage);
   canvas.addEventListener('webglcontextcreationerror', onCreateError, false);
 
   // Create the desired context
-  let gl: WebGLRenderingContext | null = null;
+  let gl: WebGLRenderingContext | WebGL2RenderingContext | null = null;
 
   if (props.type === 'webgl2') {
     props = {...props, webgl1: false};
@@ -67,11 +70,11 @@ export function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas
   }
 
   // Prefer webgl2 over webgl1 if both are acceptable
-  if (props.webgl2) {
-    gl = gl || canvas.getContext('webgl2', props) as WebGL2RenderingContext | null;
+  if (!gl && props.webgl2) {
+    gl = canvas.getContext('webgl2', props) as WebGL2RenderingContext;
   }
-  if (props.webgl1) {
-    gl = gl || canvas.getContext('webgl', props) as WebGLRenderingContext | null;
+  if (!gl && props.webgl1) {
+    gl = canvas.getContext('webgl', props) as WebGLRenderingContext;
   }
 
   // TODO are we removing this listener before giving it a chance to fire?
@@ -88,12 +91,16 @@ export function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas
   if (props.onContextLost) {
     // Carefully extract and wrap callbacks to prevent addEventListener from rebinding them.
     const {onContextLost} = props;
-    canvas.addEventListener('webglcontextlost',(event: Event) => onContextLost(event), false);
+    canvas.addEventListener('webglcontextlost', (event: Event) => onContextLost(event), false);
   }
   if (props.onContextRestored) {
     // Carefully extract and wrap callbacks to prevent addEventListener from rebinding them.
     const {onContextRestored} = props;
-    canvas.addEventListener('webglcontextrestored', (event: Event) => onContextRestored(event), false);
+    canvas.addEventListener(
+      'webglcontextrestored',
+      (event: Event) => onContextRestored(event),
+      false
+    );
   }
 
   return gl;

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

@@ -2,7 +2,7 @@
 // Also knows default values of all parameters, enabling fast cache initialization
 // Provides base functionality for the state caching.
 import {Device} from '@luma.gl/api';
-import type {GLParameters} from '../../types/webgl';
+import type {GLParameters} from '@luma.gl/constants';
 import {
   GL_PARAMETER_DEFAULTS,
   GL_PARAMETER_SETTERS,

package/src/context/parameters/webgl-parameter-tables.ts

@@ -1,7 +1,7 @@
 // Tables describing WebGL parameters
-import GL from '@luma.gl/constants';
+import {GL, GLParameters} from '@luma.gl/constants';
 import {isWebGL2} from '../context/webgl-checks';
-import type {GLParameters} from '../../types/webgl';
+
 // DEFAULT SETTINGS - FOR FAST CACHE INITIALIZATION AND CONTEXT RESETS
 
 /* eslint-disable no-shadow */

package/src/index.ts

@@ -33,7 +33,7 @@ export type {RenderbufferProps} from './adapter/objects/webgl-renderbuffer';
 export {WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
 export {WEBGLVertexArrayObject} from './adapter/objects/webgl-vertex-array-object';
 
-// WebGL adapter classes (Legacy, will be moved to gltools)
+// WebGL adapter classes (Legacy, will be moved to webgl-legacy)
 export {Accessor} from './classic/accessor';
 export type {AccessorObject} from './types';
 export type {ClassicBufferProps, ClassicBufferProps as BufferProps} from './classic/buffer';
@@ -51,7 +51,7 @@ export {
 
 export {setDeviceParameters, withDeviceParameters} from './adapter/converters/device-parameters';
 
-export type {GLParameters} from './types/webgl';
+export type {GLParameters} from '@luma.gl/constants';
 export {
   getParameters,
   setParameters,
@@ -74,4 +74,11 @@ export {polyfillContext} from './context/polyfill/polyfill-context';
 
 // HELPERS - EXPERIMENTAL
 export {getShaderLayout, getProgramBindings} from './adapter/helpers/get-shader-layout';
-export {_checkFloat32ColorAttachment} from './adapter/converters/texture-formats';
+export {convertGLToTextureFormat, _checkFloat32ColorAttachment} from './adapter/converters/texture-formats';
+
+// TEST EXPORTS
+export {TEXTURE_FORMATS as _TEXTURE_FORMATS} from './adapter/converters/texture-formats';
+
+// DEPRECATED EXPORTS
+export {clear} from './classic/clear';
+export {readPixelsToBuffer, readPixelsToArray} from './classic/copy-and-blit';

package/dist/adapter/converters/renderbuffer-formats.d.ts

@@ -1,16 +0,0 @@
-import GL from '@luma.gl/constants';
-export declare function isRenderbufferFormatSupported(gl: WebGLRenderingContext, format: GL): boolean;
-export declare function getRenderbufferFormatBytesPerPixel(format: GL): number;
-/**
- * @param bpp "bytes per pixel", used for memory usage calculations.
- * @param gl2 requires WebGL2
- * @param ext requires extension
- */
-declare type RenderbufferFormat = {
-    bpp: number;
-    gl2?: boolean;
-    ext?: string;
-};
-export declare const RENDERBUFFER_FORMATS: Record<string, RenderbufferFormat>;
-export {};
-//# sourceMappingURL=renderbuffer-formats.d.ts.map

package/dist/adapter/converters/renderbuffer-formats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"renderbuffer-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/renderbuffer-formats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGpC,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,qBAAqB,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAa5F;AAED,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,EAAE,GAAG,MAAM,CAErE;AAKD;;;;GAIG;AACH,aAAK,kBAAkB,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAqDnE,CAAC"}

package/dist/adapter/converters/renderbuffer-formats.js

@@ -1,180 +0,0 @@
-import GL from '@luma.gl/constants';
-import { isWebGL2 } from "../../context/context/webgl-checks.js";
-export function isRenderbufferFormatSupported(gl, format) {
-  const info = RENDERBUFFER_FORMATS[format];
-  if (!info) {
-    return false;
-  }
-  if (info.ext) {
-    return Boolean(gl.getExtension(info.ext));
-  }
-  if (info.gl2) {
-    return isWebGL2(gl);
-  }
-  return true;
-}
-export function getRenderbufferFormatBytesPerPixel(format) {
-  return RENDERBUFFER_FORMATS[format].bpp;
-}
-const EXT_FLOAT_WEBGL2 = 'EXT_color_buffer_float';
-export const RENDERBUFFER_FORMATS = {
-  [GL.DEPTH_COMPONENT16]: {
-    bpp: 2
-  },
-  [GL.DEPTH_COMPONENT24]: {
-    gl2: true,
-    bpp: 3
-  },
-  [GL.DEPTH_COMPONENT32F]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.STENCIL_INDEX8]: {
-    bpp: 1
-  },
-  [GL.DEPTH_STENCIL]: {
-    bpp: 4
-  },
-  [GL.DEPTH24_STENCIL8]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.DEPTH32F_STENCIL8]: {
-    gl2: true,
-    bpp: 5
-  },
-  [GL.RGBA4]: {
-    bpp: 2
-  },
-  [GL.RGB565]: {
-    bpp: 2
-  },
-  [GL.RGB5_A1]: {
-    bpp: 2
-  },
-  [GL.R8]: {
-    gl2: true,
-    bpp: 1
-  },
-  [GL.R8UI]: {
-    gl2: true,
-    bpp: 1
-  },
-  [GL.R8I]: {
-    gl2: true,
-    bpp: 1
-  },
-  [GL.R16UI]: {
-    gl2: true,
-    bpp: 2
-  },
-  [GL.R16I]: {
-    gl2: true,
-    bpp: 2
-  },
-  [GL.R32UI]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.R32I]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RG8]: {
-    gl2: true,
-    bpp: 2
-  },
-  [GL.RG8UI]: {
-    gl2: true,
-    bpp: 2
-  },
-  [GL.RG8I]: {
-    gl2: true,
-    bpp: 2
-  },
-  [GL.RG16UI]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RG16I]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RG32UI]: {
-    gl2: true,
-    bpp: 8
-  },
-  [GL.RG32I]: {
-    gl2: true,
-    bpp: 8
-  },
-  [GL.RGB8]: {
-    gl2: true,
-    bpp: 3
-  },
-  [GL.RGBA8]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RGB10_A2]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RGBA8UI]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RGBA8I]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RGB10_A2UI]: {
-    gl2: true,
-    bpp: 4
-  },
-  [GL.RGBA16UI]: {
-    gl2: true,
-    bpp: 8
-  },
-  [GL.RGBA16I]: {
-    gl2: true,
-    bpp: 8
-  },
-  [GL.RGBA32I]: {
-    gl2: true,
-    bpp: 16
-  },
-  [GL.RGBA32UI]: {
-    gl2: true,
-    bpp: 16
-  },
-  [GL.R16F]: {
-    ext: EXT_FLOAT_WEBGL2,
-    bpp: 2
-  },
-  [GL.RG16F]: {
-    ext: EXT_FLOAT_WEBGL2,
-    bpp: 4
-  },
-  [GL.RGBA16F]: {
-    ext: EXT_FLOAT_WEBGL2,
-    bpp: 8
-  },
-  [GL.R32F]: {
-    ext: EXT_FLOAT_WEBGL2,
-    bpp: 4
-  },
-  [GL.RG32F]: {
-    ext: EXT_FLOAT_WEBGL2,
-    bpp: 8
-  },
-  [GL.RGBA32F]: {
-    ext: EXT_FLOAT_WEBGL2,
-    bpp: 16
-  },
-  [GL.R11F_G11F_B10F]: {
-    ext: EXT_FLOAT_WEBGL2,
-    bpp: 4
-  }
-};
-//# sourceMappingURL=renderbuffer-formats.js.map