@luma.gl/webgl 9.0.0-alpha.15 → 9.0.0-alpha.16

package/dist/adapter/converters/device-parameters.js

@@ -1,157 +1,220 @@
 import { log, isObjectEmpty } from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import { pushContextState, popContextState } from '../../context/state-tracker/track-context-state';
-import { setParameters } from '../../context/parameters/unified-parameter-api';
-import WebGLDevice from '../webgl-device';
+import { pushContextState, popContextState } from '../../context/state-tracker/track-context-state.js';
+import { setParameters } from '../../context/parameters/unified-parameter-api.js';
+import WebGLDevice from '../webgl-device.js';
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ * @deprecated use withDeviceParameters instead
+ */
 export function withGLParameters(device, parameters, func) {
-  if (isObjectEmpty(parameters)) {
-    return func(device);
-  }
-
-  pushContextState(device.gl);
-
-  try {
-    setParameters(device, parameters);
-    return func(device);
-  } finally {
-    popContextState(device.gl);
-  }
+    if (isObjectEmpty(parameters)) {
+        // Avoid setting state if no parameters provided. Just call and return
+        return func(device);
+    }
+    // Wrap in a try-catch to ensure that parameters are restored on exceptions
+    // @ts-expect-error
+    pushContextState(device.gl);
+    try {
+        setParameters(device, parameters);
+        return func(device);
+    }
+    finally {
+        // @ts-expect-error
+        popContextState(device.gl);
+    }
 }
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ */
 export function withDeviceParameters(device, parameters, func) {
-  if (isObjectEmpty(parameters)) {
-    return func(device);
-  }
-
-  pushContextState(device.gl);
-
-  try {
-    setDeviceParameters(device, parameters);
-    return func(device);
-  } finally {
-    popContextState(device.gl);
-  }
+    if (isObjectEmpty(parameters)) {
+        // Avoid setting state if no parameters provided. Just call and return
+        return func(device);
+    }
+    // Wrap in a try-catch to ensure that parameters are restored on exceptions
+    // @ts-expect-error
+    pushContextState(device.gl);
+    try {
+        setDeviceParameters(device, parameters);
+        return func(device);
+    }
+    finally {
+        // @ts-expect-error
+        popContextState(device.gl);
+    }
 }
+/** Set WebGPU Style Parameters */
 export function setDeviceParameters(device, parameters) {
-  const webglDevice = WebGLDevice.attach(device);
-  const {
-    gl
-  } = webglDevice;
-
-  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;
+    const webglDevice = WebGLDevice.attach(device);
+    const { gl } = 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);
-  }
-
-  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) {
-    log.warn('stencilReadMask not supported under WebGL');
-  }
-
-  if (parameters.stencilCompare) {
-    const mask = parameters.stencilReadMask || 0xffffffff;
-    const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);
-    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 && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
-    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);
-  }
+    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 && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
+        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) {
-  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
-  });
+    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
+    });
 }
 export function convertToCompareFunction(parameter, value) {
-  return map(parameter, value, {
-    [GL.NEVER]: 'never',
-    [GL.LESS]: 'less',
-    [GL.EQUAL]: 'equal',
-    [GL.LEQUAL]: 'less-equal',
-    [GL.GREATER]: 'greater',
-    [GL.NOTEQUAL]: 'not-equal',
-    [GL.GEQUAL]: 'greater-equal',
-    [GL.ALWAYS]: 'always'
-  });
+    return map(parameter, value, {
+        [GL.NEVER]: 'never',
+        [GL.LESS]: 'less',
+        [GL.EQUAL]: 'equal',
+        [GL.LEQUAL]: 'less-equal',
+        [GL.GREATER]: 'greater',
+        [GL.NOTEQUAL]: 'not-equal',
+        [GL.GEQUAL]: 'greater-equal',
+        [GL.ALWAYS]: 'always'
+    });
 }
-
 function convertStencilOperation(parameter, value) {
-  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
-  });
+    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: string, value: string): 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 ".concat(value, " for ").concat(parameter);
+    return `Illegal parameter ${value} for ${parameter}`;
 }
-
 function map(parameter, value, valueMap) {
-  if (!(value in valueMap)) {
-    throw new Error(message(parameter, value));
-  }
-
-  return valueMap[value];
+    if (!(value in valueMap)) {
+        throw new Error(message(parameter, value));
+    }
+    return valueMap[value];
 }
-
 function mapBoolean(parameter, value) {
-  return value;
+    return value;
 }
-//# sourceMappingURL=device-parameters.js.map

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

@@ -6,7 +6,7 @@ export declare function getRenderbufferFormatBytesPerPixel(format: GL): number;
  * @param gl2 requires WebGL2
  * @param ext requires extension
  */
-declare type RenderbufferFormat = {
+type RenderbufferFormat = {
     bpp: number;
     gl2?: boolean;
     ext?: string;

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

@@ -1 +1 @@
-{"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,QAAA,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAqD5D,CAAC;AAEF,eAAe,oBAAoB,CAAC"}
+{"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,KAAK,kBAAkB,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,QAAA,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAqD5D,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

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

@@ -1,185 +1,71 @@
 import GL from '@luma.gl/constants';
-import { isWebGL2 } from '../../context/context/webgl-checks';
+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;
+    const info = RENDERBUFFER_FORMATS[format];
+    // Unknown 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;
+    return RENDERBUFFER_FORMATS[format].bpp;
 }
+// Define local extension strings to optimize minification
 const EXT_FLOAT_WEBGL2 = 'EXT_color_buffer_float';
 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
-  }
+    [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 },
+    // When using a WebGL 1 context, color renderbuffer formats are limited
+    [GL.RGBA4]: { bpp: 2 },
+    [GL.RGB565]: { bpp: 2 },
+    [GL.RGB5_A1]: { bpp: 2 },
+    // When using a WebGL 2 context, the following values are available additionally:
+    [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.SRGB8_ALPHA8]: {gl2: true, gl1: SRGB}, // When using the EXT_sRGB WebGL1 extension
+    [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 },
+    // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
+    [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 },
+    // TODO - can't get WEBGL_color_buffer_float to work on renderbuffers
+    [GL.RGBA32F]: { ext: EXT_FLOAT_WEBGL2, bpp: 16 },
+    // [GL.RGBA32F]: {ext: EXT_FLOAT_WEBGL2, gl1: EXT_FLOAT_WEBGL1},
+    [GL.R11F_G11F_B10F]: { ext: EXT_FLOAT_WEBGL2, bpp: 4 }
 };
 export default RENDERBUFFER_FORMATS;
-//# sourceMappingURL=renderbuffer-formats.js.map