@luma.gl/webgl 9.0.0-alpha.30 → 9.0.0-alpha.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "9.0.0-alpha.30",
+  "version": "9.0.0-alpha.32",
   "description": "WebGL2 adapter for the luma.gl API",
   "type": "module",
   "license": "MIT",
@@ -44,12 +44,12 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/constants": "9.0.0-alpha.30",
-    "@luma.gl/core": "9.0.0-alpha.30",
+    "@luma.gl/constants": "9.0.0-alpha.32",
+    "@luma.gl/core": "9.0.0-alpha.32",
     "@probe.gl/env": "^4.0.2"
   },
   "devDependencies": {
-    "@luma.gl/test-utils": "9.0.0-alpha.30"
+    "@luma.gl/test-utils": "9.0.0-alpha.32"
   },
-  "gitHead": "7fb163f20d3400d59b59a17d36b4f3c466c559ba"
+  "gitHead": "08b30dcae4aee321738cf05b509cef6b3b24c880"
 }

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

@@ -0,0 +1,41 @@
+import {GL} from '@luma.gl/constants';
+import {ShaderAttributeType, ShaderDataType} 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 shader data type from GL constants */
+export function getShaderDataTypeFromGL(type: GL): ShaderDataType {
+  switch (type) {
+    case GL.INT: return 'i32';
+    case GL.UNSIGNED_INT: return 'u32';
+    case GL.SHORT: return 'i32';
+    case GL.UNSIGNED_SHORT: return 'u32';
+    case GL.BYTE: return 'i32';
+    case GL.UNSIGNED_BYTE: return 'u32';
+    case GL.FLOAT: return 'f32';
+    case GL.HALF_FLOAT: return 'f16';
+    default: throw new Error(String(type));
+  }
+}
+
+/** GetGL constant from shader data type */
+export function getGLFromShaderDataType(type: ShaderDataType): GL.INT | GL.UNSIGNED_INT | GL.FLOAT | GL.HALF_FLOAT {
+  switch (type) {
+    // TODO
+    case 'i32': return GL.INT;
+    case 'u32': return GL.UNSIGNED_INT;
+    case 'f32': return GL.FLOAT;
+    case 'f16': return GL.HALF_FLOAT;
+    default: throw new Error(String(type));
+  }
+}

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

@@ -2,6 +2,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';
 
 /* eslint-disable camelcase */
 
@@ -603,7 +604,8 @@ export function getWebGLTextureParameters(formatOrGL: TextureFormat | GL, isWebG
       decoded.normalized,
       webglFormat
     ),
-    type: getWebGLDataType(decoded.dataType),
+    // depth formats don't have a type
+    type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : GL.UNSIGNED_BYTE,
     // @ts-expect-error
     compressed: decoded.compressed
   };
@@ -699,18 +701,3 @@ function getWebGLPixelDataFormat(
     default: return GL.RGBA;
   }
 }
-
-export function getWebGLDataType(dataType: string): GL {
-  // prettier-ignore
-  switch (dataType) {
-    case 'uint8': return GL.UNSIGNED_BYTE;
-    case 'sint8': return GL.BYTE;
-    case 'uint16': return GL.UNSIGNED_SHORT;
-    case 'sint16': return GL.SHORT;
-    case 'uint32': return GL.UNSIGNED_INT;
-    case 'sint32': return GL.INT;
-    case 'float16': return GL.HALF_FLOAT;
-    case 'float32': return GL.FLOAT;
-    default: return GL.UNSIGNED_BYTE;
-  }
-}

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

@@ -1,23 +1,80 @@
 import {GL} from '@luma.gl/constants';
-import {VertexFormat} from '@luma.gl/core';
+import {VertexFormat, VertexType} from '@luma.gl/core';
 
-export function getVertexFormat(type: GL, components: number): VertexFormat {
-  const base = getDataFormat(type);
+type GLDataType = 
+  | GL.UNSIGNED_BYTE
+  | GL.BYTE
+  | GL.UNSIGNED_SHORT
+  | GL.SHORT
+  | GL.UNSIGNED_INT
+  | GL.INT
+  | GL.HALF_FLOAT
+  | GL.FLOAT;
+
+
+/** 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`;
-    default: throw new Error(String(components));
   }
+  // @ts-ignore unreachable
+  throw new Error(String(components));
 }
 
-function getDataFormat(type: GL): 'sint32' | 'uint32' | 'float32' {
+/** Get data type from GL constants */
+export function getVertexTypeFromGL(type: GLDataType, normalized = false): VertexType {
+  // prettier-ignore
   switch (type) {
-    // TODO
-    case GL.INT: return 'sint32';
-    case GL.UNSIGNED_INT: return 'uint32';
+    // WebGPU does not support normalized 32 bit integer attributes
+    case GL.INT: return normalized ? 'sint32' : 'sint32';
+    case GL.UNSIGNED_INT: return normalized ? 'uint32' : 'uint32';
+    case GL.SHORT: return normalized ? 'sint16' : 'unorm16';
+    case GL.UNSIGNED_SHORT: return normalized ? 'uint16' : 'unorm16';
+    case GL.BYTE: return normalized ? 'sint8' : 'snorm16';
+    case GL.UNSIGNED_BYTE: return normalized ? 'uint8' : 'unorm8';
     case GL.FLOAT: return 'float32';
-    default: throw new Error(String(type));
+    case GL.HALF_FLOAT: return 'float16';
+  }
+  // @ts-ignore unreachable
+  throw new Error(String(type));
+}
+
+export function getGLFromVertexType(
+  dataType: VertexType
+):
+  | GL.UNSIGNED_BYTE
+  | GL.BYTE
+  | GL.UNSIGNED_SHORT
+  | GL.SHORT
+  | GL.UNSIGNED_INT
+  | GL.INT
+  | GL.HALF_FLOAT
+  | GL.FLOAT {
+  // prettier-ignore
+  switch (dataType) {
+    case 'uint8': return GL.UNSIGNED_BYTE;
+    case 'sint8': return GL.BYTE;
+    case 'unorm8': return GL.UNSIGNED_BYTE;
+    case 'snorm8': return GL.BYTE;
+    case 'uint16': return GL.UNSIGNED_SHORT;
+    case 'sint16': return GL.SHORT;
+    case 'unorm16': return GL.UNSIGNED_SHORT;
+    case 'snorm16': return GL.SHORT;
+    case 'uint32': return GL.UNSIGNED_INT;
+    case 'sint32': return GL.INT;
+    // WebGPU does not support normalized 32 bit integer attributes
+    // case 'unorm32': return GL.UNSIGNED_INT;
+    // case 'snorm32': return GL.INT;
+    case 'float16': return GL.HALF_FLOAT;
+    case 'float32': return GL.FLOAT;
   }
-}
+  // @ts-ignore unreachable
+  throw new Error(String(dataType));
+}

package/src/adapter/helpers/{uniforms.ts → decode-webgl-types.ts}

@@ -1,4 +1,4 @@
-import {UniformFormat, VertexFormat} from '@luma.gl/core';
+import {ShaderUniformType, ShaderAttributeType, VertexFormat} from '@luma.gl/core';
 import {GL, GLUniformType, GLSamplerType, GLCompositeType, GLDataType} from '@luma.gl/constants';
 
 /** Check is uniform is of sampler type */
@@ -27,7 +27,7 @@ const SAMPLER_TYPES: GLSamplerType[] = [
 // Composite types table
 const COMPOSITE_GL_TYPES: Record<
   GLCompositeType,
-  [GLDataType, number, string, UniformFormat, VertexFormat?]
+  [GLDataType, number, string, ShaderUniformType, VertexFormat?]
 > = {
   [GL.FLOAT]: [GL.FLOAT, 1, 'float', 'f32', 'float32'],
   [GL.FLOAT_VEC2]: [GL.FLOAT, 2, 'vec2', 'vec2<f32>', 'float32x2'],
@@ -44,11 +44,12 @@ const COMPOSITE_GL_TYPES: Record<
   [GL.UNSIGNED_INT_VEC3]: [GL.UNSIGNED_INT, 3, 'uvec3', 'vec3<u32>', 'uint32x3'],
   [GL.UNSIGNED_INT_VEC4]: [GL.UNSIGNED_INT, 4, 'uvec4', 'vec4<u32>', 'uint32x4'],
 
-  [GL.BOOL]: [GL.FLOAT, 1, 'bool', 'f32', 'float32x2'],
-  [GL.BOOL_VEC2]: [GL.FLOAT, 2, 'bvec2', 'vec2<f32>'],
-  [GL.BOOL_VEC3]: [GL.FLOAT, 3, 'bvec3', 'vec3<f32>'],
-  [GL.BOOL_VEC4]: [GL.FLOAT, 4, 'bvec4', 'vec4<f32>'],
+  [GL.BOOL]: [GL.FLOAT, 1, 'bool', 'f32', 'float32'],
+  [GL.BOOL_VEC2]: [GL.FLOAT, 2, 'bvec2', 'vec2<f32>', 'float32x2'],
+  [GL.BOOL_VEC3]: [GL.FLOAT, 3, 'bvec3', 'vec3<f32>', 'float32x3'],
+  [GL.BOOL_VEC4]: [GL.FLOAT, 4, 'bvec4', 'vec4<f32>', 'float32x4'],
 
+  // TODO - are sizes/components below correct?
   [GL.FLOAT_MAT2]: [GL.FLOAT, 8, 'mat2', 'mat2x2<f32>'], // 4
   [GL.FLOAT_MAT2x3]: [GL.FLOAT, 8, 'mat2x3', 'mat2x3<f32>'], // 6
   [GL.FLOAT_MAT2x4]: [GL.FLOAT, 8, 'mat2x4', 'mat2x4<f32>'], // 8
@@ -62,11 +63,11 @@ const COMPOSITE_GL_TYPES: Record<
   [GL.FLOAT_MAT4]: [GL.FLOAT, 16, 'mat4', 'mat4x4<f32>'] // 16
 };
 
-/** Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3) */
-export function decodeUniformType(
-  uniformType: GL
-): {format: UniformFormat; components: number; glType: GLDataType} {
-  const typeAndSize = COMPOSITE_GL_TYPES[uniformType];
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
+export function decodeGLUniformType(
+  glUniformType: GL
+): {format: ShaderUniformType; components: number; glType: GLDataType} {
+  const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
   if (!typeAndSize) {
     throw new Error('uniform');
   }
@@ -74,17 +75,21 @@ export function decodeUniformType(
   return {format, components, glType};
 }
 
-export function decodeAttributeType(attributeType: GL): {
-  format: VertexFormat;
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
+export function decodeGLAttributeType(glAttributeType: GL): {
+  attributeType: ShaderAttributeType;
+  vertexFormat: VertexFormat;
   components: number;
-  glType: GLDataType;
+  // glType: GLDataType;
 } {
-  const typeAndSize = COMPOSITE_GL_TYPES[attributeType];
+  const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType];
   if (!typeAndSize) {
     throw new Error('attribute')
   }
-  const [glType, components, , , format] = typeAndSize;
-  return {format, components, glType};
+  const [, components, , shaderType, vertexFormat] = typeAndSize;
+  // TODO sanity - if (shaderType.startsWith('mat' ...))
+  const attributeType = shaderType as unknown as ShaderAttributeType
+  return {attributeType, vertexFormat, components}; // , glType};
 }
 
 /** Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3) */

package/src/adapter/helpers/get-shader-layout.ts

@@ -2,22 +2,16 @@
 
 import type {
   ShaderLayout,
-  AttributeLayout,
   UniformBinding,
   UniformBlockBinding,
-  AttributeBinding,
-  VaryingBinding,
-  AccessorObject,
-  BufferMapping,
-  VertexFormat
+  AttributeDeclaration,
+  VaryingBinding
 } from '@luma.gl/core';
-import {log} from '@luma.gl/core';
+
 import {GL} from '@luma.gl/constants';
 import {isWebGL2} from '../../context/context/webgl-checks';
 import {Accessor} from '../../classic/accessor'; // TODO - should NOT depend on classic API
-import {decodeUniformType, decodeAttributeType} from './uniforms';
-import {getVertexFormat} from '../converters/vertex-formats';
-import {isSamplerUniform} from './uniforms';
+import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './decode-webgl-types';
 
 /**
  * Extract metadata describing binding information for a program's shaders
@@ -30,20 +24,7 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
     bindings: []
   };
 
-  const attributes: AttributeBinding[] = readAttributeBindings(gl, program);
-  for (const attribute of attributes) {
-    // TODO - multicolumn attributes like a matrix4 can be up to 16 elts...
-    const size = Math.min(attribute.accessor.size, 4);
-    const format =
-      // attribute.accessor.format ||
-      getVertexFormat(attribute.accessor.type || GL.FLOAT, size);
-    shaderLayout.attributes.push({
-      name: attribute.name,
-      location: attribute.location,
-      format,
-      stepMode: attribute.accessor.divisor === 1 ? 'instance' : 'vertex'
-    });
-  }
+  shaderLayout.attributes = readAttributeDeclarations(gl, program);
 
   // Uniform blocks
   const uniformBlocks: UniformBlockBinding[] = readUniformBlocks(gl, program);
@@ -98,79 +79,6 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
   return shaderLayout;
 }
 
-/**
- * Merges an provided shader layout into a base shader layout
- * In WebGL, this allows the auto generated shader layout to be overridden by the application
- * Typically to change the format of the vertex attributes (from float32x4 to uint8x4 etc).
- * @todo Drop this? This could also be done more clearly with bufferMapping
- */
-export function mergeShaderLayout(
-  baseLayout: ShaderLayout,
-  overrideLayout: ShaderLayout
-): ShaderLayout {
-  // Deep clone the base layout
-  const mergedLayout: ShaderLayout = {
-    ...baseLayout,
-    attributes: baseLayout.attributes.map(attribute => ({...attribute}))
-  };
-  // Merge the attributes
-  for (const attribute of overrideLayout?.attributes || []) {
-    const baseAttribute = mergedLayout.attributes.find(attr => attr.name === attribute.name);
-    if (!baseAttribute) {
-      log.warn(`shader layout attribute ${attribute.name} not present in shader`);
-    } else {
-      baseAttribute.format = attribute.format || baseAttribute.format;
-      baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
-    }
-  }
-  return mergedLayout;
-}
-
-export function mergeBufferMap(baseLayout: ShaderLayout, bufferMap: BufferMapping[]): ShaderLayout {
-  // Deep clone the base layout
-  const mergedLayout: ShaderLayout = {
-    ...baseLayout,
-    attributes: baseLayout.attributes.map(attribute => ({...attribute}))
-  };
-  for (const bufferMapping of bufferMap) {
-    // Handle interleave
-    switch (bufferMapping.type) {
-      case 'interleave':
-        // Handle interleaved buffer mapping
-        for (const attributeOverride of bufferMapping.attributes) {
-          overrideShaderLayoutAttribute(mergedLayout, attributeOverride);
-        }
-        break;
-
-      default:
-        // Handle simple attribute overrides
-        overrideShaderLayoutAttribute(mergedLayout, bufferMapping);
-    }
-  }
-  return mergedLayout;
-}
-
-function overrideShaderLayoutAttribute(
-  layout: ShaderLayout,
-  attributeOverride: {name: string; format?: VertexFormat}
-): void {
-  const attribute = getAttributeFromLayout(layout, attributeOverride.name);
-  if (attribute && attributeOverride.format) {
-    attribute.format = attributeOverride.format;
-  }
-}
-
-export function getAttributeFromLayout(
-  shaderLayout: ShaderLayout,
-  name: string
-): AttributeLayout | null {
-  const attribute = shaderLayout.attributes.find(attr => attr.name === name);
-  if (!attribute) {
-    log.warn(`shader layout attribute "${name}" not present in shader`);
-  }
-  return attribute || null;
-}
-
 // HELPERS
 
 /**
@@ -178,11 +86,11 @@ export function getAttributeFromLayout(
  *
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
-function readAttributeBindings(
+function readAttributeDeclarations(
   gl: WebGLRenderingContext,
   program: WebGLProgram
-): AttributeBinding[] {
-  const attributes: AttributeBinding[] = [];
+): AttributeDeclaration[] {
+  const attributes: AttributeDeclaration[] = [];
 
   const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
 
@@ -191,23 +99,30 @@ function readAttributeBindings(
     if (!activeInfo) {
       throw new Error('activeInfo');
     }
-    const {name, type: compositeType, size} = activeInfo;
+    const {name, type: compositeType /* , size*/} = activeInfo;
     const location = gl.getAttribLocation(program, name);
-    // Add only user provided attributes, for built-in attributes like
-    // `gl_InstanceID` locaiton will be < 0
+    // Add only user provided attributes, for built-in attributes like `gl_InstanceID` location will be < 0
     if (location >= 0) {
-      const {glType, components} = decodeAttributeType(compositeType);
-      const accessor: AccessorObject = {type: glType, size: size * components};
-      // Any attribute name containing the word "instance" will be assumed to be instanced
-      if (/instance/i.test(name)) {
-        accessor.divisor = 1;
-      }
-      const attributeInfo = {location, name, accessor: new Accessor(accessor)}; // Base values
-      attributes.push(attributeInfo);
+      const {attributeType} = decodeGLAttributeType(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.
+      // There is no hint in the shader declarations
+      // Heuristic: Any attribute name containing the word "instance" will be assumed to be instanced
+      const stepMode = /instance/i.test(name) ? 'instance' : 'vertex';
+
+      attributes.push({
+        name,
+        location,
+        stepMode,
+        type: attributeType,
+        // size - for arrays, size is the number of elements in the array
+      });
     }
   }
 
-  attributes.sort((a: AttributeBinding, b: AttributeBinding) => a.location - b.location);
+  // Sort by declaration order
+  attributes.sort((a: AttributeDeclaration, b: AttributeDeclaration) => a.location - b.location);
   return attributes;
 }
 
@@ -231,7 +146,7 @@ function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): Varying
       throw new Error('activeInfo');
     }
     const {name, type: compositeType, size} = activeInfo;
-    const {glType, components} = decodeUniformType(compositeType);
+    const {glType, components} = decodeGLUniformType(compositeType);
     const accessor = new Accessor({type: glType, size: size * components});
     const varying = {location, name, accessor}; // Base values
     varyings.push(varying);
@@ -290,9 +205,7 @@ function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram):
 
 /**
  * Extract info about all "active" uniform blocks
- *
- * ("Active" just means that unused (aka inactive) blocks may have been
- * optimized away during linking)
+ * @note In WebGL, "active" just means that unused (inactive) blocks may have been optimized away during linking)
  */
 function readUniformBlocks(
   gl: WebGLRenderingContext,
@@ -346,7 +259,7 @@ function readUniformBlocks(
 
       blockInfo.uniforms.push({
         name: activeInfo.name,
-        format: decodeUniformType(uniformType[i]).format,
+        format: decodeGLUniformType(uniformType[i]).format,
         type: uniformType[i],
         arrayLength: uniformArrayLength[i],
         byteOffset: uniformOffset[i],
@@ -363,6 +276,27 @@ function readUniformBlocks(
   return uniformBlocks;
 }
 
+/**
+ * TOOD - compare with a above, confirm copy, then delete
+  const bindings: Binding[] = [];
+  const count = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);
+  for (let blockIndex = 0; blockIndex < count; blockIndex++) {
+    const vertex = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
+    const fragment = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+    const visibility = (vertex) + (fragment);
+    const binding: BufferBinding = {
+      location: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_BINDING),
+      // name: gl.getActiveUniformBlockName(program, blockIndex),
+      type: 'uniform',
+      visibility,
+      minBindingSize: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),
+      // uniformCount: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      // uniformIndices: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
+    }
+    bindings.push(binding);
+  }
+*/
+
 const SAMPLER_UNIFORMS_GL_TO_GPU: Record<
   number,
   [
@@ -426,45 +360,3 @@ function parseUniformName(name: string): {name: string; length: number; isArray:
     isArray: Boolean(matches[2])
   };
 }
-
-/**
- * TODO - verify this is a copy of above and delete
- * import type {TextureFormat} from '@luma.gl/core';
-* Extract info about all "active" uniform blocks
- * ("Active" just means that unused (inactive) blocks may have been optimized away during linking)
- *
- function getUniformBlockBindings(gl: WebGLRenderingContext, program): Binding[] {
-  if (!isWebGL2(gl)) {
-    return;
-  }
-  const bindings: Binding[] = [];
-  const count = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);
-  for (let blockIndex = 0; blockIndex < count; blockIndex++) {
-    const vertex = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-    const fragment = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-    const visibility = (vertex) + (fragment);
-    const binding: BufferBinding = {
-      location: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_BINDING),
-      // name: gl.getActiveUniformBlockName(program, blockIndex),
-      type: 'uniform',
-      visibility,
-      minBindingSize: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),
-      // uniformCount: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
-      // uniformIndices: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
-    }
-    bindings.push(binding);
-  }
-  return bindings;
-}
-
-function setBindings(gl2: WebGL2RenderingContext, program: WebGLProgram, bindings: Binding[][]): void {
-  for (const bindGroup of bindings) {
-    for (const binding of bindGroup) {
-
-    }
-  }
-
-  // Set up indirection table
-  // this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);
-}
- */

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

@@ -1,53 +1,53 @@
 /* eslint-disable */
 
 // Uniforms
-import {GL} from '@luma.gl/constants';
+import type {UniformValue} from '@luma.gl/core';
+import {GL, GLCompositeType, GLSamplerType} from '@luma.gl/constants';
 
 /** Set a raw uniform (without type conversion and caching) */
 /* eslint-disable max-len */
 export function setUniform(
   gl: WebGLRenderingContext,
   location: WebGLUniformLocation,
-  type: GL,
-  value: number | Float32Array | Int32Array | Uint32Array | boolean
+  type: GLCompositeType | GLSamplerType,
+  value: UniformValue
 ): void {
   const gl2 = gl as WebGL2RenderingContext;
 
-  if (typeof value === 'number') {
-    // prettier-ignore
-    switch (type) {
-      // WebGL1 samplers
-      case GL.SAMPLER_2D:
-      case GL.SAMPLER_CUBE:
-      // WebGL2 samplers
-      case GL.SAMPLER_3D:
-      case GL.SAMPLER_2D_SHADOW:
-      case GL.SAMPLER_2D_ARRAY:
-      case GL.SAMPLER_2D_ARRAY_SHADOW:
-      case GL.SAMPLER_CUBE_SHADOW:
-      case GL.INT_SAMPLER_2D:
-      case GL.INT_SAMPLER_3D:
-      case GL.INT_SAMPLER_CUBE:
-      case GL.INT_SAMPLER_2D_ARRAY:
-      case GL.UNSIGNED_INT_SAMPLER_2D:
-      case GL.UNSIGNED_INT_SAMPLER_3D:
-      case GL.UNSIGNED_INT_SAMPLER_CUBE:
-      case GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
-        return gl.uniform1i(location, value);
-    }
+  // Prepare the value for WebGL setters
+  let uniformValue = value;
+  if (uniformValue === true) {
+    uniformValue = 1;
   }
-
-  if (value === true) {
-    value = 1;
-  }
-
-  if (value === false) {
-    value = 0;
+  if (uniformValue === false) {
+    uniformValue = 0;
   }
-  const arrayValue = (typeof value === 'number') ? [value] : value;
+  const arrayValue = typeof uniformValue === 'number' ? [uniformValue] : uniformValue;
 
   // prettier-ignore
   switch (type) {
+    // WebGL1 samplers
+    case GL.SAMPLER_2D:
+    case GL.SAMPLER_CUBE:
+    // WebGL2 samplers
+    case GL.SAMPLER_3D:
+    case GL.SAMPLER_2D_SHADOW:
+    case GL.SAMPLER_2D_ARRAY:
+    case GL.SAMPLER_2D_ARRAY_SHADOW:
+    case GL.SAMPLER_CUBE_SHADOW:
+    case GL.INT_SAMPLER_2D:
+    case GL.INT_SAMPLER_3D:
+    case GL.INT_SAMPLER_CUBE:
+    case GL.INT_SAMPLER_2D_ARRAY:
+    case GL.UNSIGNED_INT_SAMPLER_2D:
+    case GL.UNSIGNED_INT_SAMPLER_3D:
+    case GL.UNSIGNED_INT_SAMPLER_CUBE:
+    case GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
+      if (typeof value !== 'number') {
+        throw new Error('samplers must be set to integers');
+      }
+      return gl.uniform1i(location, value);
+
     case GL.FLOAT: return gl.uniform1fv(location, arrayValue);
     case GL.FLOAT_VEC2: return gl.uniform2fv(location, arrayValue);
     case GL.FLOAT_VEC3: return gl.uniform3fv(location, arrayValue);

package/src/adapter/objects/webgl-vertex-array-object.ts

@@ -8,6 +8,7 @@ import {WebGLResource} from './webgl-resource';
 import {WEBGLBuffer} from '../resources/webgl-buffer';
 
 import {BufferWithAccessor} from '../../classic/buffer-with-accessor';
+import {AccessorObject} from '../..';
 
 const ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
 
@@ -93,7 +94,7 @@ export class WEBGLVertexArrayObject extends WebGLResource<VertexArrayObjectProps
   }
 
   /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
-  setBuffer(location: number, buffer: WEBGLBuffer, accessor: any): void {
+  setBuffer(location: number, buffer: WEBGLBuffer, accessor: AccessorObject): void {
     // Check target
     if (buffer.glTarget === GL.ELEMENT_ARRAY_BUFFER) {
       this.setElementBuffer(buffer, accessor);

package/src/adapter/resources/webgl-command-encoder.ts

@@ -15,7 +15,7 @@ export class WEBGLCommandEncoder extends CommandEncoder {
   readonly commandBuffer: WEBGLCommandBuffer;
 
   constructor(device: WebGLDevice, props: CommandEncoderProps) {
-    super(props);
+    super(device, props);
     this.device = device;
     this.commandBuffer = new WEBGLCommandBuffer(device);
   }