@luma.gl/webgl 9.1.9 → 9.2.0-alpha.2

package/dist/index.d.ts

@@ -13,10 +13,8 @@ export { WEBGLCommandEncoder } from "./adapter/resources/webgl-command-encoder.j
 export { WEBGLRenderPass } from "./adapter/resources/webgl-render-pass.js";
 export { WEBGLVertexArray } from "./adapter/resources/webgl-vertex-array.js";
 export { WEBGLTransformFeedback } from "./adapter/resources/webgl-transform-feedback.js";
-export { Accessor } from "./deprecated/accessor.js";
-export type { AccessorObject } from "./types.js";
 export { setDeviceParameters, withDeviceParameters } from "./adapter/converters/device-parameters.js";
-export { getShaderLayoutFromGLSL } from "./adapter/helpers/get-shader-layout.js";
+export { getShaderLayoutFromGLSL } from "./adapter/helpers/get-shader-layout-from-glsl.js";
 export { WebGLStateTracker } from "./context/state-tracker/webgl-state-tracker.js";
 export { resetGLParameters, setGLParameters, getGLParameters } from "./context/parameters/unified-parameter-api.js";
 export { withGLParameters } from "./context/state-tracker/with-parameters.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAC,iBAAiB,EAAC,wDAAqD;AAGpF,OAAO,EAAC,aAAa,EAAC,mCAAgC;AACtD,YAAY,EAAC,YAAY,EAAC,mCAAgC;AAG1D,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAGlE,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAE/D,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AAEvE,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAE9E,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AAEtE,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAGxE,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAGpF,OAAO,EAAC,QAAQ,EAAC,iCAA8B;AAC/C,YAAY,EAAC,cAAc,EAAC,mBAAgB;AAI5C,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAGjG,OAAO,EAAC,uBAAuB,EAAC,+CAA4C;AAC5E,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAG9E,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAC,iBAAiB,EAAC,wDAAqD;AAGpF,OAAO,EAAC,aAAa,EAAC,mCAAgC;AACtD,YAAY,EAAC,YAAY,EAAC,mCAAgC;AAG1D,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAGlE,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAE/D,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AAEvE,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAE9E,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AAEtE,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAGxE,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAIpF,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAGjG,OAAO,EAAC,uBAAuB,EAAC,yDAAsD;AACtF,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAG9E,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}

package/dist/index.js

@@ -21,12 +21,10 @@ export { WEBGLRenderPass } from "./adapter/resources/webgl-render-pass.js";
 export { WEBGLVertexArray } from "./adapter/resources/webgl-vertex-array.js";
 // WebGL adapter classes
 export { WEBGLTransformFeedback } from "./adapter/resources/webgl-transform-feedback.js";
-// WebGL adapter classes
-export { Accessor } from "./deprecated/accessor.js";
 // Unified parameter API
 export { setDeviceParameters, withDeviceParameters } from "./adapter/converters/device-parameters.js";
 // HELPERS - EXPERIMENTAL
-export { getShaderLayoutFromGLSL } from "./adapter/helpers/get-shader-layout.js";
+export { getShaderLayoutFromGLSL } from "./adapter/helpers/get-shader-layout-from-glsl.js";
 export { WebGLStateTracker } from "./context/state-tracker/webgl-state-tracker.js";
 // DEPRECATED TEST EXPORTS
 export { resetGLParameters, setGLParameters, getGLParameters } from "./context/parameters/unified-parameter-api.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAWpC,wBAAwB;AACxB,OAAO,EAAC,aAAa,EAAC,mCAAgC;AAGtD,uBAAuB;AACvB,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAElE,yBAAyB;AACzB,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,mFAAmF;AACnF,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AAEvE,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,mFAAmF;AACnF,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AACtE,2EAA2E;AAC3E,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAExE,wBAAwB;AACxB,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAEpF,wBAAwB;AACxB,OAAO,EAAC,QAAQ,EAAC,iCAA8B;AAG/C,wBAAwB;AAExB,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAEjG,yBAAyB;AACzB,OAAO,EAAC,uBAAuB,EAAC,+CAA4C;AAC5E,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAE9E,0BAA0B;AAC1B,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAWpC,wBAAwB;AACxB,OAAO,EAAC,aAAa,EAAC,mCAAgC;AAGtD,uBAAuB;AACvB,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAElE,yBAAyB;AACzB,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,mFAAmF;AACnF,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AAEvE,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,mFAAmF;AACnF,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AACtE,2EAA2E;AAC3E,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAExE,wBAAwB;AACxB,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAEpF,wBAAwB;AAExB,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAEjG,yBAAyB;AACzB,OAAO,EAAC,uBAAuB,EAAC,yDAAsD;AACtF,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAE9E,0BAA0B;AAC1B,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "9.1.9",
+  "version": "9.2.0-alpha.2",
   "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"
+    "@luma.gl/core": "9.2.0-alpha.1"
   },
   "dependencies": {
-    "@luma.gl/constants": "9.1.9",
+    "@luma.gl/constants": "9.2.0-alpha.2",
     "@math.gl/types": "^4.1.0",
     "@probe.gl/env": "^4.0.8"
   },
-  "gitHead": "2d0d93f337120d670e03bd2d5141d90d0d582b44"
+  "gitHead": "dc1e71675ea19a4afbb59d3b9dcd3b01deea3cae"
 }

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

@@ -395,23 +395,33 @@ function convertBlendOperationToEquation(
   });
 }
 
-function convertBlendFactorToFunction(parameter: string, value: BlendFactor): GLBlendFunction {
+function convertBlendFactorToFunction(
+  parameter: string,
+  value: BlendFactor,
+  type: 'color' | 'alpha' = 'color'
+): GLBlendFunction {
   return map<BlendFactor, GLBlendFunction>(parameter, value, {
     one: GL.ONE,
     zero: GL.ZERO,
-    'src-color': GL.SRC_COLOR,
-    'one-minus-src-color': GL.ONE_MINUS_SRC_COLOR,
-    'dst-color': GL.DST_COLOR,
-    'one-minus-dst-color': GL.ONE_MINUS_DST_COLOR,
+    src: GL.SRC_COLOR,
+    'one-minus-src': GL.ONE_MINUS_SRC_COLOR,
+    dst: GL.DST_COLOR,
+    'one-minus-dst': GL.ONE_MINUS_DST_COLOR,
     'src-alpha': GL.SRC_ALPHA,
     'one-minus-src-alpha': GL.ONE_MINUS_SRC_ALPHA,
     'dst-alpha': GL.DST_ALPHA,
     'one-minus-dst-alpha': GL.ONE_MINUS_DST_ALPHA,
     'src-alpha-saturated': GL.SRC_ALPHA_SATURATE,
-    'constant-color': GL.CONSTANT_COLOR,
-    'one-minus-constant-color': GL.ONE_MINUS_CONSTANT_COLOR,
-    'constant-alpha': GL.CONSTANT_ALPHA,
-    'one-minus-constant-alpha': GL.ONE_MINUS_CONSTANT_ALPHA
+    constant: type === 'color' ? GL.CONSTANT_COLOR : GL.CONSTANT_ALPHA,
+    'one-minus-constant':
+      type === 'color' ? GL.ONE_MINUS_CONSTANT_COLOR : GL.ONE_MINUS_CONSTANT_ALPHA,
+    // 'constant-alpha': GL.CONSTANT_ALPHA,
+    // 'one-minus-constant-alpha': GL.ONE_MINUS_CONSTANT_ALPHA,
+    // TODO not supported in WebGL2
+    src1: GL.SRC_COLOR,
+    'one-minus-src1': GL.ONE_MINUS_SRC_COLOR,
+    'src1-alpha': GL.SRC_ALPHA,
+    'one-minus-src1-alpha': GL.ONE_MINUS_SRC_ALPHA
   });
 }
 

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

@@ -99,8 +99,19 @@ function convertMinFilterMode(
     case 'none':
       return convertMaxFilterMode(minFilter);
     case 'nearest':
-      return minFilter === 'nearest' ? GL.NEAREST_MIPMAP_NEAREST : GL.NEAREST_MIPMAP_LINEAR;
+      switch (minFilter) {
+        case 'nearest':
+          return GL.NEAREST_MIPMAP_NEAREST;
+        case 'linear':
+          return GL.LINEAR_MIPMAP_NEAREST;
+      }
+      break;
     case 'linear':
-      return minFilter === 'nearest' ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR_MIPMAP_LINEAR;
+      switch (minFilter) {
+        case 'nearest':
+          return GL.NEAREST_MIPMAP_LINEAR;
+        case 'linear':
+          return GL.LINEAR_MIPMAP_LINEAR;
+      }
   }
 }

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

@@ -2,31 +2,35 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GL} from '@luma.gl/constants';
-import {ShaderAttributeType, ShaderDataType} from '@luma.gl/core';
+import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';
+import {SignedDataType} from '@luma.gl/core';
 
-/** Get shader attribute type from GL constants */
-export function getShaderAttributeTypeFromGL(
-  type: GL,
-  components: 1 | 2 | 3 | 4
-): ShaderAttributeType {
-  const dataType = getShaderDataTypeFromGL(type);
-  switch (components) {
-    case 1:
-      return dataType;
-    case 2:
-      return `vec2<${dataType}>`;
-    case 3:
-      return `vec2<${dataType}>`;
-    case 4:
-      return `vec2<${dataType}>`;
-    default:
-      throw new Error(String(components));
-  }
+/** Get shadertypes data type from GL constants */
+export function convertGLDataTypeToDataType(type: GLDataType | GLPixelType): SignedDataType {
+  return GL_DATA_TYPE_MAP[type];
 }
 
-/** Get shader data type from GL constants */
-export function getShaderDataTypeFromGL(type: GL): ShaderDataType {
+const GL_DATA_TYPE_MAP: Record<GLDataType | GLPixelType, SignedDataType> = {
+  [GL.INT]: 'sint32',
+  [GL.UNSIGNED_INT]: 'uint32',
+  [GL.SHORT]: 'sint16',
+  [GL.UNSIGNED_SHORT]: 'uint16',
+  [GL.BYTE]: 'sint8',
+  [GL.UNSIGNED_BYTE]: 'uint8',
+  [GL.FLOAT]: 'float32',
+  [GL.HALF_FLOAT]: 'float16',
+  [GL.UNSIGNED_SHORT_5_6_5]: 'uint16',
+  [GL.UNSIGNED_SHORT_4_4_4_4]: 'uint16',
+  [GL.UNSIGNED_SHORT_5_5_5_1]: 'uint16',
+  [GL.UNSIGNED_INT_2_10_10_10_REV]: 'uint32',
+  [GL.UNSIGNED_INT_10F_11F_11F_REV]: 'uint32',
+  [GL.UNSIGNED_INT_5_9_9_9_REV]: 'uint32',
+  [GL.UNSIGNED_INT_24_8]: 'uint32',
+  [GL.FLOAT_32_UNSIGNED_INT_24_8_REV]: 'uint32'
+};
+
+/** Get shader data type from GL constants *
+export function getPrimitiveTypeFromGL(type: GL): PrimitiveDataType {
   switch (type) {
     case GL.INT:
       return 'i32';
@@ -49,9 +53,30 @@ export function getShaderDataTypeFromGL(type: GL): ShaderDataType {
   }
 }
 
-/** GetGL constant from shader data type */
+/** Get shader attribute type from GL constants *
+export function getShaderAttributeTypeFromGL(
+  type: GL,
+  components: 1 | 2 | 3 | 4
+): AttributeShaderType {
+  const dataType = getPrimitiveTypeFromGL(type);
+  switch (components) {
+    case 1:
+      return dataType;
+    case 2:
+      return `vec2<${dataType}>`;
+    case 3:
+      return `vec2<${dataType}>`;
+    case 4:
+      return `vec2<${dataType}>`;
+    default:
+      throw new Error(String(components));
+  }
+}
+*/
+
+/** GetGL constant from shader data type
 export function getGLFromShaderDataType(
-  type: ShaderDataType
+  type: PrimitiveDataType
 ): GL.INT | GL.UNSIGNED_INT | GL.FLOAT | GL.HALF_FLOAT {
   switch (type) {
     // TODO
@@ -67,3 +92,4 @@ export function getGLFromShaderDataType(
       throw new Error(String(type));
   }
 }
+*/

package/src/adapter/converters/webgl-shadertypes.ts

@@ -0,0 +1,151 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {VariableShaderType, SignedDataType, VertexFormat, NormalizedDataType} from '@luma.gl/core';
+import {GL, GLUniformType, GLSamplerType, GLDataType} from '@luma.gl/constants';
+
+export type TextureBindingInfo = {
+  viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+  sampleType: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
+};
+
+/** Converts to a luma shadertype to a GL data type (GL.BYTE, GL.FLOAT32 etc)  */
+export function convertDataTypeToGLDataType(normalizedType: NormalizedDataType): GLDataType {
+  return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
+}
+
+/** Converts to a luma shadertype to a GL data type (GL.BYTE, GL.FLOAT32 etc)  */
+export function convertShaderVariableTypeToGLDataType(
+  normalizedType: VariableShaderType
+): GLDataType {
+  // @ts-ignore TODO
+  return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
+}
+
+/** Convert a WebGL "compisite type (e.g. GL.VEC3) into the corresponding luma shader uniform type */
+export function convertGLUniformTypeToShaderVariableType(
+  glUniformType: GLUniformType
+): VariableShaderType {
+  return WEBGL_SHADER_TYPES[glUniformType];
+}
+
+/** Check if a WebGL "uniform:" is a texture binding */
+export function isGLSamplerType(type: GLUniformType | GLSamplerType): type is GLSamplerType {
+  // @ts-ignore TODO
+  return Boolean(WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[type]);
+}
+
+/* Get luma texture binding info (viewDimension and sampleType) from a WebGL "sampler" binding */
+export function getTextureBindingFromGLSamplerType(
+  glSamplerType: GLSamplerType
+): TextureBindingInfo {
+  return WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[glSamplerType];
+}
+
+/** Get vertex format from GL constants */
+export function getVertexFormatFromGL(type: GLDataType, components: 1 | 2 | 3 | 4): VertexFormat {
+  const base = getVertexTypeFromGL(type);
+  // prettier-ignore
+  switch (components) {
+    case 1: return base;
+    case 2: return `${base}x2`;
+    // @ts-expect-error - deal with lack of "unaligned" formats
+    case 3: return `${base}x3`;
+    case 4: return `${base}x4`;
+  }
+  // @ts-ignore unreachable
+  throw new Error(String(components));
+}
+
+/** Get data type from GL constants */
+export function getVertexTypeFromGL(glType: GLDataType, normalized = false): NormalizedDataType {
+  const index = normalized ? 1 : 0;
+  return WEBGL_TO_NORMALIZED_DATA_TYPE[glType][index];
+}
+
+// Composite types table
+// @ts-ignore TODO - fix the type confusion here
+const WEBGL_SHADER_TYPES: Record<GLUniformType, VariableShaderType> = {
+  [GL.FLOAT]: 'f32',
+  [GL.FLOAT_VEC2]: 'vec2<f32>',
+  [GL.FLOAT_VEC3]: 'vec3<f32>',
+  [GL.FLOAT_VEC4]: 'vec4<f32>',
+
+  [GL.INT]: 'i32',
+  [GL.INT_VEC2]: 'vec2<i32>',
+  [GL.INT_VEC3]: 'vec3<i32>',
+  [GL.INT_VEC4]: 'vec4<i32>',
+
+  [GL.UNSIGNED_INT]: 'u32',
+  [GL.UNSIGNED_INT_VEC2]: 'vec2<u32>',
+  [GL.UNSIGNED_INT_VEC3]: 'vec3<u32>',
+  [GL.UNSIGNED_INT_VEC4]: 'vec4<u32>',
+
+  [GL.BOOL]: 'f32',
+  [GL.BOOL_VEC2]: 'vec2<f32>',
+  [GL.BOOL_VEC3]: 'vec3<f32>',
+  [GL.BOOL_VEC4]: 'vec4<f32>',
+
+  // TODO - are sizes/components below correct?
+  [GL.FLOAT_MAT2]: 'mat2x2<f32>',
+  [GL.FLOAT_MAT2x3]: 'mat2x3<f32>',
+  [GL.FLOAT_MAT2x4]: 'mat2x4<f32>',
+
+  [GL.FLOAT_MAT3x2]: 'mat3x2<f32>',
+  [GL.FLOAT_MAT3]: 'mat3x3<f32>',
+  [GL.FLOAT_MAT3x4]: 'mat3x4<f32>',
+
+  [GL.FLOAT_MAT4x2]: 'mat4x2<f32>',
+  [GL.FLOAT_MAT4x3]: 'mat4x3<f32>',
+  [GL.FLOAT_MAT4]: 'mat4x4<f32>'
+};
+
+const WEBGL_SAMPLER_TO_TEXTURE_BINDINGS: Record<GLSamplerType, TextureBindingInfo> = {
+  [GL.SAMPLER_2D]: {viewDimension: '2d', sampleType: 'float'},
+  [GL.SAMPLER_CUBE]: {viewDimension: 'cube', sampleType: 'float'},
+  [GL.SAMPLER_3D]: {viewDimension: '3d', sampleType: 'float'},
+  [GL.SAMPLER_2D_SHADOW]: {viewDimension: '3d', sampleType: 'depth'},
+  [GL.SAMPLER_2D_ARRAY]: {viewDimension: '2d-array', sampleType: 'float'},
+  [GL.SAMPLER_2D_ARRAY_SHADOW]: {viewDimension: '2d-array', sampleType: 'depth'},
+  [GL.SAMPLER_CUBE_SHADOW]: {viewDimension: 'cube', sampleType: 'float'},
+  [GL.INT_SAMPLER_2D]: {viewDimension: '2d', sampleType: 'sint'},
+  [GL.INT_SAMPLER_3D]: {viewDimension: '3d', sampleType: 'sint'},
+  [GL.INT_SAMPLER_CUBE]: {viewDimension: 'cube', sampleType: 'sint'},
+  [GL.INT_SAMPLER_2D_ARRAY]: {viewDimension: '2d-array', sampleType: 'uint'},
+  [GL.UNSIGNED_INT_SAMPLER_2D]: {viewDimension: '2d', sampleType: 'uint'},
+  [GL.UNSIGNED_INT_SAMPLER_3D]: {viewDimension: '3d', sampleType: 'uint'},
+  [GL.UNSIGNED_INT_SAMPLER_CUBE]: {viewDimension: 'cube', sampleType: 'uint'},
+  [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: {viewDimension: '2d-array', sampleType: 'uint'}
+};
+
+/** Map from WebGL normalized types to WebGL */
+const NORMALIZED_SHADER_TYPE_TO_WEBGL: Record<NormalizedDataType, GLDataType> = {
+  uint8: GL.UNSIGNED_BYTE,
+  sint8: GL.BYTE,
+  unorm8: GL.UNSIGNED_BYTE,
+  snorm8: GL.BYTE,
+  uint16: GL.UNSIGNED_SHORT,
+  sint16: GL.SHORT,
+  unorm16: GL.UNSIGNED_SHORT,
+  snorm16: GL.SHORT,
+  uint32: GL.UNSIGNED_INT,
+  sint32: GL.INT,
+  // WebGPU does not support normalized 32 bit integer attributes
+  //  'unorm32': GL.UNSIGNED_INT,
+  //  'snorm32': GL.INT,
+  float16: GL.HALF_FLOAT,
+  float32: GL.FLOAT
+};
+
+/* Map from WebGL types to webgpu normalized types */
+const WEBGL_TO_NORMALIZED_DATA_TYPE: Record<GLDataType, [SignedDataType, NormalizedDataType]> = {
+  [GL.BYTE]: ['sint8', 'snorm16'],
+  [GL.UNSIGNED_BYTE]: ['uint8', 'unorm8'],
+  [GL.SHORT]: ['sint16', 'unorm16'],
+  [GL.UNSIGNED_SHORT]: ['uint16', 'unorm16'],
+  [GL.INT]: ['sint32', 'sint32'],
+  [GL.UNSIGNED_INT]: ['uint32', 'uint32'],
+  [GL.FLOAT]: ['float32', 'float32'],
+  [GL.HALF_FLOAT]: ['float16', 'float16']
+};

package/src/adapter/converters/webgl-texture-table.ts

@@ -8,10 +8,10 @@ import type {
   TextureFormatCapabilities,
   DeviceTextureFormatCapabilities
 } from '@luma.gl/core';
-import {decodeTextureFormat} from '@luma.gl/core';
+import {textureFormatDecoder} from '@luma.gl/core';
 import {GL, GLPixelType, GLExtensions, GLTexelDataFormat} from '@luma.gl/constants';
 import {getWebGLExtension} from '../../context/helpers/webgl-extensions';
-import {getGLFromVertexType} from './vertex-formats';
+import {getGLFromVertexType} from './webgl-vertex-formats';
 
 /* eslint-disable camelcase */
 
@@ -112,8 +112,8 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   'r16uint': {gl: GL.R16UI, rb: true},
   'r16sint': {gl: GL.R16I, rb: true},
   'r16float': {gl: GL.R16F, rb: true},
-  'r16unorm-webgl': {gl: GL.R16_EXT, rb: true},
-  'r16snorm-webgl': {gl: GL.R16_SNORM_EXT},
+  'r16unorm': {gl: GL.R16_EXT, rb: true},
+  'r16snorm': {gl: GL.R16_SNORM_EXT},
 
   // Packed 16-bit formats
   'rgba4unorm-webgl': {gl: GL.RGBA4, rb: true},
@@ -124,7 +124,7 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   'rgb8unorm-webgl': {gl: GL.RGB8},
   'rgb8snorm-webgl': {gl: GL.RGB8_SNORM},
 
-  // 32-bit formats  
+  // 32-bit formats
   'rgba8unorm': {gl: GL.RGBA8},
   'rgba8unorm-srgb': {gl: GL.SRGB8_ALPHA8},
   'rgba8snorm': {gl: GL.RGBA8_SNORM},
@@ -137,8 +137,8 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   'rg16uint': {gl: GL.RG16UI},
   'rg16sint': {gl: GL.RG16I},
   'rg16float': {gl: GL.RG16F, rb: true},
-  'rg16unorm-webgl': {gl: GL.RG16_EXT},
-  'rg16snorm-webgl': {gl: GL.RG16_SNORM_EXT},
+  'rg16unorm': {gl: GL.RG16_EXT},
+  'rg16snorm': {gl: GL.RG16_SNORM_EXT},
 
   'r32uint': {gl: GL.R32UI, rb: true},
   'r32sint': {gl: GL.R32I, rb: true},
@@ -148,7 +148,7 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   'rgb9e5ufloat': {gl: GL.RGB9_E5}, // , filter: true},
   'rg11b10ufloat': {gl: GL.R11F_G11F_B10F, rb: true},
   'rgb10a2unorm': {gl: GL.RGB10_A2, rb: true},
-  'rgb10a2uint-webgl': {gl: GL.RGB10_A2UI, rb: true},
+  'rgb10a2uint': {gl: GL.RGB10_A2UI, rb: true},
 
   // 48-bit formats
   'rgb16unorm-webgl': {gl: GL.RGB16_EXT}, // rgb not renderable
@@ -161,12 +161,12 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   'rgba16uint': {gl: GL.RGBA16UI, rb: true},
   'rgba16sint': {gl: GL.RGBA16I, rb: true},
   'rgba16float': {gl: GL.RGBA16F},
-  'rgba16unorm-webgl': {gl: GL.RGBA16_EXT, rb: true},
-  'rgba16snorm-webgl': {gl: GL.RGBA16_SNORM_EXT},
+  'rgba16unorm': {gl: GL.RGBA16_EXT, rb: true},
+  'rgba16snorm': {gl: GL.RGBA16_SNORM_EXT},
 
   // 96-bit formats (deprecated!)
   'rgb32float-webgl': {gl: GL.RGB32F, x: EXT_color_buffer_float, dataFormat: GL.RGB, types: [GL.FLOAT]},
-  
+
   // 128-bit formats
   'rgba32uint': {gl: GL.RGBA32UI, rb: true},
   'rgba32sint': {gl: GL.RGBA32I, rb: true},
@@ -332,7 +332,13 @@ export function getTextureFormatWebGL(format: TextureFormat): {
 } {
   const formatData = WEBGL_TEXTURE_FORMATS[format];
   const webglFormat = convertTextureFormatToGL(format);
-  const decoded = decodeTextureFormat(format);
+  const decoded = textureFormatDecoder.getInfo(format);
+
+  if (decoded.compressed) {
+    // TODO: Unclear whether this is always valid, this may be why ETC2 RGBA8 fails.
+    formatData.dataFormat = webglFormat as GLTexelDataFormat;
+  }
+
   return {
     internalFormat: webglFormat,
     format:
@@ -349,7 +355,7 @@ export function getTextureFormatWebGL(format: TextureFormat): {
 export function getDepthStencilAttachmentWebGL(
   format: TextureFormat
 ): GL.DEPTH_ATTACHMENT | GL.STENCIL_ATTACHMENT | GL.DEPTH_STENCIL_ATTACHMENT {
-  const formatInfo = decodeTextureFormat(format);
+  const formatInfo = textureFormatDecoder.getInfo(format);
   switch (formatInfo.attachment) {
     case 'depth':
       return GL.DEPTH_ATTACHMENT;
@@ -364,7 +370,7 @@ export function getDepthStencilAttachmentWebGL(
 
 /** TODO - VERY roundabout legacy way of calculating bytes per pixel */
 export function getTextureFormatBytesPerPixel(format: TextureFormat): number {
-  const formatInfo = decodeTextureFormat(format);
+  const formatInfo = textureFormatDecoder.getInfo(format);
   return formatInfo.bytesPerPixel;
 }
 
@@ -394,7 +400,7 @@ export function getWebGLPixelDataFormat(
 /**
  * Map WebGPU style texture format strings to GL constants
  */
-function convertTextureFormatToGL(format: TextureFormat): GL | undefined {
+function convertTextureFormatToGL(format: TextureFormat): GL {
   const formatInfo = WEBGL_TEXTURE_FORMATS[format];
   const webglFormat = formatInfo?.gl;
   if (webglFormat === undefined) {

package/src/adapter/converters/{vertex-formats.ts → webgl-vertex-formats.ts}

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {GL} from '@luma.gl/constants';
-import {VertexFormat, VertexType} from '@luma.gl/core';
+import {VertexFormat, NormalizedDataType} from '@luma.gl/core';
 
 type GLDataType =
   | GL.UNSIGNED_BYTE
@@ -20,10 +20,9 @@ export function getVertexFormatFromGL(type: GLDataType, components: 1 | 2 | 3 |
   const base = getVertexTypeFromGL(type);
   // prettier-ignore
   switch (components) {
-    // @ts-expect-error TODO deal with lack of formats
     case 1: return base;
     case 2: return `${base}x2`;
-    // @ts-expect-error TODO deal with lack of formats
+    // @ts-expect-error TODO deal with lack of "unaligned" formats
     case 3: return `${base}x3`;
     case 4: return `${base}x4`;
   }
@@ -32,7 +31,7 @@ export function getVertexFormatFromGL(type: GLDataType, components: 1 | 2 | 3 |
 }
 
 /** Get data type from GL constants */
-export function getVertexTypeFromGL(type: GLDataType, normalized = false): VertexType {
+export function getVertexTypeFromGL(type: GLDataType, normalized = false): NormalizedDataType {
   // prettier-ignore
   switch (type) {
     // WebGPU does not support normalized 32 bit integer attributes
@@ -50,7 +49,7 @@ export function getVertexTypeFromGL(type: GLDataType, normalized = false): Verte
 }
 
 export function getGLFromVertexType(
-  dataType: VertexType
+  dataType: NormalizedDataType
 ):
   | GL.UNSIGNED_BYTE
   | GL.BYTE

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

@@ -62,7 +62,7 @@ export class WebGLDeviceFeatures extends DeviceFeatures {
     getWebGLExtension(gl, 'EXT_color_buffer_float', extensions);
   }
 
-  *[Symbol.iterator](): IterableIterator<DeviceFeature> {
+  override *[Symbol.iterator](): IterableIterator<DeviceFeature> {
     const features = this.getFeatures();
     for (const feature of features) {
       if (this.has(feature)) {

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

@@ -26,7 +26,7 @@ export class WebGLDeviceLimits extends DeviceLimits {
   get maxVertexBuffers() { return 16; } // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
   get maxVertexAttributes() { return this.getParameter(GL.MAX_VERTEX_ATTRIBS); }
   get maxVertexBufferArrayStride() { return 2048; } // TBD, this is just the default value from WebGPU
-  get maxInterStageShaderComponents() { return this.getParameter(GL.MAX_VARYING_COMPONENTS); }
+  get maxInterStageShaderVariables() { return this.getParameter(GL.MAX_VARYING_COMPONENTS); }
   get maxComputeWorkgroupStorageSize() { return 0; } // WebGL does not support compute shaders
   get maxComputeInvocationsPerWorkgroup() { return 0; } // WebGL does not support compute shaders
   get maxComputeWorkgroupSizeX() { return 0; } // WebGL does not support compute shaders

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

@@ -5,7 +5,7 @@
 import {GL} from '@luma.gl/constants';
 
 // Returns number of components in a specific readPixels WebGL format
-export function glFormatToComponents(format) {
+export function glFormatToComponents(format: GL): 0 | 1 | 2 | 3 | 4 {
   switch (format) {
     case GL.ALPHA:
     case GL.R32F:
@@ -33,7 +33,7 @@ export function glFormatToComponents(format) {
 }
 
 // Return byte count for given readPixels WebGL type
-export function glTypeToBytes(type) {
+export function glTypeToBytes(type: GL): 0 | 1 | 2 | 4 {
   switch (type) {
     case GL.UNSIGNED_BYTE:
       return 1;