@luma.gl/webgl 9.1.0-alpha.15 → 9.1.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "9.1.0-alpha.15",
+  "version": "9.1.0-alpha.17",
   "description": "WebGL2 adapter for the luma.gl core API",
   "type": "module",
   "license": "MIT",
@@ -40,12 +40,12 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "peerDependencies": {
-    "@luma.gl/core": "9.1.0-alpha.14"
+    "@luma.gl/core": "9.1.0-alpha.16"
   },
   "dependencies": {
-    "@luma.gl/constants": "9.1.0-alpha.15",
+    "@luma.gl/constants": "9.1.0-alpha.17",
     "@math.gl/types": "4.1.0-alpha.3",
     "@probe.gl/env": "^4.0.8"
   },
-  "gitHead": "41af576ca655cb749a5567cf903f9e9242793c77"
+  "gitHead": "a0d4d3ddc549bbfae6e43eebc8e1afdc4da1693c"
 }

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

@@ -31,7 +31,7 @@ export function withDeviceAndGLParameters<T = unknown>(
   device: Device,
   parameters: Parameters,
   glParameters: GLParameters,
-  func: (device?: Device) => T
+  func: (_?: Device) => T
 ): T {
   if (isObjectEmpty(parameters)) {
     // Avoid setting state if no parameters provided. Just call and return
@@ -62,7 +62,7 @@ export function withDeviceAndGLParameters<T = unknown>(
 export function withGLParameters<T = unknown>(
   device: Device,
   parameters: GLParameters,
-  func: (device?: Device) => T
+  func: (_?: Device) => T
 ): T {
   if (isObjectEmpty(parameters)) {
     // Avoid setting state if no parameters provided. Just call and return
@@ -91,7 +91,7 @@ export function withGLParameters<T = unknown>(
 export function withDeviceParameters<T = unknown>(
   device: Device,
   parameters: Parameters,
-  func: (device?: Device) => T
+  func: (_?: Device) => T
 ): T {
   if (isObjectEmpty(parameters)) {
     // Avoid setting state if no parameters provided. Just call and return

package/src/adapter/converters/sampler-parameters.ts

@@ -84,7 +84,7 @@ function convertMaxFilterMode(maxFilter: 'nearest' | 'linear'): GL.NEAREST | GL.
  */
 function convertMinFilterMode(
   minFilter: 'nearest' | 'linear',
-  mipmapFilter?: 'nearest' | 'linear'
+  mipmapFilter: 'none' | 'nearest' | 'linear' = 'none'
 ):
   | GL.NEAREST
   | GL.LINEAR
@@ -95,10 +95,12 @@ function convertMinFilterMode(
   if (!mipmapFilter) {
     return convertMaxFilterMode(minFilter);
   }
-  switch (minFilter) {
+  switch (mipmapFilter) {
+    case 'none':
+      return convertMaxFilterMode(minFilter);
     case 'nearest':
-      return mipmapFilter === 'nearest' ? GL.NEAREST_MIPMAP_NEAREST : GL.NEAREST_MIPMAP_LINEAR;
+      return minFilter === 'nearest' ? GL.NEAREST_MIPMAP_NEAREST : GL.NEAREST_MIPMAP_LINEAR;
     case 'linear':
-      return mipmapFilter === 'nearest' ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR_MIPMAP_LINEAR;
+      return minFilter === 'nearest' ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR_MIPMAP_LINEAR;
   }
 }

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

@@ -73,15 +73,6 @@ export const TEXTURE_FEATURES: Partial<Record<DeviceFeature, string[]>> = {
   'texture-compression-atc-webgl': [X_ATC]
 };
 
-/** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
-// export function getTextureFeatures(
-//   gl: WebGL2RenderingContext,
-//   extensions: GLExtensions
-// ): DeviceFeature[] {
-//   const textureFeatures = Object.keys(TEXTURE_FEATURES) as DeviceFeature[];
-//   return textureFeatures.filter(feature => checkTextureFeature(gl, feature, extensions));
-// }
-
 export function isTextureFeature(feature: DeviceFeature): boolean {
   return feature in TEXTURE_FEATURES;
 }
@@ -115,10 +106,10 @@ type Format = {
   x?: string;
   /** for compressed texture formats */
   f?: DeviceFeature;
-  /** renderable if feature is present */
-  render?: DeviceFeature;
-  /** filterable if feature is present */
-  filter?: DeviceFeature;
+  /** renderable if feature is present. false means the spec does not support this format */
+  render?: DeviceFeature | false;
+  /** filterable if feature is present. false means the spec does not support this format */
+  filter?: DeviceFeature | false;
 
   /** If not supported on WebGPU */
   wgpu?: false;
@@ -201,7 +192,7 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
   // 64-bit formats
   'rg32uint': {gl: GL.RG32UI, b: 8, c: 2, rb: true},
   'rg32sint': {gl: GL.RG32I, b: 8, c: 2, rb: true},
-  'rg32float': {gl: GL.RG32F, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, rb: true},
+  'rg32float': {gl: GL.RG32F, b: 8, c: 2, render: false, filter: float32_filterable, rb: true},
   'rgba16uint': {gl: GL.RGBA16UI, b: 8, c: 4, rb: true},
   'rgba16sint': {gl: GL.RGBA16I, b: 8, c: 4, rb: true},
   'rgba16float': {gl: GL.RGBA16F, b: 8, c: 4, render: float16_renderable, filter: float16_filterable},
@@ -318,100 +309,6 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
   'atc-rgbai-unorm-webgl': {gl: GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl}
 };
 
-/** Legal combinations for internalFormat, format and type *
-// [GL.DEPTH_COMPONENT]: {types: [GL.UNSIGNED_SHORT, GL.UNSIGNED_INT, GL.UNSIGNED_INT_24_8]},
-// [GL.DEPTH_STENCIL]: ,
-// Sized texture format
-// R
-[GL.R8]: {dataFormat: GL.RED, types: [GL.UNSIGNED_BYTE], gl2: true},
-[GL.R16F]: {dataFormat: GL.RED, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
-[GL.R8UI]: {dataFormat: GL.RED_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},
-// // RG
-[GL.RG8]: {dataFormat: GL.RG, types: [GL.UNSIGNED_BYTE], gl2: true},
-[GL.RG16F]: {dataFormat: GL.RG, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
-[GL.RG8UI]: {dataFormat: GL.RG_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},
-// // RGB
-[GL.RGB8]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE], gl2: true},
-[GL.SRGB8]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE], gl2: true},
-[GL.RGB16F]: {dataFormat: GL.RGB, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
-[GL.RGB8UI]: {dataFormat: GL.RGB_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},
-// // RGBA
-
-[GL.RGB565]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_6_5], gl2: true},
-[GL.R11F_G11F_B10F]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_INT_10F_11F_11F_REV, GL.HALF_FLOAT, GL.FLOAT], gl2: true},
-[GL.RGB9_E5]: {dataFormat: GL.RGB, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
-[GL.RGBA8]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE], gl2: true},
-[GL.SRGB8_ALPHA8]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE], gl2: true, gl1ext: EXT_SRGB},
-[GL.RGB5_A1]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_5_5_1], gl2: true},
-[GL.RGBA4]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_4_4_4_4], gl2: true},
-[GL.RGBA16F]: {dataFormat: GL.RGBA, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
-[GL.RGBA8UI]: {dataFormat: GL.RGBA_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true}
-*/
-
-/* This table is now baked into the above table
-type RenderbufferFormat = {
-  bpp: number;
-  gl2?: boolean;
-  ext?: string;
-};
-
-export const RENDERBUFFER_FORMATS: Record<string, RenderbufferFormat> = {
-  [GL.DEPTH_COMPONENT16]: {bpp: 2}, // 16 depth bits.
-  // TODO - Not clear which webgpu value to map this to.
-  // [GL.DEPTH_COMPONENT24]: {gl2: true, bpp: 3},
-  [GL.DEPTH_COMPONENT32F]: {gl2: true, bpp: 4},
-
-  [GL.STENCIL_INDEX8]: {bpp: 1}, // 8 stencil bits.
-
-  [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]: {gl2: true, bpp: 2},
-  [GL.RGB565]: {gl2: true, bpp: 2},
-  [GL.RGB5_A1]: {gl2: true, 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},
-  [GL.R11F_G11F_B10F]: {ext: EXT_FLOAT_WEBGL2, bpp: 4}
-};
-*/
-
 /** @deprecated should be removed */
 const DATA_FORMAT_CHANNELS = {
   [GL.RED]: 1,
@@ -469,17 +366,25 @@ export function isTextureFormatSupported(
   return true;
 }
 
-export function isRenderbufferFormatSupported(
+/** Checks whether linear filtering (interpolated sampling) is available for floating point textures */
+export function isTextureFormatFilterable(
   gl: WebGL2RenderingContext,
   format: TextureFormat,
   extensions: GLExtensions
 ): boolean {
-  // Note: Order is important since the function call initializes extensions.
-  return isTextureFormatSupported(gl, format, extensions) && Boolean(TEXTURE_FORMATS[format]?.rb);
+  return getTextureFormatSupportWebGL(gl, format, extensions).filterable || false;
 }
 
-/** Checks if a texture format is supported */
-export function getTextureFormatSupport(
+export function isTextureFormatRenderable(
+  gl: WebGL2RenderingContext,
+  format: TextureFormat,
+  extensions: GLExtensions
+): boolean {
+  return getTextureFormatSupportWebGL(gl, format, extensions).renderable || false;
+}
+
+/** Checks if a texture format is supported, renderable, filterable etc */
+export function getTextureFormatSupportWebGL(
   gl: WebGL2RenderingContext,
   format: TextureFormat,
   extensions: GLExtensions
@@ -490,80 +395,52 @@ export function getTextureFormatSupport(
   blendable?: boolean;
   storable?: boolean;
 } {
-  const info = TEXTURE_FORMATS[format];
-  if (!info) {
+  const formatInto = decodeTextureFormat(format);
+  if (!formatInto) {
     return {supported: false};
   }
-  // let decoded;
-  // try {
-  //   decoded = decodeTextureFormat(format);
-  // } catch {}
 
-  // Support Check that we have a GL constant
-  let supported = info.gl === undefined;
-  supported = supported && checkTextureFeature(gl, info.f, extensions);
+  const webglFormatInfo = TEXTURE_FORMATS[format];
+  if (!webglFormatInfo) {
+    return {supported: false};
+  }
 
-  // Filtering
-  // const filterable = info.filter
-  //   ? checkTextureFeature(gl, infofilter])
-  //   : decoded && !decoded.signed;
-  // const renderable = info.filter
-  //   ? checkTextureFeature(gl, inforender])
-  //   : decoded && !decoded.signed;
+  // Support Check that we have a GL constant
+  let supported = webglFormatInfo.gl !== undefined;
+  supported = supported && checkTextureFeature(gl, webglFormatInfo.f, extensions);
+
+  const isDepthStencil = format.startsWith('depth') || format.startsWith('stencil');
+  const isSigned = formatInto?.signed;
+
+  const renderable =
+    supported &&
+    !isSigned &&
+    webglFormatInfo.render &&
+    checkTextureFeature(gl, webglFormatInfo.render, extensions);
+
+  const filterable =
+    supported &&
+    !isDepthStencil &&
+    !isSigned &&
+    webglFormatInfo.filter &&
+    checkTextureFeature(gl, webglFormatInfo.filter, extensions);
+
+  // if (format.endsWith('32float')) {
+  //   return Boolean(getWebGLExtension(gl, 'OES_texture_float_linear, extensions', extensions));
+  // }
+  // if (format.endsWith('16float')) {
+  //   return Boolean(getWebGLExtension(gl, 'OES_texture_half_float_linear, extensions', extensions));
+  // }
 
   return {
     supported,
-    renderable: supported && checkTextureFeature(gl, info.render, extensions),
-    filterable: supported && checkTextureFeature(gl, info.filter, extensions),
-    blendable: false, // tod,
-    storable: false
+    renderable,
+    filterable,
+    blendable: false, // TODO,
+    storable: false // TODO
   };
 }
 
-/** Checks whether linear filtering (interpolated sampling) is available for floating point textures */
-export function isTextureFormatFilterable(
-  gl: WebGL2RenderingContext,
-  format: TextureFormat,
-  extensions: GLExtensions
-): boolean {
-  if (!isTextureFormatSupported(gl, format, extensions)) {
-    return false;
-  }
-  if (format.startsWith('depth') || format.startsWith('stencil')) {
-    return false;
-  }
-  try {
-    const decoded = decodeTextureFormat(format);
-    if (decoded.signed) {
-      return false;
-    }
-  } catch {
-    return false;
-  }
-  if (format.endsWith('32float')) {
-    return Boolean(getWebGLExtension(gl, 'OES_texture_float_linear, extensions', extensions));
-  }
-  if (format.endsWith('16float')) {
-    return Boolean(getWebGLExtension(gl, 'OES_texture_half_float_linear, extensions', extensions));
-  }
-  return true;
-}
-
-export function isTextureFormatRenderable(
-  gl: WebGL2RenderingContext,
-  format: TextureFormat,
-  extensions: GLExtensions
-): boolean {
-  if (!isTextureFormatSupported(gl, format, extensions)) {
-    return false;
-  }
-  if (typeof format === 'number') {
-    return false; // isTextureFormatFilterableWebGL(gl, format);
-  }
-  // TODO depends on device...
-  return true;
-}
-
 /** Get parameters necessary to work with format in WebGL: internalFormat, dataFormat, type, compressed, */
 export function getTextureFormatWebGL(format: TextureFormat): {
   internalFormat: GL;
@@ -642,6 +519,29 @@ function convertTextureFormatToGL(format: TextureFormat): GL | undefined {
   return webglFormat;
 }
 
+// LEGACY CODE
+// TODO - remove when confident in above implementation
+
+/** luma.gl v9 does not user renderbufers 
+export function isRenderbufferFormatSupported(
+  gl: WebGL2RenderingContext,
+  format: TextureFormat,
+  extensions: GLExtensions
+): boolean {
+  // Note: Order is important since the function call initializes extensions.
+  return isTextureFormatSupported(gl, format, extensions) && Boolean(TEXTURE_FORMATS[format]?.rb);
+}
+*/
+
+/** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
+// export function getTextureFeatures(
+//   gl: WebGL2RenderingContext,
+//   extensions: GLExtensions
+// ): DeviceFeature[] {
+//   const textureFeatures = Object.keys(TEXTURE_FEATURES) as DeviceFeature[];
+//   return textureFeatures.filter(feature => checkTextureFeature(gl, feature, extensions));
+// }
+
 /**
  * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
 export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat {
@@ -655,3 +555,97 @@ export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFor
   return entry[0] as TextureFormat;
 }
  */
+
+/** Legal combinations for internalFormat, format and type *
+// [GL.DEPTH_COMPONENT]: {types: [GL.UNSIGNED_SHORT, GL.UNSIGNED_INT, GL.UNSIGNED_INT_24_8]},
+// [GL.DEPTH_STENCIL]: ,
+// Sized texture format
+// R
+[GL.R8]: {dataFormat: GL.RED, types: [GL.UNSIGNED_BYTE], gl2: true},
+[GL.R16F]: {dataFormat: GL.RED, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
+[GL.R8UI]: {dataFormat: GL.RED_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},
+// // RG
+[GL.RG8]: {dataFormat: GL.RG, types: [GL.UNSIGNED_BYTE], gl2: true},
+[GL.RG16F]: {dataFormat: GL.RG, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
+[GL.RG8UI]: {dataFormat: GL.RG_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},
+// // RGB
+[GL.RGB8]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE], gl2: true},
+[GL.SRGB8]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE], gl2: true},
+[GL.RGB16F]: {dataFormat: GL.RGB, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
+[GL.RGB8UI]: {dataFormat: GL.RGB_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},
+// // RGBA
+
+[GL.RGB565]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_6_5], gl2: true},
+[GL.R11F_G11F_B10F]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_INT_10F_11F_11F_REV, GL.HALF_FLOAT, GL.FLOAT], gl2: true},
+[GL.RGB9_E5]: {dataFormat: GL.RGB, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
+[GL.RGBA8]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE], gl2: true},
+[GL.SRGB8_ALPHA8]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE], gl2: true, gl1ext: EXT_SRGB},
+[GL.RGB5_A1]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_5_5_1], gl2: true},
+[GL.RGBA4]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_4_4_4_4], gl2: true},
+[GL.RGBA16F]: {dataFormat: GL.RGBA, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},
+[GL.RGBA8UI]: {dataFormat: GL.RGBA_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true}
+*/
+
+/* This table is now baked into the above table
+type RenderbufferFormat = {
+  bpp: number;
+  gl2?: boolean;
+  ext?: string;
+};
+
+export const RENDERBUFFER_FORMATS: Record<string, RenderbufferFormat> = {
+  [GL.DEPTH_COMPONENT16]: {bpp: 2}, // 16 depth bits.
+  // TODO - Not clear which webgpu value to map this to.
+  // [GL.DEPTH_COMPONENT24]: {gl2: true, bpp: 3},
+  [GL.DEPTH_COMPONENT32F]: {gl2: true, bpp: 4},
+
+  [GL.STENCIL_INDEX8]: {bpp: 1}, // 8 stencil bits.
+
+  [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]: {gl2: true, bpp: 2},
+  [GL.RGB565]: {gl2: true, bpp: 2},
+  [GL.RGB5_A1]: {gl2: true, 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},
+  [GL.R11F_G11F_B10F]: {ext: EXT_FLOAT_WEBGL2, bpp: 4}
+};
+*/

package/src/adapter/helpers/format-utils.ts

@@ -10,14 +10,20 @@ export function glFormatToComponents(format) {
     case GL.ALPHA:
     case GL.R32F:
     case GL.RED:
+    case GL.RED_INTEGER:
       return 1;
+    case GL.RG32I:
+    case GL.RG32UI:
     case GL.RG32F:
+    case GL.RG_INTEGER:
     case GL.RG:
       return 2;
     case GL.RGB:
+    case GL.RGB_INTEGER:
     case GL.RGB32F:
       return 3;
     case GL.RGBA:
+    case GL.RGBA_INTEGER:
     case GL.RGBA32F:
       return 4;
     // TODO: Add support for additional WebGL2 formats