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

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

@@ -2,8 +2,7 @@
 // Provides a function that enables simple checking of which WebGL features are
 // available in an WebGL1 or WebGL2 environment.
 
-import {DeviceFeature} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+import {DeviceFeature} from '@luma.gl/core';
 import {isWebGL2} from '../../context/context/webgl-checks';
 import {isOldIE} from './is-old-ie';
 import {getTextureFeatures, _checkFloat32ColorAttachment} from '../converters/texture-formats';
@@ -47,7 +46,12 @@ export function getWebGLFeatures(gl: WebGLRenderingContext): Set<DeviceFeature>
 }
 
 function isFeatureSupported(gl: WebGLRenderingContext, feature: DeviceFeature): boolean {
-  const [webgl1Feature, webgl2Feature] = WEBGL_FEATURES[feature];;
+  const featureInfo = WEBGL_FEATURES[feature];
+  if (!featureInfo) {
+    return false;
+  }
+
+  const [webgl1Feature, webgl2Feature] = featureInfo || [];
 
   // Get extension name from table
   const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
@@ -100,6 +104,9 @@ export function canCompileGLSLExtension(gl: WebGLRenderingContext, extensionName
   const source = `#extension GL_${extensionName} : ${behavior}\nvoid main(void) {}`;
 
   const shader = gl.createShader(gl.VERTEX_SHADER);
+  if (!shader) {
+    throw new Error('shader');
+  }
   gl.shaderSource(shader, source);
   gl.compileShader(shader);
   const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);

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

@@ -1,11 +1,11 @@
 // luma.gl, MIT license
-import type {DeviceLimits} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+import type {DeviceLimits} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {getWebGL2Context} from '../../context/context/webgl-checks';
 
 /** Populate a WebGPU style device limits */
 export function getDeviceLimits(gl: WebGLRenderingContext): DeviceLimits {
-  const gl2: WebGL2RenderingContext = getWebGL2Context(gl);
+  const gl2: WebGL2RenderingContext | null = getWebGL2Context(gl);
   return {
     maxTextureDimension1D: 0, // WebGL does not support 1D textures
     maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),

package/src/adapter/device-helpers/get-device-info.ts

@@ -1,5 +1,5 @@
-import {DeviceInfo} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+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. */
@@ -27,23 +27,27 @@ export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
   };
 }
 
-function identifyGPUVendor(vendor: string, renderer: string): 'nvidia' | 'intel' | 'apple' | 'amd' | 'unknown' {
-  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {
+function identifyGPUVendor(vendor: string, renderer: string): 'nvidia' | 'intel' | 'apple' | 'amd' | 'software' | 'unknown' {
+  if ((/NVIDIA/i.exec(vendor)) || (/NVIDIA/i.exec(renderer))) {
     return 'nvidia';
   }
-  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {
+  if ((/INTEL/i.exec(vendor)) || (/INTEL/i.exec(renderer))) {
     return 'intel';
   }
-  if (vendor.match(/Apple/i) || renderer.match(/Apple/i)) {
+  if ((/Apple/i.exec(vendor)) || (/Apple/i.exec(renderer))) {
     return 'apple';
   }
   if (
-    vendor.match(/AMD/i) ||
-    renderer.match(/AMD/i) ||
-    vendor.match(/ATI/i) ||
-    renderer.match(/ATI/i)
+    (/AMD/i.exec(vendor)) ||
+    (/AMD/i.exec(renderer)) ||
+    (/ATI/i.exec(vendor)) ||
+    (/ATI/i.exec(renderer))
   ) {
     return 'amd';
   }
+  if ((/SwiftShader/i.exec(vendor)) || (/SwiftShader/i.exec(renderer))) {
+    return 'software';
+  }
+  
   return 'unknown';
 }

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

@@ -1,8 +1,7 @@
-import GL from '@luma.gl/constants';
-import {GLDrawMode, GLPrimitive} from '../../types/webgl';
+import {GL, GLPrimitiveTopology, GLPrimitive} from '@luma.gl/constants';
 
 // Counts the number of complete primitives given a number of vertices and a drawMode
-export function getPrimitiveDrawMode(drawMode: GLDrawMode): GLPrimitive {
+export function getPrimitiveDrawMode(drawMode: GLPrimitiveTopology): GLPrimitive {
   switch (drawMode) {
     case GL.POINTS:
       return GL.POINTS;
@@ -24,7 +23,7 @@ export function getPrimitiveDrawMode(drawMode: GLDrawMode): GLPrimitive {
 }
 
 // Counts the number of complete "primitives" given a number of vertices and a drawMode
-export function getPrimitiveCount(options: {drawMode: GLDrawMode, vertexCount: number}): number {
+export function getPrimitiveCount(options: {drawMode: GLPrimitiveTopology, vertexCount: number}): number {
   const {drawMode, vertexCount} = options;
   switch (drawMode) {
     case GL.POINTS:
@@ -45,7 +44,7 @@ export function getPrimitiveCount(options: {drawMode: GLDrawMode, vertexCount: n
 }
 
 // Counts the number of vertices after splitting the vertex stream into separate "primitives"
-export function getVertexCount(options: {drawMode: GLDrawMode, vertexCount: number}): number {
+export function getVertexCount(options: {drawMode: GLPrimitiveTopology, vertexCount: number}): number {
   const {drawMode, vertexCount} = options;
   const primitiveCount = getPrimitiveCount({drawMode, vertexCount});
   switch (getPrimitiveDrawMode(drawMode)) {

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

@@ -0,0 +1,40 @@
+// luma.gl, MIT license
+
+// Note: This was the only dependency that made @luma.gl/webgl depend on @luma.gl/shadertools
+// This file was coped from shadertools to avoid the dependency
+
+/** Information extracted from shader source code */
+export type ShaderInfo = {
+  name: string;
+  language: 'glsl' | 'wgsl';
+  version: number;
+};
+
+/** Extracts information from shader source code */
+export function getShaderInfo(source: string, defaultName?: string): ShaderInfo {
+  return {
+    name: getShaderName(source, defaultName),
+    language: 'glsl',
+    version: getShaderVersion(source)
+  };
+}
+
+/** Extracts GLSLIFY style naming of shaders: `#define SHADER_NAME ...` */
+function getShaderName(shader: string, defaultName: string = 'unnamed'): string {
+  const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+  const match = SHADER_NAME_REGEXP.exec(shader);
+  return match ? match[1] : defaultName;
+}
+
+/** returns GLSL shader version of given shader string */
+function getShaderVersion(source: string): number {
+  let version = 100;
+  const words = source.match(/[^\s]+/g);
+  if (words && words.length >= 2 && words[0] === '#version') {
+    const v = parseInt(words[1], 10);
+    if (Number.isFinite(v)) {
+      version = v;
+    }
+  }
+  return version;
+}

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

@@ -1,37 +1,42 @@
-import {
+// luma.gl, MIT license
+
+import type {
   ShaderLayout,
-  BindingLayout,
+  AttributeLayout,
   UniformBinding,
   UniformBlockBinding,
-  ProgramBindings,
   AttributeBinding,
   VaryingBinding,
-  AttributeLayout,
-  AccessorObject
-} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+  AccessorObject,
+  BufferMapping,
+  VertexFormat
+} 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 {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';
+
 /**
  * Extract metadata describing binding information for a program's shaders
  * Note: `linkProgram()` needs to have been called
  * (although linking does not need to have been successful).
  */
 export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram): ShaderLayout {
-  const programBindings = getProgramBindings(gl, program);
-
   const shaderLayout: ShaderLayout = {
     attributes: [],
     bindings: []
   };
 
-  for (const attribute of programBindings.attributes) {
+  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, attribute.accessor.size);
+      getVertexFormat(attribute.accessor.type || GL.FLOAT, size);
     shaderLayout.attributes.push({
       name: attribute.name,
       location: attribute.location,
@@ -41,8 +46,9 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
   }
 
   // Uniform blocks
-  for (const uniformBlock of programBindings.uniformBlocks) {
-    const uniforms = uniformBlock.uniforms.map((uniform) => ({
+  const uniformBlocks: UniformBlockBinding[] = readUniformBlocks(gl, program);
+  for (const uniformBlock of uniformBlocks) {
+    const uniforms = uniformBlock.uniforms.map(uniform => ({
       name: uniform.name,
       format: uniform.format,
       byteOffset: uniform.byteOffset,
@@ -59,8 +65,9 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
     });
   }
 
+  const uniforms: UniformBinding[] = readUniformBindings(gl, program);
   let textureUnit = 0;
-  for (const uniform of programBindings.uniforms) {
+  for (const uniform of uniforms) {
     if (isSamplerUniform(uniform.type)) {
       const {viewDimension, sampleType} = getSamplerInfo(uniform.type);
       shaderLayout.bindings.push({
@@ -77,38 +84,95 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
     }
   }
 
-  const uniforms = programBindings.uniforms?.filter((uniform) => uniform.location !== null) || [];
   if (uniforms.length) {
     shaderLayout.uniforms = uniforms;
   }
-  if (programBindings.varyings?.length) {
-    shaderLayout.varyings = programBindings.varyings;
+
+  // Varyings
+  const varyings: VaryingBinding[] = readVaryings(gl, program);
+  // Note - samplers are always in unform bindings, even if uniform blocks are used
+  if (varyings?.length) {
+    shaderLayout.varyings = varyings;
   }
 
   return shaderLayout;
 }
 
 /**
- * Extract metadata describing binding information for a program's shaders
- * Note: `linkProgram()` needs to have been called
- * (although linking does not need to have been successful).
+ * 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 getProgramBindings(
-  gl: WebGLRenderingContext,
-  program: WebGLProgram
-): ProgramBindings {
-  const config: ProgramBindings = {
-    attributes: readAttributeBindings(gl, program),
-    uniforms: readUniformBindings(gl, program),
-    uniformBlocks: readUniformBlocks(gl, program),
-    varyings: readVaryings(gl, program)
+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;
+}
 
-  Object.seal(config);
-  return config;
-  // generateWebGPUStyleBindings(bindings);
+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
+
 /**
  * Extract info about all transform feedback varyings
  *
@@ -123,7 +187,11 @@ function readAttributeBindings(
   const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
 
   for (let index = 0; index < count; index++) {
-    const {name, type: compositeType, size} = gl.getActiveAttrib(program, index);
+    const activeInfo = gl.getActiveAttrib(program, index);
+    if (!activeInfo) {
+      throw new Error('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
@@ -158,7 +226,11 @@ function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): Varying
 
   const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
-    const {name, type: compositeType, size} = gl2.getTransformFeedbackVarying(program, location);
+    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
+    if (!activeInfo) {
+      throw new Error('activeInfo');
+    }
+    const {name, type: compositeType, size} = activeInfo;
     const {glType, components} = decodeUniformType(compositeType);
     const accessor = new Accessor({type: glType, size: size * components});
     const varying = {location, name, accessor}; // Base values
@@ -179,7 +251,11 @@ function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram):
 
   const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
   for (let i = 0; i < uniformCount; i++) {
-    const {name: rawName, size, type} = gl.getActiveUniform(program, i);
+    const activeInfo = gl.getActiveUniform(program, i);
+    if (!activeInfo) {
+      throw new Error('activeInfo');
+    }
+    const {name: rawName, size, type} = activeInfo;
     const {name, isArray} = parseUniformName(rawName);
     let webglLocation = gl.getUniformLocation(program, name);
     const uniformInfo = {
@@ -234,8 +310,8 @@ function readUniformBlocks(
 
   const blockCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
-    const blockInfo = {
-      name: gl2.getActiveUniformBlockName(program, blockIndex),
+    const blockInfo: UniformBlockBinding = {
+      name: gl2.getActiveUniformBlockName(program, blockIndex) || '',
       location: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_BINDING),
       byteLength: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_DATA_SIZE),
       vertex: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
@@ -244,33 +320,39 @@ function readUniformBlocks(
       uniforms: [] as any[]
     };
 
-    const uniformIndices = getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
+    const uniformIndices =
+      (getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) as number[]) || [];
 
     const uniformType = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
     const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
-    const uniformBlockIndex = gl2.getActiveUniforms(
-      program,
-      uniformIndices,
-      GL.UNIFORM_BLOCK_INDEX
-    ); // Array of GLint indicating the block indices of the uniforms.
+    // const uniformBlockIndex = gl2.getActiveUniforms(
+    //   program,
+    //   uniformIndices,
+    //   GL.UNIFORM_BLOCK_INDEX
+    // ); // Array of GLint indicating the block indices of the uniforms.
     const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
     const uniformStride = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
-    const uniformMatrixStride = gl2.getActiveUniforms(
-      program,
-      uniformIndices,
-      GL.UNIFORM_MATRIX_STRIDE
-    ); // Array of GLint indicating the strides between columns of a column-major matrix or a row-major matrix.
-    const uniformRowMajor = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
+    // const uniformMatrixStride = gl2.getActiveUniforms(
+    //   program,
+    //   uniformIndices,
+    //   GL.UNIFORM_MATRIX_STRIDE
+    // ); // Array of GLint indicating the strides between columns of a column-major matrix or a row-major matrix.
+    // const uniformRowMajor = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
+      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
+      if (!activeInfo) {
+        throw new Error('activeInfo');
+      }
+
       blockInfo.uniforms.push({
-        name: gl2.getActiveUniform(program, uniformIndices[i]).name,
+        name: activeInfo.name,
         format: decodeUniformType(uniformType[i]).format,
         type: uniformType[i],
         arrayLength: uniformArrayLength[i],
         byteOffset: uniformOffset[i],
-        byteStride: uniformStride[i],
-        matrixStride: uniformStride[i],
-        rowMajor: uniformRowMajor[i]
+        byteStride: uniformStride[i]
+        // matrixStride: uniformStride[i],
+        // rowMajor: uniformRowMajor[i]
       });
     }
 
@@ -305,18 +387,18 @@ const SAMPLER_UNIFORMS_GL_TO_GPU: Record<
   [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'uint']
 };
 
-function getSamplerInfo(type: GL):
-  | {
-      viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
-      sampleType: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
-    }
-  | undefined {
-  let sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
-  if (sampler) {
-    const [viewDimension, sampleType] = sampler;
-    return {viewDimension, sampleType};
+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');
   }
-  return null;
+  const [viewDimension, sampleType] = sampler;
+  return {viewDimension, sampleType};
 }
 
 // HELPERS
@@ -333,7 +415,7 @@ function parseUniformName(name: string): {name: string; length: number; isArray:
 
   // if array name then clean the array brackets
   const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-  const matches = name.match(UNIFORM_NAME_REGEXP);
+  const matches = UNIFORM_NAME_REGEXP.exec(name);
   if (!matches || matches.length < 2) {
     throw new Error(`Failed to parse GLSL uniform name ${name}`);
   }
@@ -347,11 +429,11 @@ function parseUniformName(name: string): {name: string; length: number; isArray:
 
 /**
  * TODO - verify this is a copy of above and delete
- * import type {TextureFormat} from '@luma.gl/api';
+ * 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, program): Binding[] {
+ function getUniformBlockBindings(gl: WebGLRenderingContext, program): Binding[] {
   if (!isWebGL2(gl)) {
     return;
   }

package/src/adapter/helpers/parse-shader-compiler-log.ts

@@ -1,5 +1,5 @@
 // luma.gl, MIT license
-import type {CompilerMessage} from '@luma.gl/shadertools';
+import type {CompilerMessage} from '@luma.gl/core';
 
 const MESSAGE_TYPES = ['warning', 'error', 'info'];
 
@@ -16,7 +16,7 @@ export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessag
 
   for (const line of lines) {
     if (line.length <= 1) {
-      continue;
+      continue; // eslint-disable-line no-continue
     }
 
     const segments: string[] = line.split(':');

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

@@ -1,5 +1,7 @@
+/* eslint-disable */
+
 // Uniforms
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
 
 /** Set a raw uniform (without type conversion and caching) */
 /* eslint-disable max-len */
@@ -7,7 +9,7 @@ export function setUniform(
   gl: WebGLRenderingContext,
   location: WebGLUniformLocation,
   type: GL,
-  value: number | Float32Array | Int32Array | Uint32Array
+  value: number | Float32Array | Int32Array | Uint32Array | boolean
 ): void {
   const gl2 = gl as WebGL2RenderingContext;
 
@@ -35,13 +37,12 @@ export function setUniform(
     }
   }
 
-  // @ts-expect-error
   if (value === true) {
     value = 1;
   }
-  // @ts-expect-error
+
   if (value === false) {
-    value = 1;
+    value = 0;
   }
   const arrayValue = (typeof value === 'number') ? [value] : value;
 
@@ -60,7 +61,7 @@ export function setUniform(
     case GL.BOOL: return gl.uniform1iv(location, arrayValue);
     case GL.BOOL_VEC2: return gl.uniform2iv(location, arrayValue);
     case GL.BOOL_VEC3: return gl.uniform3iv(location, arrayValue);
-    case GL.BOOL_VEC4: gl.uniform4iv(location, arrayValue);
+    case GL.BOOL_VEC4: return gl.uniform4iv(location, arrayValue);
 
     // WEBGL2 - unsigned integers
     case GL.UNSIGNED_INT: return gl2.uniform1uiv(location, arrayValue, 1);

package/src/adapter/helpers/uniforms.ts

@@ -1,6 +1,5 @@
-import {UniformFormat, VertexFormat} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {GLUniformType, GLSamplerType, GLCompositeType, GLType} from '../../types/webgl'
+import {UniformFormat, VertexFormat} from '@luma.gl/core';
+import {GL, GLUniformType, GLSamplerType, GLCompositeType, GLDataType} from '@luma.gl/constants';
 
 /** Check is uniform is of sampler type */
 export function isSamplerUniform(type: GLUniformType): boolean {
@@ -25,8 +24,11 @@ const SAMPLER_TYPES: GLSamplerType[] = [
   GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
 ];
 
-// Composite types table 
-const COMPOSITE_GL_TYPES: Record<GLCompositeType, [GLType, number, string, UniformFormat, VertexFormat?]> = {
+// Composite types table
+const COMPOSITE_GL_TYPES: Record<
+  GLCompositeType,
+  [GLDataType, number, string, UniformFormat, VertexFormat?]
+> = {
   [GL.FLOAT]: [GL.FLOAT, 1, 'float', 'f32', 'float32'],
   [GL.FLOAT_VEC2]: [GL.FLOAT, 2, 'vec2', 'vec2<f32>', 'float32x2'],
   [GL.FLOAT_VEC3]: [GL.FLOAT, 3, 'vec3', 'vec3<f32>', 'float32x3'],
@@ -61,27 +63,35 @@ const COMPOSITE_GL_TYPES: Record<GLCompositeType, [GLType, number, string, Unifo
 };
 
 /** 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: GLType} {
+export function decodeUniformType(
+  uniformType: GL
+): {format: UniformFormat; components: number; glType: GLDataType} {
   const typeAndSize = COMPOSITE_GL_TYPES[uniformType];
   if (!typeAndSize) {
-    return null;
+    throw new Error('uniform');
   }
   const [glType, components, , format] = typeAndSize;
   return {format, components, glType};
 }
 
-export function decodeAttributeType(uniformType: GL): {format: VertexFormat, components: number, glType: GLType} {
-  const typeAndSize = COMPOSITE_GL_TYPES[uniformType];
+export function decodeAttributeType(attributeType: GL): {
+  format: VertexFormat;
+  components: number;
+  glType: GLDataType;
+} {
+  const typeAndSize = COMPOSITE_GL_TYPES[attributeType];
   if (!typeAndSize) {
-    return null;
+    throw new Error('attribute')
   }
   const [glType, components, , , format] = typeAndSize;
   return {format, components, glType};
 }
 
 /** Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3) */
-export function decomposeCompositeGLType(compositeGLType: GLCompositeType): {type: GLType, components: number} | null {
-  const typeAndSize = COMPOSITE_GL_TYPES[compositeGLType];
+export function decomposeCompositeGLDataType(
+  compositeGLDataType: GLCompositeType
+): {type: GLDataType; components: number} | null {
+  const typeAndSize = COMPOSITE_GL_TYPES[compositeGLDataType];
   if (!typeAndSize) {
     return null;
   }
@@ -89,7 +99,7 @@ export function decomposeCompositeGLType(compositeGLType: GLCompositeType): {typ
   return {type, components};
 }
 
-export function getCompositeGLType(type: GL, components): {glType: GLType, name: string} | null {
+export function getCompositeGLDataType(type: GL, components): {glType: GLDataType; name: string} | null {
   switch (type) {
     case GL.BYTE:
     case GL.UNSIGNED_BYTE: