@luma.gl/webgl 9.0.0-alpha.14 → 9.0.0-alpha.16

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

@@ -1,328 +1,339 @@
+// luma.gl, MIT license
 import GL from '@luma.gl/constants';
-import { isWebGL2 } from '../../context/context/webgl-checks';
-import Accessor from '../../classic/accessor';
-import { decodeUniformType, decodeAttributeType } from './uniforms';
-import { getVertexFormat } from '../converters/vertex-formats';
-import { isSamplerUniform } from './uniforms';
+import { isWebGL2 } from '../../context/context/webgl-checks.js';
+import Accessor from '../../classic/accessor.js'; // TODO - should NOT depend on classic API
+import { decodeUniformType, decodeAttributeType } from './uniforms.js';
+import { getVertexFormat } from '../converters/vertex-formats.js';
+import { isSamplerUniform } from './uniforms.js';
+/**
+ * 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) {
-  var _programBindings$unif, _programBindings$vary;
-
-  const programBindings = getProgramBindings(gl, program);
-  const shaderLayout = {
-    attributes: [],
-    bindings: []
-  };
-
-  for (const attribute of programBindings.attributes) {
-    const size = Math.min(attribute.accessor.size, 4);
-    const 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'
-    });
-  }
-
-  for (const uniformBlock of programBindings.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
-    });
-  }
-
-  let textureUnit = 0;
-
-  for (const uniform of programBindings.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 programBindings = getProgramBindings(gl, program);
+    const shaderLayout = {
+        attributes: [],
+        bindings: []
+    };
+    for (const attribute of programBindings.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'
+        });
     }
-  }
-
-  const uniforms = ((_programBindings$unif = programBindings.uniforms) === null || _programBindings$unif === void 0 ? void 0 : _programBindings$unif.filter(uniform => uniform.location !== null)) || [];
-
-  if (uniforms.length) {
-    shaderLayout.uniforms = uniforms;
-  }
-
-  if ((_programBindings$vary = programBindings.varyings) !== null && _programBindings$vary !== void 0 && _programBindings$vary.length) {
-    shaderLayout.varyings = programBindings.varyings;
-  }
-
-  return shaderLayout;
+    // Uniform blocks
+    for (const uniformBlock of programBindings.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
+        });
+    }
+    let textureUnit = 0;
+    for (const uniform of programBindings.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;
+        }
+    }
+    const uniforms = programBindings.uniforms?.filter((uniform) => uniform.location !== null) || [];
+    if (uniforms.length) {
+        shaderLayout.uniforms = uniforms;
+    }
+    if (programBindings.varyings?.length) {
+        shaderLayout.varyings = programBindings.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, program) {
-  const config = {
-    attributes: readAttributeBindings(gl, program),
-    uniforms: readUniformBindings(gl, program),
-    uniformBlocks: readUniformBlocks(gl, program),
-    varyings: readVaryings(gl, program)
-  };
-  Object.seal(config);
-  return config;
+    const config = {
+        attributes: readAttributeBindings(gl, program),
+        uniforms: readUniformBindings(gl, program),
+        uniformBlocks: readUniformBlocks(gl, program),
+        varyings: readVaryings(gl, program)
+    };
+    Object.seal(config);
+    return config;
+    // generateWebGPUStyleBindings(bindings);
 }
-
+/**
+ * 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, program) {
-  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 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` locaiton will be < 0
+        if (location >= 0) {
+            const { glType, components } = decodeAttributeType(compositeType);
+            ;
+            const accessor = { 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 {
-      name,
-      type: compositeType,
-      size
-    } = activeInfo;
-    const location = gl.getAttribLocation(program, name);
-
-    if (location >= 0) {
-      const {
-        glType,
-        components
-      } = decodeAttributeType(compositeType);
-      ;
-      const accessor = {
-        type: glType,
-        size: size * components
-      };
-
-      if (/instance/i.test(name)) {
-        accessor.divisor = 1;
-      }
-
-      const attributeInfo = {
-        location,
-        name,
-        accessor: new Accessor(accessor)
-      };
-      attributes.push(attributeInfo);
-    }
-  }
-
-  attributes.sort((a, b) => a.location - b.location);
-  return attributes;
+    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, GL.TRANSFORM_FEEDBACK_VARYINGS);
-
-  for (let location = 0; location < count; location++) {
-    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
-
-    if (!activeInfo) {
-      throw new Error('activeInfo');
+    if (!isWebGL2(gl)) {
+        return [];
     }
-
-    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
-    };
-    varyings.push(varying);
-  }
-
-  varyings.sort((a, b) => a.location - b.location);
-  return varyings;
+    const gl2 = gl;
+    const varyings = [];
+    const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
+    for (let location = 0; location < count; 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
+        varyings.push(varying);
+    }
+    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, 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 = {
-      location: webglLocation,
-      name,
-      size,
-      type,
-      isArray
-    };
-    uniforms.push(uniformInfo);
-
-    if (uniformInfo.size > 1) {
-      for (let j = 0; j < uniformInfo.size; j++) {
-        const elementName = "".concat(name, "[").concat(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
+ *
+ * ("Active" just means that unused (aka 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, GL.ACTIVE_UNIFORM_BLOCKS);
-
-  for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
-    const blockInfo = {
-      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),
-      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 = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE);
-    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE);
-    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET);
-    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE);
-
-    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: decodeUniformType(uniformType[i]).format,
-        type: uniformType[i],
-        arrayLength: uniformArrayLength[i],
-        byteOffset: uniformOffset[i],
-        byteStride: uniformStride[i]
-      });
+    if (!isWebGL2(gl)) {
+        return [];
     }
-
-    uniformBlocks.push(blockInfo);
-  }
-
-  uniformBlocks.sort((a, b) => a.location - b.location);
-  return uniformBlocks;
+    const gl2 = gl;
+    const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
+    const uniformBlocks = [];
+    const blockCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
+    for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+        const blockInfo = {
+            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),
+            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 = 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);
+        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: decodeUniformType(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.sort((a, b) => a.location - b.location);
+    return uniformBlocks;
 }
-
 const SAMPLER_UNIFORMS_GL_TO_GPU = {
-  [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']
+    [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) {
-  let sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
-
-  if (!sampler) {
-    throw new Error('sampler');
-  }
-
-  const [viewDimension, sampleType] = sampler;
-  return {
-    viewDimension,
-    sampleType
-  };
+    let 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 = name.match(UNIFORM_NAME_REGEXP);
+    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])
     };
+}
+/**
+ * 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: 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;
+}
 
-  const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-  const matches = name.match(UNIFORM_NAME_REGEXP);
+function setBindings(gl2: WebGL2RenderingContext, program: WebGLProgram, bindings: Binding[][]): void {
+  for (const bindGroup of bindings) {
+    for (const binding of bindGroup) {
 
-  if (!matches || matches.length < 2) {
-    throw new Error("Failed to parse GLSL uniform name ".concat(name));
+    }
   }
 
-  return {
-    name: matches[1],
-    length: matches[2] ? 1 : 0,
-    isArray: Boolean(matches[2])
-  };
+  // Set up indirection table
+  // this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);
 }
-//# sourceMappingURL=get-shader-layout.js.map
+ */

package/dist/adapter/helpers/parse-shader-compiler-log.d.ts

@@ -1,4 +1,4 @@
-import type { CompilerMessage } from '@luma.gl/shadertools';
+import type { CompilerMessage } from '@luma.gl/api';
 /**
  * Parse a WebGL-format GLSL compilation log into an array of WebGPU style message records.
  * This follows documented WebGL conventions for compilation logs.

package/dist/adapter/helpers/parse-shader-compiler-log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-shader-compiler-log.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/parse-shader-compiler-log.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAI1D;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAI,SAAS,eAAe,EAAE,CAqClF"}
+{"version":3,"file":"parse-shader-compiler-log.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/parse-shader-compiler-log.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAIlD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAI,SAAS,eAAe,EAAE,CAqClF"}