@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.10

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

@@ -1,50 +1,36 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
-import {
+import type {
   ShaderLayout,
-  BindingLayout,
   UniformBinding,
   UniformBlockBinding,
-  ProgramBindings,
-  AttributeBinding,
-  VaryingBinding,
-  AttributeLayout,
-  AccessorObject
-} from '@luma.gl/api';
-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';
+  AttributeDeclaration,
+  VaryingBinding
+} from '@luma.gl/core';
+
+import {GL} from '@luma.gl/constants';
+import {Accessor} from '../../classic/accessor'; // TODO - should NOT depend on classic API
+import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './decode-webgl-types';
+
 /**
  * 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);
-
+export function getShaderLayout(gl: WebGL2RenderingContext, program: WebGLProgram): ShaderLayout {
   const shaderLayout: ShaderLayout = {
     attributes: [],
     bindings: []
   };
 
-  for (const attribute of programBindings.attributes) {
-    const format =
-      // attribute.accessor.format ||
-      getVertexFormat(attribute.accessor.type || GL.FLOAT, attribute.accessor.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
-  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,
@@ -61,8 +47,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({
@@ -79,48 +66,32 @@ 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).
- */
-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)
-  };
-
-  Object.seal(config);
-  return config;
-  // generateWebGPUStyleBindings(bindings);
-}
+// HELPERS
 
 /**
  * Extract info about all transform feedback varyings
  *
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
-function readAttributeBindings(
-  gl: WebGLRenderingContext,
+function readAttributeDeclarations(
+  gl: WebGL2RenderingContext,
   program: WebGLProgram
-): AttributeBinding[] {
-  const attributes: AttributeBinding[] = [];
+): AttributeDeclaration[] {
+  const attributes: AttributeDeclaration[] = [];
 
   const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
 
@@ -129,23 +100,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;
 }
 
@@ -154,22 +132,17 @@ function readAttributeBindings(
  *
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
-function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): VaryingBinding[] {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl as WebGL2RenderingContext;
-
+function readVaryings(gl: WebGL2RenderingContext, program: WebGLProgram): VaryingBinding[] {
   const varyings: VaryingBinding[] = [];
 
   const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
-    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
+    const activeInfo = gl.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
       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);
@@ -184,7 +157,7 @@ function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): Varying
  *
  * Query uniform locations and build name to setter map.
  */
-function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram): UniformBinding[] {
+function readUniformBindings(gl: WebGL2RenderingContext, program: WebGLProgram): UniformBinding[] {
   const uniforms: UniformBinding[] = [];
 
   const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
@@ -228,28 +201,21 @@ 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,
+  gl: WebGL2RenderingContext,
   program: WebGLProgram
 ): UniformBlockBinding[] {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl as WebGL2RenderingContext;
-
   const getBlockParameter = (blockIndex: number, pname: GL): any =>
-    gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
+    gl.getActiveUniformBlockParameter(program, blockIndex, pname);
 
   const uniformBlocks: UniformBlockBinding[] = [];
 
-  const blockCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo: UniformBlockBinding = {
-      name: gl2.getActiveUniformBlockName(program, blockIndex) || '',
+      name: gl.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),
@@ -258,36 +224,37 @@ function readUniformBlocks(
       uniforms: [] as any[]
     };
 
-    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 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 uniformIndices =
+      (getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) as number[]) || [];
+
+    const uniformType = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
+    const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
+    // const uniformBlockIndex = gl.getActiveUniforms(
+    //   program,
+    //   uniformIndices,
+    //   GL.UNIFORM_BLOCK_INDEX
+    // ); // Array of GLint indicating the block indices of the uniforms.
+    const uniformOffset = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
+    const uniformStride = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
+    // const uniformMatrixStride = gl.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 = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
-      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
+      const activeInfo = gl.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
         throw new Error('activeInfo');
       }
-  
+
       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],
-        byteStride: uniformStride[i],
+        byteStride: uniformStride[i]
         // matrixStride: uniformStride[i],
         // rowMajor: uniformRowMajor[i]
       });
@@ -300,6 +267,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,
   [
@@ -324,13 +312,13 @@ const SAMPLER_UNIFORMS_GL_TO_GPU: Record<
   [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'uint']
 };
 
-type SamplerInfo =   | {
+type SamplerInfo = {
   viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
   sampleType: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
 };
 
 function getSamplerInfo(type: GL): SamplerInfo {
-  let sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
+  const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
   if (!sampler) {
     throw new Error('sampler');
   }
@@ -352,7 +340,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}`);
   }
@@ -363,45 +351,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/api';
-* 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[] {
-  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/parse-shader-compiler-log.ts

@@ -1,14 +1,15 @@
-// luma.gl, MIT license
-import type {CompilerMessage} from '@luma.gl/shadertools';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
-const MESSAGE_TYPES = ['warning', 'error', 'info'];
+import type {CompilerMessage} from '@luma.gl/core';
 
 /**
  * Parse a WebGL-format GLSL compilation log into an array of WebGPU style message records.
  * This follows documented WebGL conventions for compilation logs.
  * Based on https://github.com/wwwtyro/gl-format-compiler-error (public domain)
  */
-export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessage[] {
+export function parseShaderCompilerLog(errLog: string): readonly CompilerMessage[] {
   // Parse the error - note: browser and driver dependent
   const lines = errLog.split(/\r?\n/);
 
@@ -16,10 +17,23 @@ 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(':');
+
+    // Check for messages with no line information `ERROR: unsupported shader version`
+    if (segments.length === 2) {
+      const [messageType, message] = segments;
+      messages.push({
+        message: message.trim(),
+        type: getMessageType(messageType),
+        lineNum: 0,
+        linePos: 0
+      });
+      continue; // eslint-disable-line no-continue
+    }
+
     const [messageType, linePosition, lineNumber, ...rest] = segments;
 
     let lineNum = parseInt(lineNumber, 10);
@@ -32,17 +46,23 @@ export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessag
       linePos = 0;
     }
 
-    // Ensure supported type
-    const lowerCaseType = messageType.toLowerCase();
-    const type = (MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info') as 'warning' | 'error' | 'info';
-
     messages.push({
       message: rest.join(':').trim(),
-      type,
+      type: getMessageType(messageType),
       lineNum,
       linePos // TODO
-    })
+    });
   }
 
   return messages;
 }
+
+/** Ensure supported type */
+function getMessageType(messageType: string): 'warning' | 'error' | 'info' {
+  const MESSAGE_TYPES = ['warning', 'error', 'info'];
+  const lowerCaseType = messageType.toLowerCase();
+  return (MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info') as
+    | 'warning'
+    | 'error'
+    | 'info';
+}

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

@@ -1,52 +1,55 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* 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,
+  gl: WebGL2RenderingContext,
   location: WebGLUniformLocation,
-  type: GL,
-  value: number | Float32Array | Int32Array | Uint32Array
+  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;
   }
-
-  // @ts-expect-error
-  if (value === true) {
-    value = 1;
+  if (uniformValue === false) {
+    uniformValue = 0;
   }
-  // @ts-expect-error
-  if (value === false) {
-    value = 1;
-  }
-  const arrayValue = (typeof value === 'number') ? [value] : value;
+  const arrayValue = typeof uniformValue === 'number' ? [uniformValue] : uniformValue;
 
   // prettier-ignore
   switch (type) {
+    case GL.SAMPLER_2D:
+    case GL.SAMPLER_CUBE:
+    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);
@@ -60,7 +63,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);