@luma.gl/webgl 9.1.0-beta.9 → 9.2.0-alpha.1

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.0-beta.9",
+  "version": "9.2.0-alpha.1",
   "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.1"
+    "@luma.gl/core": "9.2.0-alpha.0"
   },
   "dependencies": {
-    "@luma.gl/constants": "9.1.0-beta.9",
+    "@luma.gl/constants": "9.2.0-alpha.1",
     "@math.gl/types": "^4.1.0",
     "@probe.gl/env": "^4.0.8"
   },
-  "gitHead": "ce90c649e27184c399eaeab814ec21a46f45677b"
+  "gitHead": "d6d2f791f2ce96f4b5acb68e05faea62c35440fb"
 }

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/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,152 @@
+// 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) {
+    // @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
+    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 {getTextureFormatInfo} 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 */
 
@@ -148,8 +148,8 @@ 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
   'rgb16snorm-webgl': {gl: GL.RGB16_SNORM_EXT}, // rgb not renderable
@@ -332,7 +332,7 @@ export function getTextureFormatWebGL(format: TextureFormat): {
 } {
   const formatData = WEBGL_TEXTURE_FORMATS[format];
   const webglFormat = convertTextureFormatToGL(format);
-  const decoded = decodeTextureFormat(format);
+  const decoded = getTextureFormatInfo(format);
   return {
     internalFormat: webglFormat,
     format:
@@ -349,7 +349,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 = getTextureFormatInfo(format);
   switch (formatInfo.attachment) {
     case 'depth':
       return GL.DEPTH_ATTACHMENT;
@@ -364,8 +364,8 @@ export function getDepthStencilAttachmentWebGL(
 
 /** TODO - VERY roundabout legacy way of calculating bytes per pixel */
 export function getTextureFormatBytesPerPixel(format: TextureFormat): number {
-  const formatInfo = decodeTextureFormat(format);
-  return formatInfo.bytesPerPixel;
+  const formatInfo = getTextureFormatInfo(format);
+  return formatInfo.bytesPerPixel as number;
 }
 
 // DATA TYPE HELPERS
@@ -394,7 +394,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
@@ -32,7 +32,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 +50,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;

package/src/adapter/helpers/{get-shader-layout.ts → get-shader-layout-from-glsl.ts}

@@ -7,11 +7,17 @@ import type {
   UniformBinding,
   UniformBlockBinding,
   AttributeDeclaration,
-  VaryingBinding
+  VaryingBinding,
+  AttributeShaderType
 } from '@luma.gl/core';
+import {getVariableShaderTypeInfo} from '@luma.gl/core';
 
-import {GL} from '@luma.gl/constants';
-import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './decode-webgl-types';
+import {GL, GLUniformType} from '@luma.gl/constants';
+import {
+  isGLSamplerType,
+  getTextureBindingFromGLSamplerType,
+  convertGLUniformTypeToShaderVariableType
+} from '../converters/webgl-shadertypes';
 
 /**
  * Extract metadata describing binding information for a program's shaders
@@ -53,8 +59,8 @@ export function getShaderLayoutFromGLSL(
   const uniforms: UniformBinding[] = readUniformBindings(gl, program);
   let textureUnit = 0;
   for (const uniform of uniforms) {
-    if (isSamplerUniform(uniform.type)) {
-      const {viewDimension, sampleType} = getSamplerInfo(uniform.type);
+    if (isGLSamplerType(uniform.type)) {
+      const {viewDimension, sampleType} = getTextureBindingFromGLSamplerType(uniform.type);
       shaderLayout.bindings.push({
         type: 'texture',
         name: uniform.name,
@@ -108,7 +114,7 @@ function readAttributeDeclarations(
     const location = gl.getAttribLocation(program, name);
     // Add only user provided attributes, for built-in attributes like `gl_InstanceID` location will be < 0
     if (location >= 0) {
-      const {attributeType} = decodeGLAttributeType(compositeType);
+      const attributeType = convertGLUniformTypeToShaderVariableType(compositeType);
 
       // Whether an attribute is instanced is essentially fixed by the structure of the shader code,
       // so it is arguably a static property of the shader.
@@ -120,7 +126,7 @@ function readAttributeDeclarations(
         name,
         location,
         stepMode,
-        type: attributeType
+        type: attributeType as AttributeShaderType
         // size - for arrays, size is the number of elements in the array
       });
     }
@@ -145,10 +151,10 @@ function readVaryings(gl: WebGL2RenderingContext, program: WebGLProgram): Varyin
     if (!activeInfo) {
       throw new Error('activeInfo');
     }
-    const {name, type: compositeType, size} = activeInfo;
-    const {glType, components} = decodeGLUniformType(compositeType);
-    const varying = {location, name, type: glType, size: size * components}; // Base values
-    varyings.push(varying);
+    const {name, type: glUniformType, size} = activeInfo;
+    const uniformType = convertGLUniformTypeToShaderVariableType(glUniformType as GLUniformType);
+    const {type, components} = getVariableShaderTypeInfo(uniformType);
+    varyings.push({location, name, type, size: size * components});
   }
 
   varyings.sort((a, b) => a.location - b.location);
@@ -251,9 +257,11 @@ function readUniformBlocks(
         throw new Error('activeInfo');
       }
 
+      const format = convertGLUniformTypeToShaderVariableType(uniformType[i]);
+
       blockInfo.uniforms.push({
         name: activeInfo.name,
-        format: decodeGLUniformType(uniformType[i]).format,
+        format,
         type: uniformType[i],
         arrayLength: uniformArrayLength[i],
         byteOffset: uniformOffset[i],
@@ -291,44 +299,6 @@ function readUniformBlocks(
   }
 */
 
-const SAMPLER_UNIFORMS_GL_TO_GPU: Record<
-  number,
-  [
-    '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d',
-    'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint'
-  ]
-> = {
-  [GL.SAMPLER_2D]: ['2d', 'float'],
-  [GL.SAMPLER_CUBE]: ['cube', 'float'],
-  [GL.SAMPLER_3D]: ['3d', 'float'],
-  [GL.SAMPLER_2D_SHADOW]: ['3d', 'depth'],
-  [GL.SAMPLER_2D_ARRAY]: ['2d-array', 'float'],
-  [GL.SAMPLER_2D_ARRAY_SHADOW]: ['2d-array', 'depth'],
-  [GL.SAMPLER_CUBE_SHADOW]: ['cube', 'float'],
-  [GL.INT_SAMPLER_2D]: ['2d', 'sint'],
-  [GL.INT_SAMPLER_3D]: ['3d', 'sint'],
-  [GL.INT_SAMPLER_CUBE]: ['cube', 'sint'],
-  [GL.INT_SAMPLER_2D_ARRAY]: ['2d-array', 'uint'],
-  [GL.UNSIGNED_INT_SAMPLER_2D]: ['2d', 'uint'],
-  [GL.UNSIGNED_INT_SAMPLER_3D]: ['3d', 'uint'],
-  [GL.UNSIGNED_INT_SAMPLER_CUBE]: ['cube', 'uint'],
-  [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'uint']
-};
-
-type SamplerInfo = {
-  viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
-  sampleType: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
-};
-
-function getSamplerInfo(type: GL): SamplerInfo {
-  const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
-  if (!sampler) {
-    throw new Error('sampler');
-  }
-  const [viewDimension, sampleType] = sampler;
-  return {viewDimension, sampleType};
-}
-
 // HELPERS
 
 function parseUniformName(name: string): {name: string; length: number; isArray: boolean} {

package/src/adapter/helpers/set-uniform.ts

@@ -6,14 +6,14 @@
 
 // Uniforms
 import type {UniformValue} from '@luma.gl/core';
-import {GL, GLCompositeType, GLSamplerType} from '@luma.gl/constants';
+import {GL, GLUniformType, GLSamplerType} from '@luma.gl/constants';
 
 /** Set a raw uniform (without type conversion and caching) */
 /* eslint-disable max-len */
 export function setUniform(
   gl: WebGL2RenderingContext,
   location: WebGLUniformLocation,
-  type: GLCompositeType | GLSamplerType,
+  type: GLUniformType | GLSamplerType,
   value: UniformValue
 ): void {
   const gl2 = gl as WebGL2RenderingContext;