@luma.gl/webgl 9.0.0-beta.4 → 9.0.0-beta.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "9.0.0-beta.4",
-  "description": "WebGL2 adapter for the luma.gl API",
+  "version": "9.0.0-beta.5",
+  "description": "WebGL2 adapter for the luma.gl core API",
   "type": "module",
   "license": "MIT",
   "publishConfig": {
@@ -34,22 +34,18 @@
     "README.md"
   ],
   "sideEffects": false,
-  "browser": {
-    "gl": false,
-    "gl/wrap": false
-  },
   "scripts": {
-    "build-bundle": "ocular-bundle ./src/index.ts",
-    "pre-build": "npm run build-bundle && npm run build-bundle -- --env=dev"
+    "build-minified-bundle": "ocular-bundle ./src/index.ts -output=dist/dist.min.js",
+    "build-dev-bundle": "ocular-bundle ./src/index.ts -output=dist/dist.dev.js -- --env=dev",
+    "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
+  },
+  "peerDependencies": {
+    "@luma.gl/constants": "^9.0.0-beta.4"
   },
   "dependencies": {
-    "@babel/runtime": "^7.0.0",
-    "@luma.gl/constants": "9.0.0-beta.4",
-    "@luma.gl/core": "9.0.0-beta.4",
+    "@luma.gl/constants": "9.0.0-beta.5",
+    "@luma.gl/core": "9.0.0-beta.5",
     "@probe.gl/env": "^4.0.2"
   },
-  "devDependencies": {
-    "@luma.gl/test-utils": "9.0.0-beta.4"
-  },
-  "gitHead": "bf6bb45b25d59de5b3d05dab4b2e91ad583059e6"
+  "gitHead": "793d3ab42f5a572b6cb603ea78aabaa73a873301"
 }

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

@@ -291,7 +291,6 @@ function convertBlendOperationToEquation(parameter: string, value: BlendOperatio
     'add': GL.FUNC_ADD,
     'subtract': 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
   } as Record<BlendOperation, GLBlendEquation>);

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

@@ -52,23 +52,6 @@ export function convertSamplerParametersToWebGL(props: SamplerProps): GLSamplerP
   return params;
 }
 
-/**
- * Override sampler settings that are not supported by Non-Power-of-Two textures in WebGL1.
- */
-export function updateSamplerParametersForNPOT(
-  parameters: GLSamplerParameters
-): GLSamplerParameters {
-  const newParameters = {...parameters};
-  if (parameters[GL.TEXTURE_MIN_FILTER] !== GL.NEAREST) {
-    // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_MIN_FILTER to LINEAR`)();
-    newParameters[GL.TEXTURE_MIN_FILTER] = GL.LINEAR;
-  }
-  // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_WRAP_S to CLAMP_TO_EDGE`)();
-  newParameters[GL.TEXTURE_WRAP_S] = GL.CLAMP_TO_EDGE;
-  newParameters[GL.TEXTURE_WRAP_T] = GL.CLAMP_TO_EDGE;
-  return newParameters;
-}
-
 // HELPERS
 
 /** Convert address more */

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

@@ -4,8 +4,7 @@
 import type {TextureFormat, DeviceFeature} from '@luma.gl/core';
 import {decodeTextureFormat} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
-import {isWebGL2} from '../../context/context/webgl-checks';
-import { getGLFromVertexType } from './vertex-formats';
+import {getGLFromVertexType} from './vertex-formats';
 
 /* eslint-disable camelcase */
 
@@ -19,6 +18,9 @@ const texture_compression_etc1_webgl: DeviceFeature = 'texture-compression-etc1-
 const texture_compression_pvrtc_webgl: DeviceFeature = 'texture-compression-pvrtc-webgl';
 const texture_compression_atc_webgl: DeviceFeature = 'texture-compression-atc-webgl';
 
+// const float32_renderable_webgl: DeviceFeature = 'float32-renderable-webgl';
+// const float16_renderable_webgl: DeviceFeature = 'float16-renderable-webgl';
+
 // Define local webgl extension strings to optimize minification
 const X_S3TC = 'WEBGL_compressed_texture_s3tc'; // BC1, BC2, BC3
 const X_S3TC_SRGB = 'WEBGL_compressed_texture_s3tc_srgb'; // BC1, BC2, BC3
@@ -31,53 +33,49 @@ const X_PVRTC = 'WEBGL_compressed_texture_pvrtc';
 const X_ATC = 'WEBGL_compressed_texture_atc';
 
 // Define local webgl extension strings to optimize minification
-const EXT_SRGB = 'EXT_sRGB'; // https://developer.mozilla.org/en-US/docs/Web/API/EXT_sRGB
 const EXT_TEXTURE_NORM16 = 'EXT_texture_norm16';
-const EXT_FLOAT_WEBGL1 = 'WEBGL_color_buffer_float';
 const EXT_FLOAT_RENDER_WEBGL2 = 'EXT_color_buffer_float';
 // const EXT_HALF_FLOAT_WEBGL1 = 'EXT_color_buffer_half_float';
 // const DEPTH = 'WEBGL_depth_texture';
 
-const checkExtension = (gl: WebGLRenderingContext, extension: string): boolean =>
-  gl.getExtension(extension);
-const checkExtensions = (gl: WebGLRenderingContext, extensions: string[]): boolean =>
-  extensions.every(extension => gl.getExtension(extension));
+// WebGL1-only extensions
+// const EXT_SRGB = 'EXT_sRGB'; // https://developer.mozilla.org/en-US/docs/Web/API/EXT_sRGB
 
 // prettier-ignore
-const TEXTURE_FEATURE_CHECKS: Partial<Record<DeviceFeature, (gl: WebGLRenderingContext) => boolean> > = {
-  'texture-blend-float-webgl1': (gl) => isWebGL2(gl) ? true : checkExtension(gl, 'EXT_float_blend'),
-  'texture-formats-srgb-webgl1': (gl) => (isWebGL2(gl) ? true : checkExtension(gl, EXT_SRGB)),
-  'texture-formats-depth-webgl1': (gl) => isWebGL2(gl) ? true : checkExtension(gl, 'WEBGL_depth_texture'),
-  'texture-formats-float32-webgl1': (gl) => isWebGL2(gl) ? true : checkExtension(gl, 'OES_texture_float'),
-  'texture-formats-float16-webgl1': (gl) => isWebGL2(gl) ? true : checkExtension(gl, 'OES_texture_half_float'),
-  'texture-formats-norm16-webgl': (gl) => isWebGL2(gl) ? checkExtension(gl, EXT_TEXTURE_NORM16) : false,
-  'texture-filter-linear-float32-webgl': (gl) => checkExtension(gl, 'OES_texture_float_linear'),
-  'texture-filter-linear-float16-webgl': (gl) => checkExtension(gl, 'OES_texture_half_float_linear'),
-  'texture-filter-anisotropic-webgl': (gl) => checkExtension(gl, 'EXT_texture_filter_anisotropic'),
-  'texture-renderable-float32-webgl': (gl) => checkExtension(gl, 'EXT_color_buffer_float'), // [false, 'EXT_color_buffer_float'],
-  'texture-renderable-float16-webgl': (gl) => checkExtension(gl, 'EXT_color_buffer_half_float'),
-
-  'texture-compression-bc': (gl) => checkExtensions(gl, [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC]),
-  'texture-compression-bc5-webgl': (gl) => checkExtensions(gl, [X_RGTC]),
-  // 'texture-compression-bc7-webgl': gl => checkExtensions(gl, [X_BPTC]),
-  // 'texture-compression-bc3-srgb-webgl': gl => checkExtensions(gl, [X_S3TC_SRGB]),
-  // 'texture-compression-bc3-webgl': gl => checkExtensions(gl, [X_S3TC]),
-  'texture-compression-etc2': (gl) => checkExtensions(gl, [X_ETC2]),
-  'texture-compression-astc': (gl) => checkExtensions(gl, [X_ASTC]),
-  'texture-compression-etc1-webgl': (gl) => checkExtensions(gl, [X_ETC1]),
-  'texture-compression-pvrtc-webgl': (gl) => checkExtensions(gl, [X_PVRTC]),
-  'texture-compression-atc-webgl': (gl) => checkExtensions(gl, [X_ATC])
+const TEXTURE_FEATURE_CHECKS: Partial<Record<DeviceFeature, string[]>> = {
+  'float32-renderable-webgl': ['EXT_color_buffer_float'], // [false, 'EXT_color_buffer_float'],
+  'float16-renderable-webgl': ['EXT_color_buffer_half_float'],
+  'norm16-renderable-webgl': [EXT_TEXTURE_NORM16],
+
+  'float32-filterable-linear-webgl': ['OES_texture_float_linear'],
+  'float16-filterable-linear-webgl': ['OES_texture_half_float_linear'],
+  'texture-filterable-anisotropic-webgl': ['EXT_texture_filter_anisotropic'],
+
+  'texture-blend-float-webgl': ['EXT_float_blend'],
+
+  'texture-compression-bc': [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC],
+  // 'texture-compression-bc3-srgb-webgl': [X_S3TC_SRGB],
+  // 'texture-compression-bc3-webgl': [X_S3TC],
+  'texture-compression-bc5-webgl': [X_RGTC],
+  'texture-compression-bc7-webgl': [X_BPTC],
+  'texture-compression-etc2': [X_ETC2],
+  'texture-compression-astc': [X_ASTC],
+  'texture-compression-etc1-webgl': [X_ETC1],
+  'texture-compression-pvrtc-webgl': [X_PVRTC],
+  'texture-compression-atc-webgl': [X_ATC]
 };
 
-export function checkTextureFeature(gl: WebGLRenderingContext, feature: DeviceFeature): boolean {
-  return TEXTURE_FEATURE_CHECKS[feature]?.(gl) || false;
+function checkTextureFeature(gl: WebGL2RenderingContext, feature: DeviceFeature): boolean {
+  const extensions = TEXTURE_FEATURE_CHECKS[feature] || [];
+  return extensions.every(extension => gl.getExtension(extension));
 }
 
-const checkTextureFeatures = (gl: WebGLRenderingContext, features: DeviceFeature[]): boolean =>
-  features.every(feature => checkTextureFeature(gl, feature));
+function checkTextureFeatures(gl: WebGL2RenderingContext, features: DeviceFeature[]): boolean {
+  return features.every(feature => checkTextureFeature(gl, feature));
+}
 
 /** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
-export function getTextureFeatures(gl: WebGLRenderingContext): DeviceFeature[] {
+export function getTextureFeatures(gl: WebGL2RenderingContext): DeviceFeature[] {
   const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS) as DeviceFeature[];
   return textureFeatures.filter(feature => checkTextureFeature(gl, feature));
 }
@@ -87,9 +85,6 @@ export function getTextureFeatures(gl: WebGLRenderingContext): DeviceFeature[] {
 /** Map a format to webgl and constants */
 type Format = {
   gl?: GL;
-  /** If a different unsized format is needed in WebGL1 */
-  gl1?: GL;
-  gl1ext?: string;
   /** format requires WebGL2, when using a WebGL 1 context, color renderbuffer formats are limited */
   gl2ext?: string;
 
@@ -120,12 +115,12 @@ type Format = {
   /** if depthTexture is set this is a depth/stencil format that can be set to a texture  */
   depthTexture?: boolean;
 
-  renderbuffer?: boolean
+  renderbuffer?: boolean;
 };
 
 // TABLES
 
-/** 
+/**
  * Texture format data -
  * Exported but can change without notice
  */
@@ -134,9 +129,9 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
   // Unsized formats that leave the precision up to the driver.
   // TODO - Fix bpp constants
   // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
-  'rgb8unorm-unsized': {gl: GL.RGB, gl1: GL.RGB, b: 4, c: 2, bpp: 4,
+  'rgb8unorm-unsized': {gl: GL.RGB, b: 4, c: 2, bpp: 4,
     dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_6_5]},
-  'rgba8unorm-unsized': {gl: GL.RGBA, gl1: GL.RGBA, b: 4, c: 2, bpp: 4,
+  'rgba8unorm-unsized': {gl: GL.RGBA, b: 4, c: 2, bpp: 4,
     dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_4_4_4_4, GL.UNSIGNED_SHORT_5_5_5_1]},
   // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
@@ -155,9 +150,9 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
 
   'r16uint': {gl: GL.R16UI, b: 2, c: 1, renderbuffer: true},
   'r16sint': {gl: GL.R16I, b: 2, c: 1, renderbuffer: true},
-  'r16float': {gl: GL.R16F, b: 2, c: 1, render: 'texture-renderable-float16-webgl', filter: 'texture-filter-linear-float16-webgl', renderbuffer: true},
-  'r16unorm-webgl': {gl: GL.R16_EXT, b:2, c:1, f: 'texture-formats-norm16-webgl', renderbuffer: true, x: EXT_TEXTURE_NORM16},
-  'r16snorm-webgl': {gl: GL.R16_SNORM_EXT, b:2, c:1, f: 'texture-formats-norm16-webgl', x: EXT_TEXTURE_NORM16},
+  'r16float': {gl: GL.R16F, b: 2, c: 1, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl', renderbuffer: true},
+  'r16unorm-webgl': {gl: GL.R16_EXT, b:2, c:1, f: 'norm16-renderable-webgl', renderbuffer: true, x: EXT_TEXTURE_NORM16},
+  'r16snorm-webgl': {gl: GL.R16_SNORM_EXT, b:2, c:1, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16},
 
   // Packed 16-bit formats
   'rgba4unorm-webgl': {gl: GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true},
@@ -169,8 +164,8 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
   'rgb8snorm-webgl': {gl: GL.RGB8_SNORM, b: 3, c: 3, wgpu: false},
 
   // 32-bit formats  
-  'rgba8unorm': {gl: GL.RGBA8, gl1: GL.RGBA, b: 4, c: 2, bpp: 4},
-  'rgba8unorm-srgb': {gl: GL.SRGB8_ALPHA8, gl1: GL.SRGB_ALPHA_EXT, b: 4, c: 4, gl1ext: EXT_SRGB, bpp: 4},
+  'rgba8unorm': {gl: GL.RGBA8, b: 4, c: 2, bpp: 4},
+  'rgba8unorm-srgb': {gl: GL.SRGB8_ALPHA8, b: 4, c: 4, bpp: 4},
   'rgba8snorm': {gl: GL.RGBA8_SNORM, b: 4, c: 4},
   'rgba8uint': {gl: GL.RGBA8UI, b: 4, c: 4, bpp: 4},
   'rgba8sint': {gl: GL.RGBA8I, b: 4, c: 4, bpp: 4},
@@ -181,54 +176,52 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
   'rg16uint': {gl: GL.RG16UI, b: 4, c: 1, bpp: 4},
   'rg16sint': {gl: GL.RG16I, b: 4, c: 2, bpp: 4},
   // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  'rg16float': {gl: GL.RG16F, bpp: 4, b: 4, c: 2, render: 'texture-renderable-float16-webgl', filter: 'texture-filter-linear-float16-webgl', renderbuffer: true},
-  'rg16unorm-webgl': {gl: GL.RG16_EXT, b:2, c:2, f: 'texture-formats-norm16-webgl', x: EXT_TEXTURE_NORM16},
-  'rg16snorm-webgl': {gl: GL.RG16_SNORM_EXT, b:2, c:2, f: 'texture-formats-norm16-webgl', x: EXT_TEXTURE_NORM16},
+  'rg16float': {gl: GL.RG16F, bpp: 4, b: 4, c: 2, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl', renderbuffer: true},
+  'rg16unorm-webgl': {gl: GL.RG16_EXT, b:2, c:2, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16},
+  'rg16snorm-webgl': {gl: GL.RG16_SNORM_EXT, b:2, c:2, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16},
 
   'r32uint': {gl: GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true},
   'r32sint': {gl: GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true},
-  'r32float': {gl: GL.R32F, bpp: 4, b: 4, c: 1, render: 'texture-renderable-float32-webgl', filter: 'texture-filter-linear-float32-webgl'},
+  'r32float': {gl: GL.R32F, bpp: 4, b: 4, c: 1, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl'},
 
   // Packed 32-bit formats
-  'rgb9e5ufloat': {gl: GL.RGB9_E5, b: 4, c: 3, p: 1, render: 'texture-renderable-float16-webgl', filter: 'texture-filter-linear-float16-webgl'},
-  'rg11b10ufloat': {gl: GL.R11F_G11F_B10F, b: 4, c: 3, p: 1,render: 'texture-renderable-float32-webgl', renderbuffer: true},
+  'rgb9e5ufloat': {gl: GL.RGB9_E5, b: 4, c: 3, p: 1, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl'},
+  'rg11b10ufloat': {gl: GL.R11F_G11F_B10F, b: 4, c: 3, p: 1,render: 'float32-renderable-webgl', renderbuffer: true},
   'rgb10a2unorm': {gl: GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true},
-  // webgl2 only
   'rgb10a2unorm-webgl': {b: 4, c: 4, gl: GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true},
 
   // 48-bit formats
-  'rgb16unorm-webgl': {gl: GL.RGB16_EXT, b:2, c:3, f: 'texture-formats-norm16-webgl', x: EXT_TEXTURE_NORM16},
-  'rgb16snorm-webgl': {gl: GL.RGB16_SNORM_EXT, b:2, c:3, f: 'texture-formats-norm16-webgl', x: EXT_TEXTURE_NORM16},
+  'rgb16unorm-webgl': {gl: GL.RGB16_EXT, b:2, c:3, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16},
+  'rgb16snorm-webgl': {gl: GL.RGB16_SNORM_EXT, b:2, c:3, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16},
 
   // 64-bit formats
   'rg32uint': {gl: GL.RG32UI, b: 8, c: 2, renderbuffer: true},
   'rg32sint': {gl: GL.RG32I, b: 8, c: 2, renderbuffer: true},
-  'rg32float': {gl: GL.RG32F, b: 8, c: 2, render: 'texture-renderable-float32-webgl', filter: 'texture-filter-linear-float32-webgl', renderbuffer: true},
+  'rg32float': {gl: GL.RG32F, b: 8, c: 2, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl', renderbuffer: true},
   'rgba16uint': {gl: GL.RGBA16UI, b: 8, c: 4, renderbuffer: true},
   'rgba16sint': {gl: GL.RGBA16I, b: 8, c: 4, renderbuffer: true},
-  'rgba16float': {gl: GL.RGBA16F, gl1: GL.RGBA, b: 8, c: 4, render: 'texture-renderable-float16-webgl', filter: 'texture-filter-linear-float16-webgl'},
-  'rgba16unorm-webgl': {gl: GL.RGBA16_EXT, b:2, c:4, f: 'texture-formats-norm16-webgl', renderbuffer: true, x: EXT_TEXTURE_NORM16},
-  'rgba16snorm-webgl': {gl: GL.RGBA16_SNORM_EXT, b:2, c:4, f: 'texture-formats-norm16-webgl', x: EXT_TEXTURE_NORM16},
+  'rgba16float': {gl: GL.RGBA16F, b: 8, c: 4, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl'},
+  'rgba16unorm-webgl': {gl: GL.RGBA16_EXT, b:2, c:4, f: 'norm16-renderable-webgl', renderbuffer: true, x: EXT_TEXTURE_NORM16},
+  'rgba16snorm-webgl': {gl: GL.RGBA16_SNORM_EXT, b:2, c:4, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16},
 
   // 96-bit formats (deprecated!)
-  'rgb32float-webgl': {gl: GL.RGB32F, gl1: GL.RGB, render: 'texture-renderable-float32-webgl', filter: 'texture-filter-linear-float32-webgl',
-    gl2ext: EXT_FLOAT_RENDER_WEBGL2,  gl1ext: EXT_FLOAT_WEBGL1, // WebGL1 render buffers are supported with GL.RGB32F
-    dataFormat: GL.RGB, types: [GL.FLOAT]},
+  'rgb32float-webgl': {gl: GL.RGB32F, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl',
+    gl2ext: EXT_FLOAT_RENDER_WEBGL2, dataFormat: GL.RGB, types: [GL.FLOAT]},
   
   // 128-bit formats
   'rgba32uint': {gl: GL.RGBA32UI, b: 16, c: 4, renderbuffer: true},
   'rgba32sint': {gl: GL.RGBA32I, b: 16, c: 4, renderbuffer: true},
-  'rgba32float': {gl: GL.RGBA32F, b: 16, c: 4, render: 'texture-renderable-float32-webgl', filter: 'texture-filter-linear-float32-webgl', renderbuffer: true},
+  'rgba32float': {gl: GL.RGBA32F, b: 16, c: 4, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl', renderbuffer: true},
 
   // Depth and stencil formats
-  'stencil8': {gl: GL.STENCIL_INDEX8, gl1: GL.STENCIL_INDEX8, b: 1, c: 1, attachment: GL.STENCIL_ATTACHMENT, renderbuffer: true}, // 8 stencil bits
+  'stencil8': {gl: GL.STENCIL_INDEX8, b: 1, c: 1, attachment: GL.STENCIL_ATTACHMENT, renderbuffer: true}, // 8 stencil bits
 
-  'depth16unorm': {gl: GL.DEPTH_COMPONENT16, gl1: GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: GL.DEPTH_ATTACHMENT, renderbuffer: true}, // 16 depth bits
+  'depth16unorm': {gl: GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: GL.DEPTH_ATTACHMENT, renderbuffer: true}, // 16 depth bits
   'depth24plus': {gl: GL.DEPTH_COMPONENT24, b: 3, c: 1, attachment: GL.DEPTH_ATTACHMENT},
   'depth32float': {gl: GL.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: GL.DEPTH_ATTACHMENT, renderbuffer: true},
 
   // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
-  'depth24plus-stencil8': {gl: GL.DEPTH_STENCIL, gl1: GL.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true},
+  'depth24plus-stencil8': {gl: GL.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true},
   // "depth24unorm-stencil8" feature
   'depth24unorm-stencil8': {gl: GL.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true},
   // "depth32float-stencil8" feature
@@ -319,8 +312,8 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
 };
 
 /** Legal combinations for internalFormat, format and type *
-// [GL.DEPTH_COMPONENT]: {types: [GL.UNSIGNED_SHORT, GL.UNSIGNED_INT, GL.UNSIGNED_INT_24_8], gl1ext: DEPTH},
-// [GL.DEPTH_STENCIL]: {gl1ext: DEPTH},
+// [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},
@@ -332,19 +325,19 @@ export const TEXTURE_FORMATS: Record<TextureFormat, Format> = {
 [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, gl1ext: EXT_SRGB},
-[GL.RGB16F]: {dataFormat: GL.RGB, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true, gl1ext: EXT_HALF_FLOAT_WEBGL1},
+[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, gl1ext: EXT_HALF_FLOAT_WEBGL1},
+[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, gl1ext: EXT_HALF_FLOAT_WEBGL1},
+[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}
 */
 
@@ -445,7 +438,7 @@ const TYPE_SIZES = {
 
 /** Checks if a texture format is supported */
 export function isTextureFormatSupported(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   formatOrGL: TextureFormat | GL
 ): boolean {
   const format = convertGLToTextureFormat(formatOrGL);
@@ -454,21 +447,21 @@ export function isTextureFormatSupported(
     return false;
   }
   // Check that we have a GL constant
-  if (isWebGL2(gl) ? info.gl === undefined : info.gl1 === undefined) {
+  if (info.gl === undefined) {
     return false;
   }
   // Check extensions
-  const extension = info.x || (isWebGL2(gl) ? info.gl2ext || info.gl1ext : info.gl1ext);
+  const extension = info.x || info.gl2ext;
   if (extension) {
     return Boolean(gl.getExtension(extension));
   }
-  // if (info.gl1 === undefined && info.gl2 === undefined) {
-  //   // No info - always supported
-  // }
   return true;
 }
 
-export function isRenderbufferFormatSupported(gl: WebGLRenderingContext, format: TextureFormat): boolean {
+export function isRenderbufferFormatSupported(
+  gl: WebGL2RenderingContext,
+  format: TextureFormat
+): boolean {
   // Note: Order is important since the function call initializes extensions.
   return isTextureFormatSupported(gl, format) && TEXTURE_FORMATS[format]?.renderbuffer;
 }
@@ -480,9 +473,7 @@ export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFor
   if (typeof format === 'string') {
     return format;
   }
-  const entry = Object.entries(TEXTURE_FORMATS).find(
-    ([, entry]) => entry.gl === format || entry.gl1 === format
-  );
+  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
   if (!entry) {
     throw new Error(`Unknown texture format ${format}`);
   }
@@ -492,9 +483,9 @@ export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFor
 /**
  * Map WebGPU style texture format strings to GL constants
  */
-export function convertTextureFormatToGL(format: TextureFormat, isWebGL2: boolean): GL | undefined {
+export function convertTextureFormatToGL(format: TextureFormat): GL | undefined {
   const formatInfo = TEXTURE_FORMATS[format];
-  const webglFormat = isWebGL2 ? formatInfo?.gl : formatInfo?.gl1;
+  const webglFormat = formatInfo?.gl;
   if (webglFormat === undefined) {
     throw new Error(`Unsupported texture format ${format}`);
   }
@@ -503,7 +494,7 @@ export function convertTextureFormatToGL(format: TextureFormat, isWebGL2: boolea
 
 /** Checks if a texture format is supported */
 export function getTextureFormatSupport(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   formatOrGL: TextureFormat | GL
 ): {
   supported: boolean;
@@ -523,7 +514,7 @@ export function getTextureFormatSupport(
   // } catch {}
 
   // Support Check that we have a GL constant
-  let supported = isWebGL2(gl) ? info.gl === undefined : info.gl1 === undefined;
+  let supported = info.gl === undefined;
   supported = supported && checkTextureFeatures(gl, [info.f]);
 
   // Filtering
@@ -545,7 +536,7 @@ export function getTextureFormatSupport(
 
 /** Checks whether linear filtering (interpolated sampling) is available for floating point textures */
 export function isTextureFormatFilterable(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   formatOrGL: TextureFormat | GL
 ): boolean {
   const format = convertGLToTextureFormat(formatOrGL);
@@ -566,22 +557,11 @@ export function isTextureFormatFilterable(
   if (format.endsWith('16float')) {
     return Boolean(gl.getExtension('OES_texture_half_float_linear'));
   }
-  // if (typeof format === 'string') {
-  //   if (format === 'rgba32float') {
-  //     return gl.device.features.has('texture-renderable-rgba32float-webgl');
-  //   }
-  //   if (format.endsWith('32float')) {
-  //     return gl.device.features.has('texture-renderable-float32-webgl');
-  //   }
-  //   if (format.endsWith('16float')) {
-  //     return gl.device.features.has('texture-renderable-float16-webgl');
-  //   }
-  // }
   return true;
 }
 
 export function isTextureFormatRenderable(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   formatOrGL: TextureFormat | GL
 ): boolean {
   const format = convertGLToTextureFormat(formatOrGL);
@@ -595,9 +575,9 @@ export function isTextureFormatRenderable(
   return true;
 }
 
-export function getWebGLTextureParameters(formatOrGL: TextureFormat | GL, isWebGL2: boolean) {
+export function getWebGLTextureParameters(formatOrGL: TextureFormat | GL) {
   const format = convertGLToTextureFormat(formatOrGL);
-  const webglFormat = convertTextureFormatToGL(format, isWebGL2);
+  const webglFormat = convertTextureFormatToGL(format);
   const decoded = decodeTextureFormat(format);
   return {
     format: webglFormat,
@@ -624,59 +604,11 @@ export function getDepthStencilAttachmentWebGL(
   return info.attachment;
 }
 
-/**
- * function to test if Float 32 bit format texture can be bound as color attachment
- * @todo Generalize to check arbitrary formats?
- */
-export function _checkFloat32ColorAttachment(
-  gl: WebGLRenderingContext,
-  internalFormat = gl.RGBA,
-  srcFormat = GL.RGBA,
-  srcType = GL.UNSIGNED_BYTE
-) {
-  let texture: WebGLTexture | null = null;
-  let framebuffer: WebGLFramebuffer | null = null;
-  try {
-    texture = gl.createTexture();
-    gl.bindTexture(GL.TEXTURE_2D, texture);
-
-    const level = 0;
-    const width = 1;
-    const height = 1;
-    const border = 0;
-    const pixel = new Uint8Array([0, 0, 255, 255]); // opaque blue
-    gl.texImage2D(
-      gl.TEXTURE_2D,
-      level,
-      internalFormat,
-      width,
-      height,
-      border,
-      srcFormat,
-      srcType,
-      pixel
-    );
-
-    framebuffer = gl.createFramebuffer();
-    gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
-    gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
-    const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER) as GL === GL.FRAMEBUFFER_COMPLETE;
-
-    gl.bindTexture(GL.TEXTURE_2D, null);
-    return status;
-  } finally {
-    gl.deleteTexture(texture);
-    gl.deleteFramebuffer(framebuffer);
-  }
-}
-
 /** TODO - VERY roundabout legacy way of calculating bytes per pixel */
-export function getTextureFormatBytesPerPixel(
-  formatOrGL: TextureFormat | GL,
-  isWebGL2: boolean
-): number {
+export function getTextureFormatBytesPerPixel(formatOrGL: TextureFormat | GL): number {
+  // TODO remove webgl1 support
   const format = convertGLToTextureFormat(formatOrGL);
-  const params = getWebGLTextureParameters(format, isWebGL2);
+  const params = getWebGLTextureParameters(format);
   // NOTE(Tarek): Default to RGBA bytes
   const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
   const channelSize = TYPE_SIZES[params.type] || 1;

package/src/adapter/device-helpers/webgl-device-features.ts

@@ -0,0 +1,69 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+// Feature detection for WebGL
+// Provides a function that enables simple checking of which WebGL features are
+
+import {DeviceFeature} from '@luma.gl/core';
+import {getTextureFeatures} from '../converters/texture-formats';
+
+/** Get WebGPU style feature strings */
+export function getDeviceFeatures(gl: WebGL2RenderingContext): Set<DeviceFeature> {
+  const features = getWebGLFeatures(gl);
+
+  // texture features
+  // features.add('texture-compression-bc');
+  for (const textureFeature of getTextureFeatures(gl)) {
+    features.add(textureFeature);
+  }
+
+  // TODO
+  // features.add('depth-clip-control'); // GPUPrimitiveState.clampDepth
+  // features.add('depth24unorm-stencil8'); // GPUTextureFormat 'depth24unorm-stencil8'.
+  // features.add('depth32float-stencil8'); // GPUTextureFormat 'depth32float-stencil8'.
+  // features.add('timestamp-query'); // GPUQueryType "timestamp-query"
+  // "indirect-first-instance"
+
+  return features;
+}
+
+/** Extract all WebGL features */
+export function getWebGLFeatures(gl: WebGL2RenderingContext): Set<DeviceFeature> {
+  // Enable EXT_float_blend first: https://developer.mozilla.org/en-US/docs/Web/API/EXT_float_blend
+  gl.getExtension('EXT_color_buffer_float');
+
+  const features = new Set<DeviceFeature>();
+  for (const feature of Object.keys(WEBGL_FEATURES) as DeviceFeature[]) {
+    if (isFeatureSupported(gl, feature)) {
+      features.add(feature);
+    }
+  }
+  return features;
+}
+
+function isFeatureSupported(gl: WebGL2RenderingContext, feature: DeviceFeature): boolean {
+  const featureInfo = WEBGL_FEATURES[feature];
+
+  // string value requires checking the corresponding WebGL extension
+  return typeof featureInfo === 'string'
+    ? Boolean(gl.getExtension(featureInfo))
+    : Boolean(featureInfo);
+}
+
+/**
+ * Defines luma.gl "feature" names and semantics
+ * when value is 'string' it is the name of the extension that enables this feature
+ */
+const WEBGL_FEATURES: Partial<Record<DeviceFeature, boolean | string>> = {
+  webgl: true,
+  glsl: true,
+
+  'uniforms-webgl': true,
+  'transform-feedback-webgl': true,
+  'constant-attributes-webgl': true,
+
+  'timer-query-webgl': 'EXT_disjoint_timer_query_webgl2',
+  'shader-status-async-webgl': 'KHR_parallel_shader_compile'
+
+  // Textures are handled by getTextureFeatures()
+};

package/src/adapter/device-helpers/{get-device-info.ts → webgl-device-info.ts}

@@ -3,10 +3,9 @@
 
 import {DeviceInfo} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
-import {isWebGL2} from '../../context/context/webgl-checks';
 
 /** @returns strings identifying the GPU vendor and driver. */
-export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
+export function getDeviceInfo(gl: WebGL2RenderingContext): DeviceInfo {
   // "Masked" info is always available, but don't contain much useful information
   const vendorMasked = gl.getParameter(GL.VENDOR);
   const rendererMasked = gl.getParameter(GL.RENDERER);
@@ -32,10 +31,10 @@ export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
   // const version = gl.getParameter(GL.SHADING_LANGUAGE_VERSION) as string;
   // const shadingLanguageVersion = parseGLSLVersion(version);
   const shadingLanguage = 'glsl';
-  const shadingLanguageVersion = isWebGL2(gl) ? 300 : 100
+  const shadingLanguageVersion = 300;
 
   return {
-    type: isWebGL2(gl) ? 'webgl2' : 'webgl',
+    type: 'webgl',
     gpu,
     gpuType,
     gpuBackend,