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

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

@@ -59,139 +59,139 @@ type GL_STENCIL_OP =
   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;
+  [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?:
+  // 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;
+  clearColor?: [number, number, number, number] | NumberArray;
+  clearDepth?: number;
+  clearStencil?: number;
 
-   colorMask?: [boolean, boolean, boolean, boolean];
+  colorMask?: [boolean, boolean, boolean, boolean];
 
-   cull?: boolean;
-   cullFace?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;
+  cull?: boolean;
+  cullFace?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;
 
-   depthTest?: boolean;
-   depthFunc?: GL_FUNCTION;
-   depthMask?: boolean;
-   depthRange?: [number, number] | NumberArray;
+  depthTest?: boolean;
+  depthFunc?: GL_FUNCTION;
+  depthMask?: boolean;
+  depthRange?: [number, number] | NumberArray;
 
-   dither?: boolean;
+  dither?: boolean;
 
-   derivativeHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
+  derivativeHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
 
-   frontFace?: GL.CW | GL.CCW;
+  frontFace?: GL.CW | GL.CCW;
 
-   mipmapHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
+  mipmapHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
 
-   lineWidth?: number;
+  lineWidth?: number;
 
-   polygonOffsetFill?: boolean;
-   polygonOffset?: [number, number];
+  polygonOffsetFill?: boolean;
+  polygonOffset?: [number, number];
 
-   sampleCoverage?: [number, boolean];
+  sampleCoverage?: [number, boolean];
 
-   scissorTest?: boolean;
-   scissor?: [number, number, number, number] | NumberArray;
+  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?:
+  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;
- };
+  viewport?: [number, number, number, number] | NumberArray;
+};
 
- export type GLParameters = GLValueParameters | GLFunctionStyleParameters;
+export type GLParameters = GLValueParameters | GLFunctionStyleParameters;

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

@@ -0,0 +1,244 @@
+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;
+  }
+}

package/src/helpers/program-bindings.ts

@@ -0,0 +1,46 @@
+import {Accessor} from '../types/accessor';
+
+/** Describes an attribute binding for a program */
+export type AttributeBinding = {
+  location: number;
+  name: string;
+  accessor: Accessor;
+}
+
+/** Describes a varying binding for a program */
+export type VaryingBinding = {
+  location: number;
+  name: string;
+  accessor: Accessor;
+}
+
+/** Describes a uniform block binding for a program */
+export type UniformBlockBinding = {
+  location: number;
+  name: string;
+  byteLength: number;
+  vertex: boolean;
+  fragment: boolean;
+  uniformCount: number;
+  uniformIndices: number[];
+}
+
+/** Describes a uniform (sampler etc) binding for a program */
+export type UniformBinding = {
+  location: number;
+  name: string;
+  size: number;
+  type: number;
+  isArray: boolean;
+}
+
+/**
+ * Holds metadata describing attribute configurations for a program's shaders
+ */
+export type ProgramBindings = {
+  readonly attributes: AttributeBinding[];
+  readonly varyings: VaryingBinding[];
+  readonly uniformBlocks: UniformBlockBinding[];
+  // Note - samplers are always in unform bindings, even if uniform blocks are used
+  readonly uniforms: UniformBinding[];
+}

package/src/index.ts

@@ -8,8 +8,8 @@
 import './init';
 
 // export type {WebGLDeviceProps, WebGLDeviceInfo, WebGPUDeviceLimits} from './lib/webgl-device';
-export type {WebGLDeviceProps} from './device/webgl-device';
-export {default as WebGLDevice, getWebGLDevice} from './device/webgl-device';
+export type {WebGLDeviceProps} from './adapter/webgl-device';
+export {default as WebGLDevice, getWebGLDevice} from './adapter/webgl-device';
 
 // UTILS
 export {requestAnimationFrame, cancelAnimationFrame} from './webgl-utils/request-animation-frame';
@@ -29,8 +29,6 @@ export {default as Texture2D} from './classes/texture-2d';
 export type {TextureCubeProps} from './classes/texture-cube';
 export {default as TextureCube} from './classes/texture-cube';
 
-export type {ShaderProps} from './classes/webgl-shader';
-export {Shader, VertexShader, FragmentShader} from './classes/webgl-shader';
 export type {ProgramProps} from './classes/program';
 export {default as Program} from './classes/program';
 export type {FramebufferProps} from './classes/framebuffer';
@@ -38,6 +36,10 @@ export {default as Framebuffer} from './classes/framebuffer';
 export type {RenderbufferProps} from './classes/renderbuffer';
 export {default as Renderbuffer} from './classes/renderbuffer';
 
+// Classic luma.gl classes (For backwards compatibility)
+export type {ShaderProps} from './classes/shader';
+export {Shader, VertexShader, FragmentShader} from './classes/shader';
+
 export {clear, clearBuffer} from './classes/clear';
 
 // Copy and Blit
@@ -63,6 +65,8 @@ export type {VertexArrayProps} from './classes/vertex-array';
 export {default as VertexArray} from './classes/vertex-array';
 export {default as UniformBufferLayout} from './classes/uniform-buffer-layout';
 
+export {setDeviceParameters} from './adapter/converters/set-device-parameters';
+
 // experimental WebGL exports
 
 // UTILS
@@ -113,7 +117,6 @@ export {lumaStats} from './init';
 export {log, assert, uid, isObjectEmpty} from '@luma.gl/api';
 export {setPathPrefix, loadFile, loadImage} from '@luma.gl/api';
 
-
 // export {
 //   getContextInfo, getGLContextInfo, getContextLimits,
 //   FEATURES,
@@ -121,7 +124,10 @@ export {setPathPrefix, loadFile, loadImage} from '@luma.gl/api';
 //   canCompileGLGSExtension
 // } from '@luma.gl/gltools';
 
-// REMOVED in v8.6
+// HELPERS - EXPERIMENTAL
+export {getProgramBindings} from './helpers/get-program-bindings';
+
+// REMOVED in v8.7
 // getShaderInfo,
 // getShaderName
 // getShaderVersion

package/src/init.ts

@@ -1,7 +1,7 @@
 import {log} from '@luma.gl/api';
 import {isBrowser} from '@probe.gl/env';
 import {luma, lumaStats} from '@luma.gl/api';
-import WebGLDevice from './device/webgl-device';
+import WebGLDevice from './adapter/webgl-device';
 
 // Version detection using babel plugin
 // @ts-expect-error

package/src/types/accessor.d.ts

@@ -0,0 +1,29 @@
+// ACCESSORS
+
+/**
+ * Attribute descriptor object
+ */
+export type Accessor = {
+  format?: string;
+  offset?: number;
+  location?: number;
+
+  // can now be described with single WebGPU-style `format` string
+  type?: number;
+  size?: number;
+  normalized?: boolean;
+  integer?: boolean;
+
+  // deprecated - now shared between accessors in the surrounding BufferAccessor object
+  stride?: number;
+  divisor?: number;
+};
+
+/**
+ * List of attribute descriptors for one interleaved buffer
+ */
+export type BufferAccessors = {
+  stride?: number;
+  stepMode?: 'vertex' | 'instance';
+  attributes: Accessor[];
+}