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

package/src/adapter/converters/webgpu-texture-formats.ts

@@ -0,0 +1,167 @@
+import GL from '@luma.gl/constants';
+
+// Define local extension strings to optimize minification
+const SRGB = 'EXT_sRGB';
+const EXT_FLOAT_WEBGL1 = 'WEBGL.color_buffer_float';
+const EXT_FLOAT_WEBGL2 = 'EXT_color_buffer_float';
+const EXT_HALF_FLOAT_WEBGL1 = 'EXT_color_buffer_half_float';
+
+// const S3TC = 'WEBGL_compressed_texture_s3tc';
+// const PVRTC = 'WEBGL_compressed_texture_pvrtc';
+// const ES3 = 'WEBGL_compressed_texture_es3';
+// const ETC1 = 'WEBGL_compressed_texture_etc1';
+// const SRGB = 'EXT_sRGB';
+// const DEPTH = 'WEBGL_depth_texture';
+
+// NOTES:
+// - gl2: format requires WebGL2, when using a WebGL 1 context, color renderbuffer formats are limited
+// - b (bytes per pixel), for memory usage calculations.
+// - c (channels)
+// - p (packed)
+
+export const TEXTURE_FORMAT_DEFINITIONS = {
+  // 8-bit formats
+  'r8unorm': {b: 1, c: 1, gl: GL.R8, gl2: true},
+  'r8snorm': {b: 1, c: 1},
+  'r8uint': {b: 1, c: 1, gl: GL.R8UI, gl2: true},
+  'r8sint': {b: 1, c: 1, gl: GL.R8I, gl2: true},
+
+  // 16-bit formats
+  'r16uint': {b: 2, c: 1, gl: GL.R16UI, gl2: true},
+  'r16sint': {b: 2, c: 1, gl: GL.R16I, gl2: true},
+  'r16float': {b: 2, c: 1, gl: GL.R16F, gl2: EXT_FLOAT_WEBGL2},
+  'rg8unorm': {b: 2, c: 2, gl: GL.RG8, gl2: true},
+  'rg8snorm': {b: 2, c: 2},
+  'rg8uint': {b: 2, c: 2, gl: GL.RG8UI, gl2: true},
+  'rg8sint': {b: 2, c: 2, gl: GL.RG8I, gl2: true},
+
+  // Packed 16-bit formats
+  // 'rgba4norm?': {b: 2, c: 4, gl: GL.RGBA4, wgpu: false},
+  // 'rgb565norm?': {b: 2, c: 4, gl: GL.RGB565, wgpu: false},
+  // 'rgb5a1norm?': {b: 2, c: 4, gl: GL.RGB5_A1, wgpu: false},
+
+  // 24-bit formats
+  // 'rbg8norm?': {b: 3, c: 3, gl: GL.RGB8, gl2: true, wgpu: false},
+
+  // 32-bit formats
+  'r32uint': {b: 4, c: 1, gl: GL.R32UI, gl2: true, bpp: 4},
+  'r32sint': {b: 4, c: 1, gl: GL.R32I, gl2: true, bpp: 4},
+  'r32float': {b: 4, c: 1, gl: GL.R32F, gl2: EXT_FLOAT_WEBGL2, bpp: 4},
+  'rg16uint': {b: 4, c: 1, gl: GL.RG16UI, gl2: true, bpp: 4},
+  'rg16sint': {b: 4, c: 2, gl: GL.RG16I, gl2: true, bpp: 4},
+  // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
+  'rg16float': {b: 4, c: 2, gl: GL.RG16F, gl2: EXT_FLOAT_WEBGL2, bpp: 4},
+  'rgba8unorm': {b: 4, c: 2, gl: GL.RGBA8, gl2: true, bpp: 4},
+
+  'rgba8unorm-srgb': {b: 4, c: 4, gl: GL.SRGB8_ALPHA8, gl2: true, gl1: SRGB, bpp: 4},
+  'rgba8snorm': {b: 4, c: 4},
+  'rgba8uint': {b: 4, c: 4, gl: GL.RGBA8UI, gl2: true, bpp: 4},
+  'rgba8sint': {b: 4, c: 4, gl: GL.RGBA8I, gl2: true, bpp: 4},
+  'bgra8unorm': {b: 4, c: 4},
+  'bgra8unorm-srgb': {b: 4, c: 4},
+
+  // Packed 32-bit formats
+  'rgb9e5ufloat': {b: 4, c: 3, p: 1, gl: GL.RGB9_E5, gl2: true, gl1: 'WEBGL_color_buffer_half_float'},
+  'rg11b10ufloat': {b: 4, c: 3, p: 1, gl: GL.R11F_G11F_B10F, gl2: EXT_FLOAT_WEBGL2},
+  'rgb10a2unorm': {b: 4, c: 4, p: 1, gl: GL.RGB10_A2, gl2: true},
+  // webgl2 only
+  // '?rgb10a2unorm?': {b: 4, c: 4, p: 1, webgpu: false, gl: GL.RGB10_A2UI, gl2: true, bpp: 4},
+
+  // 64-bit formats
+  'rg32uint': {b: 8, c: 2, gl: GL.RG32UI, gl2: true},
+  'rg32sint': {b: 8, c: 2, gl: GL.RG32I, gl2: true},
+  'rg32float': {b: 8, c: 2, gl: GL.RG32F, gl2: EXT_FLOAT_WEBGL2},
+  'rgba16uint': {b: 8, c: 4, gl: GL.RGBA16UI, gl2: true},
+  'rgba16sint': {b: 8, c: 4, gl: GL.RGBA16I, gl2: true},
+  'rgba16float': {b: 8, c: 4, gl: GL.RGBA16F, gl2: EXT_FLOAT_WEBGL2},
+
+  // 96-bit formats
+  // {gl: GL.RGB32F, dataFormat: GL.RGB, types: [GL.FLOAT], gl2: true},
+
+  // 128-bit formats
+  'rgba32uint': {b: 16, c: 4, gl: GL.RGBA32UI, gl2: true},
+  'rgba32sint': {b: 16, c: 4, gl: GL.RGBA32I, gl2: true},
+  'rgba32float': {b: 16, c: 4, gl: GL.RGBA32F, gl2: EXT_FLOAT_WEBGL2}, // gl1: EXT_FLOAT_WEBGL1
+
+  // Depth and stencil formats
+  'stencil8': {b: 1, c: 1, gl: GL.STENCIL_INDEX8}, // 8 stencil bits
+  'depth16unorm': {b: 2, c: 1, gl: GL.DEPTH_COMPONENT16}, // 16 depth bits
+  'depth24plus': {b: 3, c: 1, gl: GL.DEPTH_COMPONENT24, gl2: true},
+  'depth24plus-stencil8': {b: 4, c: 2, p: 1, gl: GL.DEPTH24_STENCIL8, gl2: true},
+  'depth32float': {b: 4, c: 1, gl: GL.DEPTH_COMPONENT32F, gl2: true},
+
+  // "depth24unorm-stencil8" feature
+  'depth24unorm-stencil8': {b: 4, c: 2, p: 1, gl: GL.DEPTH_STENCIL},
+
+  // "depth32float-stencil8" feature
+  "depth32float-stencil8": {b: 5, c: 2, p: 1, gl: GL.DEPTH32F_STENCIL8, gl2: true},
+
+  // BC compressed formats usable if "texture-compression-bc" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  'bc1-rgba-unorm': {},
+  'bc1-rgba-unorm-srgb': {},
+  'bc2-rgba-unorm': {},
+  'bc2-rgba-unorm-srgb': {},
+  'bc3-rgba-unorm': {},
+  'bc3-rgba-unorm-srgb': {},
+  'bc4-r-unorm': {},
+  'bc4-r-snorm': {},
+  'bc5-rg-unorm': {},
+  'bc5-rg-snorm': {},
+  'bc6h-rgb-ufloat': {},
+  'bc6h-rgb-float': {},
+  'bc7-rgba-unorm': {},
+  'bc7-rgba-unorm-srgb': {}
+};
+
+////////////////////////////////////////////////////
+// Compressed formats
+
+// WEBGL_compressed_texture_s3tc
+
+// {gl: GL.COMPRESSED_RGB_S3TC_DXT1_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, compressed: true, gl1: S3TC},
+
+// WEBGL_compressed_texture_es3
+
+// {gl: GL.COMPRESSED_R11_EAC, compressed: true, gl1: ES3}, // RED
+// {gl: GL.COMPRESSED_SIGNED_R11_EAC, compressed: true, gl1: ES3}, // RED
+// {gl: GL.COMPRESSED_RG11_EAC, compressed: true, gl1: ES3}, // RG
+// {gl: GL.COMPRESSED_SIGNED_RG11_EAC, compressed: true, gl1: ES3}, // RG
+// {gl: GL.COMPRESSED_RGB8_ETC2, compressed: true, gl1: ES3}, // RGB
+// {gl: GL.COMPRESSED_RGBA8_ETC2_EAC, compressed: true, gl1: ES3}, // RBG
+// {gl: GL.COMPRESSED_SRGB8_ETC2, compressed: true, gl1: ES3}, // RGB
+// {gl: GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, compressed: true, gl1: ES3}, // RGBA
+// {gl: GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, compressed: true, gl1: ES3}, // RGBA
+// {gl: GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, compressed: true, gl1: ES3}, // RGBA
+/* WebGL2 guaranteed availability compressed formats?
+COMPRESSED_R11_EAC RED
+COMPRESSED_SIGNED_R11_EAC RED
+COMPRESSED_RG11_EAC RG
+COMPRESSED_SIGNED_RG11_EAC RG
+COMPRESSED_RGB8_ETC2 RGB
+COMPRESSED_SRGB8_ETC2 RGB
+COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA
+COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA
+COMPRESSED_RGBA8_ETC2_EAC RGBA
+COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
+*/
+
+// WEBGL_compressed_texture_pvrtc
+
+// {gl: GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, compressed: true, gl1: PVRTC},
+
+// WEBGL_compressed_texture_etc1
+
+// {gl: GL.COMPRESSED_RGB_ETC1_WEBGL, compressed: true, gl1: ETC1},
+
+// WEBGL_compressed_texture_atc
+
+// {gl: GL.COMPRESSED_RGB_ATC_WEBGL, compressed: true, gl1: ETC1},
+// {gl: GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, compressed: true, gl1: ETC1},
+// {gl: GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, compressed: true, gl1: ETC1}

package/src/{device → adapter/device-helpers}/device-features.ts

@@ -3,10 +3,10 @@
 // available in an WebGL1 or WebGL2 environment.
 
 import GL from '@luma.gl/constants';
-import {isWebGL2} from '../context/context/webgl-checks';
-import {isOldIE} from '../webgl-utils/is-old-ie';
+import {isWebGL2} from '../../context/context/webgl-checks';
+import {isOldIE} from './is-old-ie';
 
-export type DeviceFeature = 
+export type DeviceFeature =
   'depth-clamping' |
   'depth24unorm-stencil8' |
   'depth32float-stencil8' |
@@ -15,7 +15,7 @@ export type DeviceFeature =
   'texture-compression-bc';
 
 // TODO - this should be the default export, test cases need updating
-export type WebGLFeature = 
+export type WebGLFeature =
   'webgl2' |
 
   // api support (unify with WebGPU timestamp-query?)

package/src/{device → adapter/device-helpers}/device-limits.ts

@@ -1,7 +1,7 @@
 // luma.gl, MIT license
 import type {DeviceLimits} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import {getWebGL2Context} from '../context/context/webgl-checks';
+import {getWebGL2Context} from '../../context/context/webgl-checks';
 
 /** Populate a WebGPU style device limits */
 export function getDeviceLimits(gl: WebGLRenderingContext): DeviceLimits {

package/src/{device → adapter/device-helpers}/get-device-info.ts

@@ -1,7 +1,7 @@
 import {DeviceInfo} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import {isWebGL2} from '../context/context/webgl-checks';
-  
+import {isWebGL2} from '../../context/context/webgl-checks';
+
 /** @returns strings identifying the GPU vendor and driver. */
 export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
   const vendorMasked = gl.getParameter(GL.VENDOR);

package/src/{device → adapter}/webgl-device.ts

@@ -7,14 +7,14 @@ import {getDevicePixelRatio, setDevicePixelRatio} from '../context/context/devic
 import {createBrowserContext} from '../context/context/create-context';
 import {getCanvas} from '../context/context/get-canvas';
 import {isWebGL, isWebGL2} from '../context/context/webgl-checks';
-import {getDeviceInfo} from './get-device-info';
-import {getDeviceFeatures, Feature} from './device-features';
-import {getDeviceLimits, getWebGLLimits, WebGLLimits} from './device-limits';
+import {getDeviceInfo} from './device-helpers/get-device-info';
+import {getDeviceFeatures, Feature} from './device-helpers/device-features';
+import {getDeviceLimits, getWebGLLimits, WebGLLimits} from './device-helpers/device-limits';
 
 // WebGL classes
 import type {BufferProps, ShaderProps} from '@luma.gl/api';
 import WEBGLBuffer from '../classes/webgl-buffer';
-import {WEBGLShader} from '../classes/webgl-shader';
+import {WEBGLShader} from '../adapter/webgl-shader';
 import Texture2D, {Texture2DProps} from '../classes/texture-2d';
 import type {default as Framebuffer} from '../classes/framebuffer';
 import type {default as VertexArrayObject} from '../classes/vertex-array-object';
@@ -111,7 +111,7 @@ export default class WebGLDevice extends Device implements ContextState {
   _polyfilled: boolean = false;
 
   /**
-   * 
+   *
    */
   static fromContext(gl: WebGLRenderingContext): WebGLDevice {
     // @ts-expect-error
@@ -130,7 +130,7 @@ export default class WebGLDevice extends Device implements ContextState {
   ): WebGLDevice {
     if (gl instanceof WebGLDevice) {
       return gl;
-    }  
+    }
     if (!isWebGL(gl)) {
       throw new Error('Invalid WebGLRenderingContext');
     }
@@ -140,7 +140,7 @@ export default class WebGLDevice extends Device implements ContextState {
 
   constructor(props: WebGLDeviceProps) {
     super();
-    
+
     this.props = {...DEFAULT_DEVICE_PROPS, ...props};
 
     // If attaching to an already attached context, return the attached device
@@ -275,11 +275,11 @@ export default class WebGLDevice extends Device implements ContextState {
   }
 
   createTexture(props: Texture2DProps): Texture2D {
-    return new Texture2D(this.gl, props);
+    return new Texture2D(this, props);
   }
 
   createShader(props: ShaderProps): WEBGLShader {
-    return new WEBGLShader(this.gl, props);
+    return new WEBGLShader(this, props);
   }
 
   /**

package/src/adapter/webgl-shader.ts

@@ -0,0 +1,84 @@
+// luma.gl, MIT license
+import {log, uid, Shader, ShaderProps} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import {getShaderInfo, CompilerMessage, formatCompilerLog} from '@luma.gl/shadertools';
+import {parseShaderCompilerLog} from '../webgl-utils/parse-shader-compiler-log';
+import WebGLDevice from '../adapter/webgl-device';
+
+/**
+ * An immutable compiled shader program that execute portions of the GPU Pipeline
+ */
+ export class WEBGLShader extends Shader {
+  readonly device: WebGLDevice;
+  readonly gl: WebGLRenderingContext;
+  readonly handle: WebGLShader;
+
+  readonly stage: 'vertex' | 'fragment';
+  readonly source: string;
+
+  constructor(device: WebGLDevice, props: ShaderProps) {
+    super(device, {id: getShaderIdFromProps(props), ...props});
+    this.device = device;
+    this.gl = device.gl;
+    switch (this.props.stage) {
+      case 'vertex':
+        this.handle = this.props.handle || this.gl.createShader(GL.VERTEX_SHADER);
+        break;
+      case 'fragment':
+        this.handle = this.props.handle || this.gl.createShader(GL.FRAGMENT_SHADER);
+        break;
+      default:
+        throw new Error(this.props.stage);
+    }
+    this.stage = this.props.stage;
+    this.source = this.props.source;
+    this._compile(this.source);
+  }
+
+  destroy(): void {
+    if (this.handle) {
+      this.removeStats();
+      this.gl.deleteShader(this.handle);
+      // @ts-expect-error
+      this.handle = null;
+    }
+  }
+
+  async compilationInfo(): Promise<readonly CompilerMessage[]> {
+    const log = this.gl.getShaderInfoLog(this.handle);
+    return parseShaderCompilerLog(log);
+  }
+
+  // PRIVATE METHODS
+
+  _compile(source) {
+    const addGLSLVersion = source => source.startsWith('#version ') ? source : `#version 100\n${source}`;
+    source = addGLSLVersion(source);
+
+    this.gl.shaderSource(this.handle, source);
+    this.gl.compileShader(this.handle);
+
+    // TODO - For performance reasons, avoid checking shader compilation errors on production?
+    // TODO - Load log even when no error reported, to catch warnings?
+    // https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
+    const compileStatus = this.gl.getShaderParameter(this.handle, GL.COMPILE_STATUS);
+    if (!compileStatus) {
+      const shaderLog = this.gl.getShaderInfoLog(this.handle);
+      const messages = parseShaderCompilerLog(shaderLog).filter(message => message.type === 'error');
+      const formattedLog = formatCompilerLog(messages, source);
+      const shaderName: string = getShaderInfo(source).name;
+      const shaderDescription = `${this.stage} shader ${shaderName}`;
+      log.error(`GLSL compilation errors in ${shaderDescription}\n${formattedLog}`)();
+      throw new Error(`GLSL compilation errors in ${shaderName}`);
+    }
+  }
+}
+
+// HELPERS
+
+/** Deduce an id, from shader source, or supplied id, or shader type */
+function getShaderIdFromProps(props: ShaderProps): string {
+  return getShaderInfo(props.source).name ||
+    props.id ||
+    uid(`unnamed ${props.stage}-shader`);
+}

package/src/classes/framebuffer.ts

@@ -1,6 +1,6 @@
 import {log, assert} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import {getWebGL2Context, assertWebGL2Context} from '../context/context/webgl-checks';
 import {getKey} from '../webgl-utils/constants-to-keys';
 import Resource, {ResourceProps} from './webgl-resource';

package/src/classes/program-configuration.ts

@@ -1,8 +1,9 @@
 // Contains metadata describing attribute configurations for a program's shaders
 // Much of this is automatically extracted from shaders after program linking
-import Accessor from './accessor';
-import {isWebGL2} from '../context/context/webgl-checks';
-import {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';
+// import Accessor from './accessor';
+import type Program from './program';
+import type {AttributeBinding, VaryingBinding} from '../helpers/program-bindings';
+import {getProgramBindings} from '../helpers/get-program-bindings';
 
 /**
  * is a mechanism for taking a program object and querying information
@@ -12,22 +13,32 @@ import {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';
  */
  export default class ProgramConfiguration {
   id: string;
-  attributeInfos: any[] = [];
-  attributeInfosByName: Record<string, any> = {};
+  attributeInfos: AttributeBinding[] = [];
+  attributeInfosByName: Record<string, AttributeBinding> = {};
   // Locations may not be contiguous the case of matrix attributes
   // so keep a separate location->attribute map.
-  attributeInfosByLocation: any[] = [];
-  varyingInfos: any[] = [];
-  varyingInfosByName: Record<string, any> = {};
+  attributeInfosByLocation: AttributeBinding[] = [];
+  varyingInfos: VaryingBinding[] = [];
+  varyingInfosByName: Record<string, VaryingBinding> = {};
 
-  constructor(program) {
+  constructor(program: Program) {
     this.id = program.id;
     Object.seal(this);
-    this._readAttributesFromProgram(program);
-    this._readVaryingsFromProgram(program);
+
+    const bindings = getProgramBindings(program.gl2, program.handle);
+
+    this.attributeInfos = bindings.attributes;
+    for (const attributeInfo of bindings.attributes) {
+      this.attributeInfosByName[attributeInfo.name] = attributeInfo;
+      this.attributeInfosByLocation[attributeInfo.location] = attributeInfo;
+    }
+
+    for (const varyingInfo of bindings.varyings) {
+      this.varyingInfosByName[varyingInfo.name] = varyingInfo;
+    }
   }
 
-  getAttributeInfo(locationOrName) {
+  getAttributeInfo(locationOrName: number | string): AttributeBinding {
     const location = Number(locationOrName);
     if (Number.isFinite(location)) {
       return this.attributeInfosByLocation[location];
@@ -36,17 +47,17 @@ import {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';
   }
 
   // Resolves an attribute name or index to an index
-  getAttributeLocation(locationOrName) {
+  getAttributeLocation(locationOrName: number | string): number {
     const attributeInfo = this.getAttributeInfo(locationOrName);
     return attributeInfo ? attributeInfo.location : -1;
   }
 
-  getAttributeAccessor(locationOrName) {
+  getAttributeAccessor(locationOrName: number | string) {
     const attributeInfo = this.getAttributeInfo(locationOrName);
     return attributeInfo ? attributeInfo.accessor : null;
   }
 
-  getVaryingInfo(locationOrName) {
+  getVaryingInfo(locationOrName: number | string): VaryingBinding {
     const location = Number(locationOrName);
     if (Number.isFinite(location)) {
       return this.varyingInfos[location];
@@ -54,77 +65,13 @@ import {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';
     return this.varyingInfosByName[locationOrName] || null;
   }
 
-  getVaryingIndex(locationOrName) {
+  getVaryingIndex(locationOrName: number | string): number {
     const varying = this.getVaryingInfo(locationOrName);
     return varying ? varying.location : -1;
   }
 
-  getVaryingAccessor(locationOrName) {
+  getVaryingAccessor(locationOrName: number | string) {
     const varying = this.getVaryingInfo(locationOrName);
     return varying ? varying.accessor : null;
   }
-
-  // PRIVATE METHODS
-
-  // linkProgram needs to have been called, although linking does not need to have been successful
-  _readAttributesFromProgram(program) {
-    const {gl} = program;
-    const count = gl.getProgramParameter(program.handle, gl.ACTIVE_ATTRIBUTES);
-
-    for (let index = 0; index < count; index++) {
-      const {name, type, size} = gl.getActiveAttrib(program.handle, index);
-      const location = gl.getAttribLocation(program.handle, name);
-      // Add only user provided attributes, for built-in attributes like
-      // `gl_InstanceID` locaiton will be < 0
-      if (location >= 0) {
-        this._addAttribute(location, name, type, size);
-      }
-    }
-
-    this.attributeInfos.sort((a, b) => a.location - b.location);
-  }
-
-  // linkProgram needs to have been called, although linking does not need to have been successful
-  _readVaryingsFromProgram(program) {
-    const {gl} = program;
-    if (!isWebGL2(gl)) {
-      return;
-    }
-
-    const count = gl.getProgramParameter(program.handle, gl.TRANSFORM_FEEDBACK_VARYINGS);
-    for (let location = 0; location < count; location++) {
-      const {name, type, size} = gl.getTransformFeedbackVarying(program.handle, location);
-      this._addVarying(location, name, type, size);
-    }
-
-    this.varyingInfos.sort((a, b) => a.location - b.location);
-  }
-
-  _addAttribute(location, name, compositeType, size) {
-    const {type, components} = decomposeCompositeGLType(compositeType);
-    const accessor = {type, size: size * components};
-    this._inferProperties(location, name, accessor);
-
-    const attributeInfo = {location, name, accessor: new Accessor(accessor)}; // Base values
-    this.attributeInfos.push(attributeInfo);
-    this.attributeInfosByLocation[location] = attributeInfo; // For quick location based lookup
-    this.attributeInfosByName[attributeInfo.name] = attributeInfo; // For quick name based lookup
-  }
-
-  // Extract additional attribute metadata from shader names (based on attribute naming conventions)
-  _inferProperties(location, name, accessor) {
-    if (/instance/i.test(name)) {
-      // Any attribute containing the word "instance" will be assumed to be instanced
-      accessor.divisor = 1;
-    }
-  }
-
-  _addVarying(location, name, compositeType, size) {
-    const {type, components} = decomposeCompositeGLType(compositeType);
-    const accessor = new Accessor({type, size: size * components});
-
-    const varying = {location, name, accessor}; // Base values
-    this.varyingInfos.push(varying);
-    this.varyingInfosByName[varying.name] = varying; // For quick name based lookup
-  }
 }