@luma.gl/webgl 8.6.0-alpha.3 → 9.0.0-alpha.2

package/src/context/parameters/webgl-parameters.ts

@@ -1,197 +0,0 @@
-// WebGL parameter types
-import GL from '@luma.gl/constants';
-
-export type TypedArray =
-  | Int8Array
-  | Uint8Array
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Uint8ClampedArray
-  | Float32Array
-  | Float64Array;
-
-/**
- * TypeScript type covering all typed arrays and classic arrays consisting of numbers
- */
-export type NumberArray = number[] | TypedArray;
-
-type Framebuffer = any;
-
-type GL_FUNCTION =
-  GL.NEVER |
-  GL.LESS |
-  GL.EQUAL |
-  GL.LEQUAL |
-  GL.GREATER |
-  GL.NOTEQUAL |
-  GL.GEQUAL |
-  GL.ALWAYS;
-
-type GL_BLEND_EQUATION = GL.FUNC_ADD | GL.FUNC_SUBTRACT | GL.FUNC_REVERSE_SUBTRACT | GL.MIN_EXT | GL.MAX_EXT;
-
-type GL_BLEND_FUNCTION =
-  GL.ZERO |
-  GL.ONE |
-  GL.SRC_COLOR |
-  GL.ONE_MINUS_SRC_COLOR |
-  GL.DST_COLOR |
-  GL.ONE_MINUS_DST_COLOR |
-  GL.SRC_ALPHA |
-  GL.ONE_MINUS_SRC_ALPHA |
-  GL.DST_ALPHA |
-  GL.ONE_MINUS_DST_ALPHA |
-  GL.CONSTANT_COLOR |
-  GL.ONE_MINUS_CONSTANT_COLOR |
-  GL.CONSTANT_ALPHA |
-  GL.ONE_MINUS_CONSTANT_ALPHA |
-  GL.SRC_ALPHA_SATURATE;
-
-type GL_STENCIL_OP =
-  GL.KEEP |
-  GL.ZERO |
-  GL.REPLACE |
-  GL.INCR |
-  GL.INCR_WRAP |
-  GL.DECR |
-  GL.DECR_WRAP |
-  GL.INVERT;
-
-export type GLValueParameters = {
-  [GL.BLEND]?: boolean;
-  [GL.BLEND_COLOR]?: [number, number, number, number] | NumberArray;
-  [GL.BLEND_EQUATION_RGB]?: GL_BLEND_EQUATION;
-  [GL.BLEND_EQUATION_ALPHA]?: GL_BLEND_EQUATION;
-  [GL.BLEND_SRC_RGB]?: GL_BLEND_FUNCTION;
-  [GL.BLEND_DST_RGB]?: GL_BLEND_FUNCTION;
-  [GL.BLEND_SRC_ALPHA]?: GL_BLEND_FUNCTION;
-  [GL.BLEND_DST_ALPHA]?: GL_BLEND_FUNCTION;
-  [GL.COLOR_CLEAR_VALUE]?: [number, number, number, number] | NumberArray;
-  [GL.COLOR_WRITEMASK]?: [boolean, boolean, boolean, boolean] | boolean[];
-  [GL.CULL_FACE]?: boolean;
-  [GL.CULL_FACE_MODE]?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;
-  [GL.DEPTH_TEST]?: boolean;
-  [GL.DEPTH_CLEAR_VALUE]?: number;
-  [GL.DEPTH_FUNC]?: GL_FUNCTION;
-  [GL.DEPTH_RANGE]?: [number, number] | NumberArray;
-  [GL.DEPTH_WRITEMASK]?: boolean;
-  [GL.DITHER]?: boolean;
-  [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
-  [GL.CURRENT_PROGRAM]?: WebGLProgram | null,
-  [GL.FRAMEBUFFER_BINDING]?: WebGLFramebuffer | null;
-  [GL.RENDERBUFFER_BINDING]?: WebGLRenderbuffer | null,
-  [GL.TRANSFORM_FEEDBACK_BINDING]?: WebGLTransformFeedback | null,
-  [GL.VERTEX_ARRAY_BINDING]?: WebGLVertexArrayObject | null,
-  [GL.ARRAY_BUFFER_BINDING]?: WebGLBuffer | null,
-  [GL.COPY_READ_BUFFER_BINDING]?: WebGLBuffer | null,
-  [GL.COPY_WRITE_BUFFER_BINDING]?: WebGLBuffer | null,
-  [GL.PIXEL_PACK_BUFFER_BINDING]?: WebGLBuffer | null,
-  [GL.PIXEL_UNPACK_BUFFER_BINDING]?: WebGLBuffer | null,
-  [GL.TEXTURE_BINDING_2D]?: WebGLTexture | null,
-  [GL.TEXTURE_BINDING_2D_ARRAY]?: WebGLTexture | null,
-  [GL.TEXTURE_BINDING_3D]?: WebGLTexture | null,
-  [GL.TEXTURE_BINDING_CUBE_MAP]?: WebGLTexture | null,
-  [GL.FRONT_FACE]?: GL.CW | GL.CCW;
-  [GL.GENERATE_MIPMAP_HINT]?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
-  [GL.LINE_WIDTH]?: number;
-  [GL.POLYGON_OFFSET_FILL]?: boolean;
-  [GL.POLYGON_OFFSET_FACTOR]?: number;
-  [GL.POLYGON_OFFSET_UNITS]?: number;
-  [GL.SAMPLE_ALPHA_TO_COVERAGE]?: boolean,
-  [GL.SAMPLE_COVERAGE]?: boolean,
-  [GL.RASTERIZER_DISCARD]?: boolean;
-  [GL.SAMPLE_COVERAGE_VALUE]?: number;
-  [GL.SAMPLE_COVERAGE_INVERT]?: boolean;
-  [GL.SCISSOR_TEST]?: boolean;
-  [GL.SCISSOR_BOX]?: [number, number, number, number] | NumberArray;
-  [GL.STENCIL_TEST]?: boolean;
-  [GL.STENCIL_CLEAR_VALUE]?: number;
-  [GL.STENCIL_WRITEMASK]?: number;
-  [GL.STENCIL_BACK_WRITEMASK]?: number;
-  [GL.STENCIL_FUNC]?: GL_FUNCTION;
-  [GL.STENCIL_REF]?: GL_FUNCTION;
-  [GL.STENCIL_VALUE_MASK]?: GL_FUNCTION;
-  [GL.STENCIL_BACK_FUNC]?: GL_FUNCTION;
-  [GL.STENCIL_BACK_REF]?: GL_FUNCTION;
-  [GL.STENCIL_BACK_VALUE_MASK]?: GL_FUNCTION;
-  [GL.STENCIL_FAIL]?: GL_STENCIL_OP;
-  [GL.STENCIL_PASS_DEPTH_FAIL]?: GL_STENCIL_OP;
-  [GL.STENCIL_PASS_DEPTH_PASS]?: GL_STENCIL_OP;
-  [GL.STENCIL_BACK_FAIL]?: GL_STENCIL_OP;
-  [GL.STENCIL_BACK_PASS_DEPTH_FAIL]?: GL_STENCIL_OP;
-  [GL.STENCIL_BACK_PASS_DEPTH_PASS]?: GL_STENCIL_OP;
-  [GL.VIEWPORT]?: [number, number, number, number] | NumberArray;
-
-  // WEBGL1 PIXEL PACK/UNPACK MODES
-  [GL.PACK_ALIGNMENT]?: number;
-  [GL.UNPACK_ALIGNMENT]?: number;
-  [GL.UNPACK_FLIP_Y_WEBGL]?: boolean;
-  [GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]?: boolean;
-  [GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]?: GL.NONE | GL.BROWSER_DEFAULT_WEBGL;
-
-  // WEBGL2 PIXEL PACK/UNPACK MODES
-  // RASTERIZER_DISCARD ...
-  [GL.PACK_ROW_LENGTH]?: number;
-  [GL.PACK_SKIP_PIXELS]?: number;
-  [GL.PACK_SKIP_ROWS]?: number;
-  [GL.READ_FRAMEBUFFER_BINDING]?: Framebuffer | null;
-  [GL.UNPACK_ROW_LENGTH]?: number;
-  [GL.UNPACK_IMAGE_HEIGHT]?: number;
-  [GL.UNPACK_SKIP_PIXELS]?: number;
-  [GL.UNPACK_SKIP_ROWS]?: number;
-  [GL.UNPACK_SKIP_IMAGES]?: number;
-};
-
-export type GLFunctionStyleParameters = {
-  // Function-style setters
-  framebuffer?: Framebuffer | null;
-  blend?: boolean;
-  blendColor?: [number, number, number, number] | NumberArray;
-  blendEquation?: GL_BLEND_EQUATION | [GL_BLEND_EQUATION, GL_BLEND_EQUATION];
-  blendFunc?:
-    [GL_BLEND_FUNCTION, GL_BLEND_FUNCTION] |
-    [GL_BLEND_FUNCTION, GL_BLEND_FUNCTION, GL_BLEND_FUNCTION, GL_BLEND_FUNCTION];
-
-  clearColor?: [number, number, number, number] | NumberArray;
-  clearDepth?: number;
-  clearStencil?: number;
-
-  colorMask?: [boolean, boolean, boolean, boolean];
-
-  cull?: boolean;
-  cullFace?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;
-
-  depthTest?: boolean;
-  depthFunc?: GL_FUNCTION;
-  depthMask?: boolean;
-  depthRange?: [number, number] | NumberArray;
-
-  dither?: boolean;
-
-  derivativeHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
-
-  frontFace?: GL.CW | GL.CCW;
-
-  mipmapHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
-
-  lineWidth?: number;
-
-  polygonOffsetFill?: boolean;
-  polygonOffset?: [number, number];
-
-  sampleCoverage?: [number, boolean];
-
-  scissorTest?: boolean;
-  scissor?: [number, number, number, number] | NumberArray;
-
-  stencilTest?: boolean;
-  stencilMask?: number | [number, number];
-  stencilFunc?: [GL_FUNCTION, number, number] | [GL_FUNCTION, number, number, GL_FUNCTION, number, number];
-  stencilOp?:
-    [GL_STENCIL_OP, GL_STENCIL_OP, GL_STENCIL_OP] |
-    [GL_STENCIL_OP, GL_STENCIL_OP, GL_STENCIL_OP, GL_STENCIL_OP, GL_STENCIL_OP, GL_STENCIL_OP];
-  viewport?: [number, number, number, number] | NumberArray;
-};
-
-export type GLParameters = GLValueParameters | GLFunctionStyleParameters;

package/src/debug/debug-program-configuration.ts

@@ -1,32 +0,0 @@
-import {getCompositeGLType} from '../webgl-utils/attribute-utils';
-
-export function getDebugTableForProgramConfiguration(config) {
-  const table = {};
-
-  const header = `Accessors for ${config.id}`;
-
-  for (const attributeInfo of config.attributeInfos) {
-    if (attributeInfo) {
-      const glslDeclaration = getGLSLDeclaration(attributeInfo);
-      table[`in ${glslDeclaration}`] = {[header]: JSON.stringify(attributeInfo.accessor)};
-    }
-  }
-
-  for (const varyingInfo of config.varyingInfos) {
-    if (varyingInfo) {
-      const glslDeclaration = getGLSLDeclaration(varyingInfo);
-      table[`out ${glslDeclaration}`] = {[header]: JSON.stringify(varyingInfo.accessor)};
-    }
-  }
-
-  return table;
-}
-
-function getGLSLDeclaration(attributeInfo) {
-  const {type, size} = attributeInfo.accessor;
-  const typeAndName = getCompositeGLType(type, size);
-  if (typeAndName) {
-    return `${typeAndName.name} ${attributeInfo.name}`;
-  }
-  return attributeInfo.name;
-}

package/src/debug/debug-uniforms.ts

@@ -1,100 +0,0 @@
-import {assert, formatValue} from '@luma.gl/api';
-
-// Prepares a table suitable for console.table
-/* eslint-disable max-statements, complexity */
-export function getDebugTableForUniforms(options?: {
-  header?: string;
-  program: any;
-  uniforms: any;
-  undefinedOnly?: boolean;
-}): {
-  table: {};
-  count: number;
-  unusedTable: {};
-  unusedCount: number;
-} {
-  const {
-    header = 'Uniforms',
-    program,
-    uniforms,
-    undefinedOnly = false
-  } = options;
-  assert(program);
-
-  const SHADER_MODULE_UNIFORM_REGEXP = '.*_.*';
-  const PROJECT_MODULE_UNIFORM_REGEXP = '.*Matrix'; // TODO - Use explicit list
-
-  const uniformLocations = program._uniformSetters;
-  const table = {}; // {[header]: {}};
-
-  // Add program's provided uniforms (in alphabetical order)
-  const uniformNames = Object.keys(uniformLocations).sort();
-
-  let count = 0;
-
-  // First add non-underscored uniforms (assumed not coming from shader modules)
-  for (const uniformName of uniformNames) {
-    if (
-      !uniformName.match(SHADER_MODULE_UNIFORM_REGEXP) &&
-      !uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)
-    ) {
-      if (addUniformToTable({table, header, uniforms, uniformName, undefinedOnly})) {
-        count++;
-      }
-    }
-  }
-
-  // add underscored uniforms (assumed from shader modules)
-  for (const uniformName of uniformNames) {
-    if (uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)) {
-      if (addUniformToTable({table, header, uniforms, uniformName, undefinedOnly})) {
-        count++;
-      }
-    }
-  }
-
-  for (const uniformName of uniformNames) {
-    if (!table[uniformName]) {
-      if (addUniformToTable({table, header, uniforms, uniformName, undefinedOnly})) {
-        count++;
-      }
-    }
-  }
-
-  // Create a table of unused uniforms
-  let unusedCount = 0;
-  const unusedTable = {};
-  if (!undefinedOnly) {
-    for (const uniformName in uniforms) {
-      const uniform = uniforms[uniformName];
-      if (!table[uniformName]) {
-        unusedCount++;
-        unusedTable[uniformName] = {
-          Type: `NOT USED: ${uniform}`,
-          [header]: formatValue(uniform)
-        };
-      }
-    }
-  }
-
-  return {table, count, unusedTable, unusedCount};
-}
-
-// Helper
-function addUniformToTable({table, header, uniforms, uniformName, undefinedOnly}) {
-  const value = uniforms[uniformName];
-  const isDefined = isUniformDefined(value);
-  if (!undefinedOnly || !isDefined) {
-    table[uniformName] = {
-      // Add program's unprovided uniforms
-      [header]: isDefined ? formatValue(value) : 'N/A',
-      'Uniform Type': isDefined ? value : 'NOT PROVIDED'
-    };
-    return true;
-  }
-  return false;
-}
-
-function isUniformDefined(value) {
-  return value !== undefined && value !== null;
-}

package/src/debug/debug-vertex-array.ts

@@ -1,123 +0,0 @@
-import {formatValue} from '@luma.gl/api';
-import Buffer from '../classes/webgl-buffer';
-import {getKey} from '../webgl-utils/constants-to-keys';
-import {getCompositeGLType} from '../webgl-utils/attribute-utils';
-
-// Creates object suitable as input for console.table
-export function getDebugTableForVertexArray(options?: {vertexArray: any; header?: string}): {} {
-  const {vertexArray, header = 'Attributes'} = options;
-
-  if (!vertexArray.configuration) {
-    return {};
-  }
-
-  const table = {}; // {[header]: {}};
-
-  // Add index (elements) if available
-  if (vertexArray.elements) {
-    // const elements = Object.assign({size: 1}, vertexArray.elements);
-    // @ts-expect-error
-    table.ELEMENT_ARRAY_BUFFER = getDebugTableRow(vertexArray, vertexArray.elements, null, header);
-  }
-
-  // Add used attributes
-  const attributes = vertexArray.values;
-
-  for (const attributeLocation in attributes) {
-    const info = vertexArray._getAttributeInfo(attributeLocation);
-    if (info) {
-      let rowHeader = `${attributeLocation}: ${info.name}`;
-      const accessor = vertexArray.accessors[info.location];
-      if (accessor) {
-        rowHeader = `${attributeLocation}: ${getGLSLDeclaration(info.name, accessor)}`;
-      }
-      table[rowHeader] = getDebugTableRow(
-        vertexArray,
-        attributes[attributeLocation],
-        accessor,
-        header
-      );
-    }
-  }
-
-  return table;
-}
-
-/* eslint-disable max-statements */
-function getDebugTableRow(vertexArray, attribute, accessor, header) {
-  const {gl} = vertexArray;
-
-  if (!attribute) {
-    return {
-      [header]: 'null',
-      'Format ': 'N/A'
-    };
-  }
-
-  let type = 'NOT PROVIDED';
-  let size = 1;
-  let verts = 0;
-  let bytes = 0;
-
-  let isInteger;
-  let marker;
-  let value;
-
-  if (accessor) {
-    type = accessor.type;
-    size = accessor.size;
-
-    // Generate a type name by dropping Array from Float32Array etc.
-    type = String(type).replace('Array', '');
-
-    // Look for 'nt' to detect integer types, e.g. Int32Array, Uint32Array
-    isInteger = type.indexOf('nt') !== -1;
-  }
-
-  if (attribute instanceof Buffer) {
-    const buffer = attribute;
-
-    const {data, changed} = buffer.getDebugData();
-    marker = changed ? '*' : '';
-
-    value = data;
-    bytes = buffer.byteLength;
-    verts = bytes / data.BYTES_PER_ELEMENT / size;
-
-    let format;
-
-    if (accessor) {
-      const instanced = accessor.divisor > 0;
-      format = `${instanced ? 'I ' : 'P '} ${verts} (x${size}=${bytes} bytes ${getKey(gl, type)})`;
-    } else {
-      // element buffer
-      isInteger = true;
-      format = `${bytes} bytes`;
-    }
-
-    return {
-      [header]: `${marker}${formatValue(value, {size, isInteger})}`,
-      'Format ': format
-    };
-  }
-
-  // CONSTANT VALUE
-  value = attribute;
-  size = attribute.length;
-  // Generate a type name by dropping Array from Float32Array etc.
-  type = String(attribute.constructor.name).replace('Array', '');
-  // Look for 'nt' to detect integer types, e.g. Int32Array, Uint32Array
-  isInteger = type.indexOf('nt') !== -1;
-
-  return {
-    [header]: `${formatValue(value, {size, isInteger})} (constant)`,
-    'Format ': `${size}x${type} (constant)`
-  };
-}
-/* eslint-ensable max-statements */
-
-function getGLSLDeclaration(name, accessor) {
-  const {type, size} = accessor;
-  const typeAndName = getCompositeGLType(type, size);
-  return typeAndName ? `${name} (${typeAndName.name})` : name;
-}

package/src/helpers/get-program-bindings.ts

@@ -1,244 +0,0 @@
-import GL from '@luma.gl/constants';
-import {isWebGL2} from '../context/context/webgl-checks';
-import {ProgramBindings, AttributeBinding, UniformBinding, UniformBlockBinding, VaryingBinding} from './program-bindings'
-import Accessor from '../classes/accessor';
-import {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';
-
-/**
- * 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: WebGL2RenderingContext, 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);
-}
-
-
-/**
- * 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: WebGL2RenderingContext, program: WebGLProgram): AttributeBinding[] {
-  const attributes: AttributeBinding[] = [];
-
-  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 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 {type, components} = decomposeCompositeGLType(compositeType);
-      const accessor = {type, size: size * components};
-      inferProperties(location, name, accessor);
-    
-      const attributeInfo = {location, name, accessor: new Accessor(accessor)}; // Base values
-      attributes.push(attributeInfo);
-    }
-  }
-
-  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: WebGL2RenderingContext, program: WebGLProgram): VaryingBinding[] {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-
-  const varyings = [];
-
-  const count = gl.getProgramParameter(program, gl.TRANSFORM_FEEDBACK_VARYINGS);
-  for (let location = 0; location < count; location++) {
-    const {name, type: compositeType, size} = gl.getTransformFeedbackVarying(program, location);
-    const {type, components} = decomposeCompositeGLType(compositeType);
-    const accessor = new Accessor({type, 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: WebGL2RenderingContext, program: WebGLProgram): UniformBinding[] {
-  const uniforms: UniformBinding[] = [];
-
-  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 {name, isArray} = parseUniformName(rawName);
-    let webglLocation = gl.getUniformLocation(program, name);
-    const uniformInfo = {
-      // WebGL locations are uniquely typed but just numbers
-      location: webglLocation as number,
-      name,
-      size,
-      type,
-      isArray
-    };
-    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 as number
-        };
-
-        uniforms.push(arrayElementUniformInfo);
-      }
-    }
-  }
-  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: WebGL2RenderingContext, program: WebGLProgram): UniformBlockBinding[] {
-  const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);
-
-  const uniformBlocks: UniformBlockBinding[] = [];
-
-  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),
-      uniformIndices: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
-      uniforms: []
-    }
-
-    for (let uniformIndex = 0; uniformIndex < blockInfo.uniformCount; ++uniformIndex) {
-      // TODO - Can we extract more?
-    }
-
-    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', 'sint'],
-  [GL.UNSIGNED_INT_SAMPLER_2D]: ['2d', 'sint'],
-  [GL.UNSIGNED_INT_SAMPLER_3D]: ['3d', 'sint'],
-  [GL.UNSIGNED_INT_SAMPLER_CUBE]: ['cube', 'sint'],
-  [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'sint']
-};
-
-/**
- * Generate a list of "WebGPU-style" bindings for this program
- */
-function generateWebGPUStyleBindings(config: ProgramBindings) {
-  const bindings: any = [];
-
-  // Uniform blocks
-  for (const blockInfo of config.uniformBlocks) {
-    bindings.push({
-      binding: blockInfo.location,
-      visibility: (blockInfo.vertex ? 0x1 : 0) & (blockInfo.fragment ? 0x2 : 0),
-      buffer: {
-        type: 'uniform',
-        // minBindingSize: blockInfo.size
-      }
-    })
-  }
-
-  // Sampler uniforms
-  for (const uniformInfo of config.uniforms) {
-    let sampler = SAMPLER_UNIFORMS_GL_TO_GPU[uniformInfo.type];
-    if (sampler) {
-      const [viewDimension, sampleType] = sampler;
-      bindings.push({
-        binding: uniformInfo.location,
-        visibility: 0, // Not available in WebGL on individual uniforms?
-        texture: {
-          viewDimension,
-          sampleType
-        }
-      });
-    }
-  }
-}
-
-// HELPERS
-
-function parseUniformName(name) {
-  // 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: matches[1],
-    length: matches[2] || 1,
-    isArray: Boolean(matches[2])
-  };
-}
-
-// Extract additional attribute metadata from shader names (based on attribute naming conventions)
-function inferProperties(accessor, location, name) {
-  if (/instance/i.test(name)) {
-    // Any attribute containing the word "instance" will be assumed to be instanced
-    accessor.divisor = 1;
-  }
-}