@luma.gl/webgl 9.0.0-beta.4 → 9.0.0-beta.5

package/dist/adapter/helpers/get-shader-layout.d.ts

@@ -4,5 +4,5 @@ import type { ShaderLayout } from '@luma.gl/core';
  * Note: `linkProgram()` needs to have been called
  * (although linking does not need to have been successful).
  */
-export declare function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram): ShaderLayout;
+export declare function getShaderLayout(gl: WebGL2RenderingContext, program: WebGLProgram): ShaderLayout;
 //# sourceMappingURL=get-shader-layout.d.ts.map

package/dist/adapter/helpers/get-shader-layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-shader-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-shader-layout.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EAKb,MAAM,eAAe,CAAC;AAOvB;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,qBAAqB,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY,CA2D9F"}
+{"version":3,"file":"get-shader-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-shader-layout.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EAKb,MAAM,eAAe,CAAC;AAMvB;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY,CA2D/F"}

package/dist/adapter/helpers/get-shader-layout.js

@@ -1,250 +1,285 @@
-import { isWebGL2 } from "../../context/context/webgl-checks.js";
-import { Accessor } from "../../classic/accessor.js";
-import { decodeGLUniformType, decodeGLAttributeType, isSamplerUniform } from "./decode-webgl-types.js";
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+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, program) {
-  const shaderLayout = {
-    attributes: [],
-    bindings: []
-  };
-  shaderLayout.attributes = readAttributeDeclarations(gl, program);
-  const uniformBlocks = readUniformBlocks(gl, program);
-  for (const uniformBlock of uniformBlocks) {
-    const uniforms = uniformBlock.uniforms.map(uniform => ({
-      name: uniform.name,
-      format: uniform.format,
-      byteOffset: uniform.byteOffset,
-      byteStride: uniform.byteStride,
-      arrayLength: uniform.arrayLength
-    }));
-    shaderLayout.bindings.push({
-      type: 'uniform',
-      name: uniformBlock.name,
-      location: uniformBlock.location,
-      visibility: (uniformBlock.vertex ? 0x1 : 0) & (uniformBlock.fragment ? 0x2 : 0),
-      minBindingSize: uniformBlock.byteLength,
-      uniforms
-    });
-  }
-  const uniforms = readUniformBindings(gl, program);
-  let textureUnit = 0;
-  for (const uniform of uniforms) {
-    if (isSamplerUniform(uniform.type)) {
-      const {
-        viewDimension,
-        sampleType
-      } = getSamplerInfo(uniform.type);
-      shaderLayout.bindings.push({
-        type: 'texture',
-        name: uniform.name,
-        location: textureUnit,
-        viewDimension,
-        sampleType
-      });
-      uniform.textureUnit = textureUnit;
-      textureUnit += 1;
+    const shaderLayout = {
+        attributes: [],
+        bindings: []
+    };
+    shaderLayout.attributes = readAttributeDeclarations(gl, program);
+    // Uniform blocks
+    const uniformBlocks = readUniformBlocks(gl, program);
+    for (const uniformBlock of uniformBlocks) {
+        const uniforms = uniformBlock.uniforms.map(uniform => ({
+            name: uniform.name,
+            format: uniform.format,
+            byteOffset: uniform.byteOffset,
+            byteStride: uniform.byteStride,
+            arrayLength: uniform.arrayLength
+        }));
+        shaderLayout.bindings.push({
+            type: 'uniform',
+            name: uniformBlock.name,
+            location: uniformBlock.location,
+            visibility: (uniformBlock.vertex ? 0x1 : 0) & (uniformBlock.fragment ? 0x2 : 0),
+            minBindingSize: uniformBlock.byteLength,
+            uniforms
+        });
     }
-  }
-  if (uniforms.length) {
-    shaderLayout.uniforms = uniforms;
-  }
-  const varyings = readVaryings(gl, program);
-  if (varyings !== null && varyings !== void 0 && varyings.length) {
-    shaderLayout.varyings = varyings;
-  }
-  return shaderLayout;
+    const uniforms = readUniformBindings(gl, program);
+    let textureUnit = 0;
+    for (const uniform of uniforms) {
+        if (isSamplerUniform(uniform.type)) {
+            const { viewDimension, sampleType } = getSamplerInfo(uniform.type);
+            shaderLayout.bindings.push({
+                type: 'texture',
+                name: uniform.name,
+                location: textureUnit,
+                viewDimension,
+                sampleType
+            });
+            // @ts-expect-error
+            uniform.textureUnit = textureUnit;
+            textureUnit += 1;
+        }
+    }
+    if (uniforms.length) {
+        shaderLayout.uniforms = uniforms;
+    }
+    // Varyings
+    const varyings = readVaryings(gl, program);
+    // Note - samplers are always in unform bindings, even if uniform blocks are used
+    if (varyings?.length) {
+        shaderLayout.varyings = varyings;
+    }
+    return shaderLayout;
 }
+// HELPERS
+/**
+ * Extract info about all transform feedback varyings
+ *
+ * linkProgram needs to have been called, although linking does not need to have been successful
+ */
 function readAttributeDeclarations(gl, program) {
-  const attributes = [];
-  const count = gl.getProgramParameter(program, 35721);
-  for (let index = 0; index < count; index++) {
-    const activeInfo = gl.getActiveAttrib(program, index);
-    if (!activeInfo) {
-      throw new Error('activeInfo');
-    }
-    const {
-      name,
-      type: compositeType
-    } = activeInfo;
-    const location = gl.getAttribLocation(program, name);
-    if (location >= 0) {
-      const {
-        attributeType
-      } = decodeGLAttributeType(compositeType);
-      const stepMode = /instance/i.test(name) ? 'instance' : 'vertex';
-      attributes.push({
-        name,
-        location,
-        stepMode,
-        type: attributeType
-      });
+    const attributes = [];
+    const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+    for (let index = 0; index < count; 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` location will be < 0
+        if (location >= 0) {
+            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, b) => a.location - b.location);
-  return attributes;
+    // Sort by declaration order
+    attributes.sort((a, b) => a.location - b.location);
+    return attributes;
 }
+/**
+ * Extract info about all transform feedback varyings
+ *
+ * linkProgram needs to have been called, although linking does not need to have been successful
+ */
 function readVaryings(gl, program) {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl;
-  const varyings = [];
-  const count = gl.getProgramParameter(program, 35971);
-  for (let location = 0; location < count; location++) {
-    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
-    if (!activeInfo) {
-      throw new Error('activeInfo');
+    const varyings = [];
+    const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
+    for (let location = 0; location < count; location++) {
+        const activeInfo = gl.getTransformFeedbackVarying(program, location);
+        if (!activeInfo) {
+            throw new Error('activeInfo');
+        }
+        const { name, type: compositeType, size } = activeInfo;
+        const { glType, components } = decodeGLUniformType(compositeType);
+        const accessor = new Accessor({ type: glType, size: size * components });
+        const varying = { location, name, accessor }; // Base values
+        varyings.push(varying);
     }
-    const {
-      name,
-      type: compositeType,
-      size
-    } = activeInfo;
-    const {
-      glType,
-      components
-    } = decodeGLUniformType(compositeType);
-    const accessor = new Accessor({
-      type: glType,
-      size: size * components
-    });
-    const varying = {
-      location,
-      name,
-      accessor
-    };
-    varyings.push(varying);
-  }
-  varyings.sort((a, b) => a.location - b.location);
-  return varyings;
+    varyings.sort((a, b) => a.location - b.location);
+    return varyings;
 }
+/**
+ * Extract info about all uniforms
+ *
+ * Query uniform locations and build name to setter map.
+ */
 function readUniformBindings(gl, program) {
-  const uniforms = [];
-  const uniformCount = gl.getProgramParameter(program, 35718);
-  for (let i = 0; i < uniformCount; 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 = {
-      location: webglLocation,
-      name,
-      size,
-      type,
-      isArray
-    };
-    uniforms.push(uniformInfo);
-    if (uniformInfo.size > 1) {
-      for (let j = 0; j < uniformInfo.size; j++) {
-        const elementName = `${name}[${j}]`;
-        webglLocation = gl.getUniformLocation(program, elementName);
-        const arrayElementUniformInfo = {
-          ...uniformInfo,
-          name: elementName,
-          location: webglLocation
+    const uniforms = [];
+    const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
+    for (let i = 0; i < uniformCount; 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 = {
+            // WebGL locations are uniquely typed but just numbers
+            location: webglLocation,
+            name,
+            size,
+            type,
+            isArray
         };
-        uniforms.push(arrayElementUniformInfo);
-      }
+        uniforms.push(uniformInfo);
+        // Array (e.g. matrix) uniforms can occupy several 4x4 byte banks
+        if (uniformInfo.size > 1) {
+            for (let j = 0; j < uniformInfo.size; j++) {
+                const elementName = `${name}[${j}]`;
+                webglLocation = gl.getUniformLocation(program, elementName);
+                const arrayElementUniformInfo = {
+                    ...uniformInfo,
+                    name: elementName,
+                    location: webglLocation
+                };
+                uniforms.push(arrayElementUniformInfo);
+            }
+        }
     }
-  }
-  return uniforms;
+    return uniforms;
 }
+/**
+ * Extract info about all "active" uniform blocks
+ * @note In WebGL, "active" just means that unused (inactive) blocks may have been optimized away during linking)
+ */
 function readUniformBlocks(gl, program) {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl;
-  const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
-  const uniformBlocks = [];
-  const blockCount = gl2.getProgramParameter(program, 35382);
-  for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
-    const blockInfo = {
-      name: gl2.getActiveUniformBlockName(program, blockIndex) || '',
-      location: getBlockParameter(blockIndex, 35391),
-      byteLength: getBlockParameter(blockIndex, 35392),
-      vertex: getBlockParameter(blockIndex, 35396),
-      fragment: getBlockParameter(blockIndex, 35398),
-      uniformCount: getBlockParameter(blockIndex, 35394),
-      uniforms: []
-    };
-    const uniformIndices = getBlockParameter(blockIndex, 35395) || [];
-    const uniformType = gl2.getActiveUniforms(program, uniformIndices, 35383);
-    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, 35384);
-    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, 35387);
-    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, 35388);
-    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: activeInfo.name,
-        format: decodeGLUniformType(uniformType[i]).format,
-        type: uniformType[i],
-        arrayLength: uniformArrayLength[i],
-        byteOffset: uniformOffset[i],
-        byteStride: uniformStride[i]
-      });
+    const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);
+    const uniformBlocks = [];
+    const blockCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
+    for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+        const blockInfo = {
+            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),
+            fragment: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+            uniformCount: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+            uniforms: []
+        };
+        const uniformIndices = getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
+        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 = gl.getActiveUniform(program, uniformIndices[i]);
+            if (!activeInfo) {
+                throw new Error('activeInfo');
+            }
+            blockInfo.uniforms.push({
+                name: activeInfo.name,
+                format: decodeGLUniformType(uniformType[i]).format,
+                type: uniformType[i],
+                arrayLength: uniformArrayLength[i],
+                byteOffset: uniformOffset[i],
+                byteStride: uniformStride[i]
+                // matrixStride: uniformStride[i],
+                // rowMajor: uniformRowMajor[i]
+            });
+        }
+        uniformBlocks.push(blockInfo);
     }
-    uniformBlocks.push(blockInfo);
-  }
-  uniformBlocks.sort((a, b) => a.location - b.location);
-  return uniformBlocks;
+    uniformBlocks.sort((a, b) => a.location - b.location);
+    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 = {
-  [35678]: ['2d', 'float'],
-  [35680]: ['cube', 'float'],
-  [35679]: ['3d', 'float'],
-  [35682]: ['3d', 'depth'],
-  [36289]: ['2d-array', 'float'],
-  [36292]: ['2d-array', 'depth'],
-  [36293]: ['cube', 'float'],
-  [36298]: ['2d', 'sint'],
-  [36299]: ['3d', 'sint'],
-  [36300]: ['cube', 'sint'],
-  [36303]: ['2d-array', 'uint'],
-  [36306]: ['2d', 'uint'],
-  [36307]: ['3d', 'uint'],
-  [36308]: ['cube', 'uint'],
-  [36311]: ['2d-array', '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']
 };
 function getSamplerInfo(type) {
-  const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
-  if (!sampler) {
-    throw new Error('sampler');
-  }
-  const [viewDimension, sampleType] = sampler;
-  return {
-    viewDimension,
-    sampleType
-  };
+    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) {
-  if (name[name.length - 1] !== ']') {
+    // Shortcut to avoid redundant or bad matches
+    if (name[name.length - 1] !== ']') {
+        return {
+            name,
+            length: 1,
+            isArray: false
+        };
+    }
+    // if array name then clean the array brackets
+    const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
+    const matches = UNIFORM_NAME_REGEXP.exec(name);
+    if (!matches || matches.length < 2) {
+        throw new Error(`Failed to parse GLSL uniform name ${name}`);
+    }
     return {
-      name,
-      length: 1,
-      isArray: false
+        name: matches[1],
+        length: matches[2] ? 1 : 0,
+        isArray: Boolean(matches[2])
     };
-  }
-  const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-  const matches = UNIFORM_NAME_REGEXP.exec(name);
-  if (!matches || matches.length < 2) {
-    throw new Error(`Failed to parse GLSL uniform name ${name}`);
-  }
-  return {
-    name: matches[1],
-    length: matches[2] ? 1 : 0,
-    isArray: Boolean(matches[2])
-  };
 }
-//# sourceMappingURL=get-shader-layout.js.map

package/dist/adapter/helpers/parse-shader-compiler-log.js

@@ -1,42 +1,51 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+/**
+ * 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) {
-  const lines = errLog.split(/\r?\n/);
-  const messages = [];
-  for (const line of lines) {
-    if (line.length <= 1) {
-      continue;
+    // Parse the error - note: browser and driver dependent
+    const lines = errLog.split(/\r?\n/);
+    const messages = [];
+    for (const line of lines) {
+        if (line.length <= 1) {
+            continue; // eslint-disable-line no-continue
+        }
+        const segments = 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);
+        if (isNaN(lineNum)) {
+            lineNum = 0;
+        }
+        let linePos = parseInt(linePosition, 10);
+        if (isNaN(linePos)) {
+            linePos = 0;
+        }
+        messages.push({
+            message: rest.join(':').trim(),
+            type: getMessageType(messageType),
+            lineNum,
+            linePos // TODO
+        });
     }
-    const segments = line.split(':');
-    if (segments.length === 2) {
-      const [messageType, message] = segments;
-      messages.push({
-        message: message.trim(),
-        type: getMessageType(messageType),
-        lineNum: 0,
-        linePos: 0
-      });
-      continue;
-    }
-    const [messageType, linePosition, lineNumber, ...rest] = segments;
-    let lineNum = parseInt(lineNumber, 10);
-    if (isNaN(lineNum)) {
-      lineNum = 0;
-    }
-    let linePos = parseInt(linePosition, 10);
-    if (isNaN(linePos)) {
-      linePos = 0;
-    }
-    messages.push({
-      message: rest.join(':').trim(),
-      type: getMessageType(messageType),
-      lineNum,
-      linePos
-    });
-  }
-  return messages;
+    return messages;
 }
+/** Ensure supported type */
 function getMessageType(messageType) {
-  const MESSAGE_TYPES = ['warning', 'error', 'info'];
-  const lowerCaseType = messageType.toLowerCase();
-  return MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info';
+    const MESSAGE_TYPES = ['warning', 'error', 'info'];
+    const lowerCaseType = messageType.toLowerCase();
+    return (MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info');
 }
-//# sourceMappingURL=parse-shader-compiler-log.js.map

package/dist/adapter/helpers/set-uniform.d.ts

@@ -1,5 +1,5 @@
 import type { UniformValue } from '@luma.gl/core';
 import { GLCompositeType, GLSamplerType } from '@luma.gl/constants';
 /** Set a raw uniform (without type conversion and caching) */
-export declare function setUniform(gl: WebGLRenderingContext, location: WebGLUniformLocation, type: GLCompositeType | GLSamplerType, value: UniformValue): void;
+export declare function setUniform(gl: WebGL2RenderingContext, location: WebGLUniformLocation, type: GLCompositeType | GLSamplerType, value: UniformValue): void;
 //# sourceMappingURL=set-uniform.d.ts.map

package/dist/adapter/helpers/set-uniform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-uniform.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/set-uniform.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,EAAK,eAAe,EAAE,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEtE,8DAA8D;AAE9D,wBAAgB,UAAU,CACxB,EAAE,EAAE,qBAAqB,EACzB,QAAQ,EAAE,oBAAoB,EAC9B,IAAI,EAAE,eAAe,GAAG,aAAa,EACrC,KAAK,EAAE,YAAY,GAClB,IAAI,CA0EN"}
+{"version":3,"file":"set-uniform.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/set-uniform.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,EAAK,eAAe,EAAE,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEtE,8DAA8D;AAE9D,wBAAgB,UAAU,CACxB,EAAE,EAAE,sBAAsB,EAC1B,QAAQ,EAAE,oBAAoB,EAC9B,IAAI,EAAE,eAAe,GAAG,aAAa,EACrC,KAAK,EAAE,YAAY,GAClB,IAAI,CAwEN"}