@luma.gl/webgl 9.0.0-alpha.45 → 9.0.0-alpha.47

package/dist/index.cjs

@@ -57,7 +57,6 @@ var __async = (__this, __arguments, generator) => {
 var src_exports = {};
 __export(src_exports, {
   Accessor: () => Accessor,
-  BufferWithAccessor: () => BufferWithAccessor,
   WEBGLBuffer: () => WEBGLBuffer,
   WEBGLCommandEncoder: () => WEBGLCommandEncoder,
   WEBGLFramebuffer: () => WEBGLFramebuffer,
@@ -68,6 +67,7 @@ __export(src_exports, {
   WEBGLSampler: () => WEBGLSampler,
   WEBGLShader: () => WEBGLShader,
   WEBGLTexture: () => WEBGLTexture,
+  WEBGLTransformFeedback: () => WEBGLTransformFeedback,
   WEBGLVertexArray: () => WEBGLVertexArray,
   WebGLCanvasContext: () => WebGLCanvasContext,
   WebGLDevice: () => WebGLDevice,
@@ -1357,7 +1357,7 @@ var GLState = class {
   constructor(gl, {
     copyState = false,
     // Copy cache from params (slow) or initialize from WebGL defaults (fast)
-    log: log9 = () => {
+    log: log10 = () => {
     }
     // Logging function, called when gl parameter change calls are actually issued
   } = {}) {
@@ -1366,7 +1366,7 @@ var GLState = class {
     this.enable = true;
     this.gl = gl;
     this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
-    this.log = log9;
+    this.log = log10;
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
   }
@@ -2111,6 +2111,7 @@ var WEBGL_FEATURES = {
   "webgl": [true, true],
   "webgl2": [false, true],
   "timer-query-webgl": ["EXT_disjoint_timer_query", "EXT_disjoint_timer_query_webgl2"],
+  "transform-feedback-webgl2": [false, true],
   // WEBGL1 SUPPORT
   "vertex-array-object-webgl1": ["OES_vertex_array_object", true],
   "instanced-rendering-webgl1": ["ANGLE_instanced_arrays", true],
@@ -2613,6 +2614,7 @@ var WEBGLBuffer = class extends import_core7.Buffer {
   readAsync(byteOffset = 0, byteLength) {
     return __async(this, null, function* () {
       this.device.assertWebGL2();
+      byteLength = byteLength != null ? byteLength : this.byteLength;
       const data = new Uint8Array(byteLength);
       const dstOffset = 0;
       this.gl.bindBuffer(import_constants10.GL.COPY_READ_BUFFER, this.handle);
@@ -4088,490 +4090,9 @@ function onValidateGLFunc(props, functionName, functionArgs) {
   }
 }
 
-// src/classic/buffer-with-accessor.ts
-var import_core19 = require("@luma.gl/core");
-var import_constants18 = require("@luma.gl/constants");
-
-// src/classic/accessor.ts
+// src/adapter/resources/webgl-shader.ts
 var import_core18 = require("@luma.gl/core");
-var import_constants17 = require("@luma.gl/constants");
-
-// src/classic/typed-array-utils.ts
 var import_constants16 = require("@luma.gl/constants");
-var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array";
-function getGLTypeFromTypedArray(arrayOrType) {
-  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
-  switch (type) {
-    case Float32Array:
-      return import_constants16.GL.FLOAT;
-    case Uint16Array:
-      return import_constants16.GL.UNSIGNED_SHORT;
-    case Uint32Array:
-      return import_constants16.GL.UNSIGNED_INT;
-    case Uint8Array:
-      return import_constants16.GL.UNSIGNED_BYTE;
-    case Uint8ClampedArray:
-      return import_constants16.GL.UNSIGNED_BYTE;
-    case Int8Array:
-      return import_constants16.GL.BYTE;
-    case Int16Array:
-      return import_constants16.GL.SHORT;
-    case Int32Array:
-      return import_constants16.GL.INT;
-    default:
-      throw new Error(ERR_TYPE_DEDUCTION);
-  }
-}
-function getTypedArrayFromGLType(glType, options) {
-  const { clamped = true } = options || {};
-  switch (glType) {
-    case import_constants16.GL.FLOAT:
-      return Float32Array;
-    case import_constants16.GL.UNSIGNED_SHORT:
-    case import_constants16.GL.UNSIGNED_SHORT_5_6_5:
-    case import_constants16.GL.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants16.GL.UNSIGNED_SHORT_5_5_5_1:
-      return Uint16Array;
-    case import_constants16.GL.UNSIGNED_INT:
-      return Uint32Array;
-    case import_constants16.GL.UNSIGNED_BYTE:
-      return clamped ? Uint8ClampedArray : Uint8Array;
-    case import_constants16.GL.BYTE:
-      return Int8Array;
-    case import_constants16.GL.SHORT:
-      return Int16Array;
-    case import_constants16.GL.INT:
-      return Int32Array;
-    default:
-      throw new Error("Failed to deduce typed array type from GL constant");
-  }
-}
-
-// src/classic/accessor.ts
-var DEFAULT_ACCESSOR_VALUES = {
-  offset: 0,
-  stride: 0,
-  type: import_constants17.GL.FLOAT,
-  size: 1,
-  divisor: 0,
-  normalized: false,
-  integer: false
-};
-var PROP_CHECKS = {
-  deprecatedProps: {
-    instanced: "divisor",
-    isInstanced: "divisor"
-  }
-};
-var Accessor = class {
-  static getBytesPerElement(accessor) {
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
-    return ArrayType.BYTES_PER_ELEMENT;
-  }
-  static getBytesPerVertex(accessor) {
-    (0, import_core18.assert)(accessor.size);
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
-    return ArrayType.BYTES_PER_ELEMENT * accessor.size;
-  }
-  // Combines (merges) a list of accessors. On top of default values
-  // Usually [programAccessor, bufferAccessor, appAccessor]
-  // All props will be set in the returned object.
-  // TODO check for conflicts between values in the supplied accessors
-  static resolve(...accessors) {
-    return new Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]);
-  }
-  constructor(...accessors) {
-    accessors.forEach((accessor) => this._assign(accessor));
-    Object.freeze(this);
-  }
-  toString() {
-    return JSON.stringify(this);
-  }
-  // ACCESSORS
-  // TODO - remove>
-  get BYTES_PER_ELEMENT() {
-    return Accessor.getBytesPerElement(this);
-  }
-  get BYTES_PER_VERTEX() {
-    return Accessor.getBytesPerVertex(this);
-  }
-  // PRIVATE
-  // eslint-disable-next-line complexity, max-statements
-  _assign(props = {}) {
-    props = (0, import_core18.checkProps)("Accessor", props, PROP_CHECKS);
-    if (props.type !== void 0) {
-      this.type = props.type;
-      if (props.type === import_constants17.GL.INT || props.type === import_constants17.GL.UNSIGNED_INT) {
-        this.integer = true;
-      }
-    }
-    if (props.size !== void 0) {
-      this.size = props.size;
-    }
-    if (props.offset !== void 0) {
-      this.offset = props.offset;
-    }
-    if (props.stride !== void 0) {
-      this.stride = props.stride;
-    }
-    if (props.normalize !== void 0) {
-      this.normalized = props.normalize;
-    }
-    if (props.normalized !== void 0) {
-      this.normalized = props.normalized;
-    }
-    if (props.integer !== void 0) {
-      this.integer = props.integer;
-    }
-    if (props.divisor !== void 0) {
-      this.divisor = props.divisor;
-    }
-    if (props.buffer !== void 0) {
-      this.buffer = props.buffer;
-    }
-    if (props.index !== void 0) {
-      if (typeof props.index === "boolean") {
-        this.index = props.index ? 1 : 0;
-      } else {
-        this.index = props.index;
-      }
-    }
-    if (props.instanced !== void 0) {
-      this.divisor = props.instanced ? 1 : 0;
-    }
-    if (props.isInstanced !== void 0) {
-      this.divisor = props.isInstanced ? 1 : 0;
-    }
-    if (this.offset === void 0)
-      delete this.offset;
-    if (this.stride === void 0)
-      delete this.stride;
-    if (this.type === void 0)
-      delete this.type;
-    if (this.size === void 0)
-      delete this.size;
-    if (this.divisor === void 0)
-      delete this.divisor;
-    if (this.normalized === void 0)
-      delete this.normalized;
-    if (this.integer === void 0)
-      delete this.integer;
-    if (this.buffer === void 0)
-      delete this.buffer;
-    if (this.index === void 0)
-      delete this.index;
-    return this;
-  }
-};
-
-// src/classic/buffer-with-accessor.ts
-var DEBUG_DATA_LENGTH2 = 10;
-var DEPRECATED_PROPS = {
-  offset: "accessor.offset",
-  stride: "accessor.stride",
-  type: "accessor.type",
-  size: "accessor.size",
-  divisor: "accessor.divisor",
-  normalized: "accessor.normalized",
-  integer: "accessor.integer",
-  instanced: "accessor.divisor",
-  isInstanced: "accessor.divisor"
-};
-var PROP_CHECKS_INITIALIZE = {
-  removedProps: {},
-  replacedProps: {
-    bytes: "byteLength"
-  },
-  // new Buffer() with individual accessor props is still used in apps, emit warnings
-  deprecatedProps: DEPRECATED_PROPS
-};
-var PROP_CHECKS_SET_PROPS = {
-  // Buffer.setProps() with individual accessor props is rare => emit errors
-  removedProps: DEPRECATED_PROPS
-};
-function getWEBGLBufferProps(props) {
-  if (ArrayBuffer.isView(props)) {
-    return { data: props };
-  } else if (typeof props === "number") {
-    return { byteLength: props };
-  }
-  props = (0, import_core19.checkProps)("Buffer", props, PROP_CHECKS_INITIALIZE);
-  const bufferProps = __spreadValues({}, props);
-  return bufferProps;
-}
-var BufferWithAccessor = class extends WEBGLBuffer {
-  constructor(device, props = {}) {
-    super(WebGLDevice.attach(device), getWEBGLBufferProps(props));
-    this.setAccessor(Object.assign({}, props, props.accessor));
-    if (this.props.data) {
-      const type = getGLTypeFromTypedArray(this.props.data);
-      (0, import_core19.assert)(type);
-      this.setAccessor(new Accessor(this.accessor, { type }));
-    }
-    Object.seal(this);
-  }
-  // override write(data: TypedArray, byteOffset: number = 0): void {
-  //   this.subData({data, offset: byteOffset});
-  // }
-  // returns number of elements in the buffer (assuming that the full buffer is used)
-  getElementCount(accessor = this.accessor) {
-    return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor));
-  }
-  // returns number of vertices in the buffer (assuming that the full buffer is used)
-  getVertexCount(accessor = this.accessor) {
-    return Math.round(this.byteLength / Accessor.getBytesPerVertex(accessor));
-  }
-  // Creates and initializes the buffer object's data store.
-  // Signature: `new Buffer(gl, {data: new Float32Array(...)})`
-  // Signature: `new Buffer(gl, new Float32Array(...))`
-  // Signature: `new Buffer(gl, 100)`
-  initialize(props = {}) {
-    if (ArrayBuffer.isView(props)) {
-      props = { data: props };
-    }
-    if (Number.isFinite(props)) {
-      props = { byteLength: props };
-    }
-    props = (0, import_core19.checkProps)("Buffer", props, PROP_CHECKS_INITIALIZE);
-    this.glUsage = props.glUsage || import_constants18.GL.STATIC_DRAW;
-    this.debugData = null;
-    this.setAccessor(Object.assign({}, props, props.accessor));
-    if (props.data) {
-      this._setData(props.data, props.byteOffset, props.byteLength);
-    } else {
-      this._setByteLength(props.byteLength || 0);
-    }
-    return this;
-  }
-  setProps(props) {
-    props = (0, import_core19.checkProps)("Buffer", props, PROP_CHECKS_SET_PROPS);
-    if ("accessor" in props) {
-      this.setAccessor(props.accessor);
-    }
-    return this;
-  }
-  // Optionally stores an accessor with the buffer, makes it easier to use it as an attribute later
-  // {type, size = 1, offset = 0, stride = 0, normalized = false, integer = false, divisor = 0}
-  setAccessor(accessor) {
-    accessor = Object.assign({}, accessor);
-    delete accessor.buffer;
-    this.accessor = new Accessor(accessor);
-    return this;
-  }
-  // Allocate a bigger GPU buffer (if the current buffer is not big enough).
-  // If a reallocation is triggered it clears the buffer
-  // Returns:
-  //  `true`: buffer was reallocated, data was cleared
-  //  `false`: buffer was big enough, data is intact
-  reallocate(byteLength) {
-    if (byteLength > this.byteLength) {
-      this._setByteLength(byteLength);
-      return true;
-    }
-    this.bytesUsed = byteLength;
-    return false;
-  }
-  // Update with new data. Reinitializes the buffer
-  setData(props) {
-    return this.initialize(props);
-  }
-  // Updates a subset of a buffer object's data store.
-  // Data (Typed Array or ArrayBuffer), length is inferred unless provided
-  // Offset into buffer
-  // WebGL2 only: Offset into srcData
-  // WebGL2 only: Number of bytes to be copied
-  subData(options) {
-    if (ArrayBuffer.isView(options)) {
-      options = { data: options };
-    }
-    const { data, offset = 0, srcOffset = 0 } = options;
-    const byteLength = options.byteLength || options.length;
-    (0, import_core19.assert)(data);
-    const glTarget = this.gl.webgl2 ? import_constants18.GL.COPY_WRITE_BUFFER : this.glTarget;
-    this.gl.bindBuffer(glTarget, this.handle);
-    if (srcOffset !== 0 || byteLength !== void 0) {
-      assertWebGL2Context(this.gl);
-      this.gl.bufferSubData(this.glTarget, offset, data, srcOffset, byteLength);
-    } else {
-      this.gl.bufferSubData(glTarget, offset, data);
-    }
-    this.gl.bindBuffer(glTarget, null);
-    this.debugData = null;
-    this._inferType(data);
-    return this;
-  }
-  /**
-   * Copies part of the data of another buffer into this buffer
-   * @note WEBGL2 ONLY
-   */
-  copyData(options) {
-    const { sourceBuffer, readOffset = 0, writeOffset = 0, size } = options;
-    const { gl, gl2 } = this;
-    assertWebGL2Context(gl);
-    gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, sourceBuffer.handle);
-    gl.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, this.handle);
-    gl2 == null ? void 0 : gl2.copyBufferSubData(import_constants18.GL.COPY_READ_BUFFER, import_constants18.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-    gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, null);
-    gl.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, null);
-    this.debugData = null;
-    return this;
-  }
-  /**
-   * Reads data from buffer into an ArrayBufferView or SharedArrayBuffer.
-   * @note WEBGL2 ONLY
-   */
-  getData(options) {
-    var _a;
-    let { dstData = null, length = 0 } = options || {};
-    const { srcByteOffset = 0, dstOffset = 0 } = options || {};
-    assertWebGL2Context(this.gl);
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants18.GL.FLOAT, { clamped: false });
-    const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);
-    const dstElementOffset = dstOffset;
-    let dstAvailableElementCount;
-    let dstElementCount;
-    if (dstData) {
-      dstElementCount = dstData.length;
-      dstAvailableElementCount = dstElementCount - dstElementOffset;
-    } else {
-      dstAvailableElementCount = Math.min(
-        sourceAvailableElementCount,
-        length || sourceAvailableElementCount
-      );
-      dstElementCount = dstElementOffset + dstAvailableElementCount;
-    }
-    const copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount);
-    length = length || copyElementCount;
-    (0, import_core19.assert)(length <= copyElementCount);
-    dstData = dstData || new ArrayType(dstElementCount);
-    this.gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, this.handle);
-    (_a = this.gl2) == null ? void 0 : _a.getBufferSubData(import_constants18.GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
-    this.gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, null);
-    return dstData;
-  }
-  /**
-   * Binds a buffer to a given binding point (target).
-   *   GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER take an index, and optionally a range.
-   *   - GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER need an index to affect state
-   *   - GL.UNIFORM_BUFFER: `offset` must be aligned to GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT.
-   *   - GL.UNIFORM_BUFFER: `size` must be a minimum of GL.UNIFORM_BLOCK_SIZE_DATA.
-   */
-  bind(options) {
-    var _a, _b;
-    const {
-      glTarget = this.glTarget,
-      // target for the bind operation
-      index = this.accessor && this.accessor.index,
-      // index = index of target (indexed bind point)
-      offset = 0,
-      size
-    } = options || {};
-    if (glTarget === import_constants18.GL.UNIFORM_BUFFER || glTarget === import_constants18.GL.TRANSFORM_FEEDBACK_BUFFER) {
-      if (size !== void 0) {
-        (_a = this.gl2) == null ? void 0 : _a.bindBufferRange(glTarget, index, this.handle, offset, size);
-      } else {
-        (0, import_core19.assert)(offset === 0);
-        (_b = this.gl2) == null ? void 0 : _b.bindBufferBase(glTarget, index, this.handle);
-      }
-    } else {
-      this.gl.bindBuffer(glTarget, this.handle);
-    }
-    return this;
-  }
-  unbind(options) {
-    var _a;
-    const { glTarget = this.glTarget, index = this.accessor && this.accessor.index } = options || {};
-    const isIndexedBuffer = glTarget === import_constants18.GL.UNIFORM_BUFFER || glTarget === import_constants18.GL.TRANSFORM_FEEDBACK_BUFFER;
-    if (isIndexedBuffer) {
-      (_a = this.gl2) == null ? void 0 : _a.bindBufferBase(glTarget, index, null);
-    } else {
-      this.gl.bindBuffer(glTarget, null);
-    }
-    return this;
-  }
-  // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
-  // Returns a short initial data array
-  getDebugData() {
-    if (!this.debugData) {
-      this.debugData = this.getData({ length: Math.min(DEBUG_DATA_LENGTH2, this.byteLength) });
-      return { data: this.debugData, changed: true };
-    }
-    return { data: this.debugData, changed: false };
-  }
-  invalidateDebugData() {
-    this.debugData = null;
-  }
-  // PRIVATE METHODS
-  // Allocate a new buffer and initialize to contents of typed array
-  _setData(data, offset = 0, byteLength = data.byteLength + offset) {
-    (0, import_core19.assert)(ArrayBuffer.isView(data));
-    this.trackDeallocatedMemory();
-    const target = this._getTarget();
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, byteLength, this.glUsage);
-    this.gl.bufferSubData(target, offset, data);
-    this.gl.bindBuffer(target, null);
-    this.debugData = data.slice(0, DEBUG_DATA_LENGTH2);
-    this.bytesUsed = byteLength;
-    this.byteLength = byteLength;
-    this.trackAllocatedMemory(byteLength);
-    const type = getGLTypeFromTypedArray(data);
-    (0, import_core19.assert)(type);
-    this.setAccessor(new Accessor(this.accessor, { type }));
-    return this;
-  }
-  // Allocate a GPU buffer of specified size.
-  _setByteLength(byteLength) {
-    (0, import_core19.assert)(byteLength >= 0);
-    this.trackDeallocatedMemory();
-    let data = byteLength;
-    if (byteLength === 0) {
-      data = new Float32Array(0);
-    }
-    const glTarget = this._getTarget();
-    this.gl.bindBuffer(glTarget, this.handle);
-    this.gl.bufferData(glTarget, data, this.glUsage);
-    this.gl.bindBuffer(glTarget, null);
-    this.debugData = null;
-    this.bytesUsed = byteLength;
-    this.byteLength = byteLength;
-    this.trackAllocatedMemory(byteLength);
-    return this;
-  }
-  // Binding a buffer for the first time locks the type
-  // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
-  _getTarget() {
-    return this.gl.webgl2 ? import_constants18.GL.COPY_WRITE_BUFFER : this.glTarget;
-  }
-  _getAvailableElementCount(srcByteOffset) {
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants18.GL.FLOAT, { clamped: false });
-    const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
-    return this.getElementCount() - sourceElementOffset;
-  }
-  // Automatically infers type from typed array passed to setData
-  // Note: No longer that useful, since type is now autodeduced from the compiled shaders
-  _inferType(data) {
-    if (!this.accessor.type) {
-      this.setAccessor(new Accessor(this.accessor, { type: getGLTypeFromTypedArray(data) }));
-    }
-  }
-  // RESOURCE METHODS
-  getParameter(pname) {
-    this.gl.bindBuffer(this.glTarget, this.handle);
-    const value = this.gl.getBufferParameter(this.glTarget, pname);
-    this.gl.bindBuffer(this.glTarget, null);
-    return value;
-  }
-  // DEPRECATIONS - v7.0
-  /** @deprecated Use Buffer.accessor.type */
-  get type() {
-    return this.accessor.type;
-  }
-};
-
-// src/adapter/resources/webgl-shader.ts
-var import_core20 = require("@luma.gl/core");
-var import_constants19 = require("@luma.gl/constants");
 
 // src/adapter/helpers/get-shader-info.ts
 function getShaderInfo(source, defaultName) {
@@ -4631,16 +4152,16 @@ function parseShaderCompilerLog(errLog) {
 }
 
 // src/adapter/resources/webgl-shader.ts
-var WEBGLShader = class extends import_core20.Shader {
+var WEBGLShader = class extends import_core18.Shader {
   constructor(device, props) {
     super(device, __spreadValues({ id: getShaderIdFromProps(props) }, props));
     this.device = device;
     switch (this.props.stage) {
       case "vertex":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants19.GL.VERTEX_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants16.GL.VERTEX_SHADER);
         break;
       case "fragment":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants19.GL.FRAGMENT_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants16.GL.FRAGMENT_SHADER);
         break;
       default:
         throw new Error(this.props.stage);
@@ -4656,8 +4177,8 @@ var WEBGLShader = class extends import_core20.Shader {
   }
   compilationInfo() {
     return __async(this, null, function* () {
-      const log9 = this.device.gl.getShaderInfoLog(this.handle);
-      return log9 ? parseShaderCompilerLog(log9) : [];
+      const log10 = this.device.gl.getShaderInfoLog(this.handle);
+      return log10 ? parseShaderCompilerLog(log10) : [];
     });
   }
   // PRIVATE METHODS
@@ -4668,32 +4189,32 @@ ${source2}`;
     const { gl } = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
-    const compileStatus = gl.getShaderParameter(this.handle, import_constants19.GL.COMPILE_STATUS);
+    const compileStatus = gl.getShaderParameter(this.handle, import_constants16.GL.COMPILE_STATUS);
     if (!compileStatus) {
       const shaderLog = gl.getShaderInfoLog(this.handle);
       const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
       const messages = parsedLog.filter((message2) => message2.type === "error");
-      const formattedLog = (0, import_core20.formatCompilerLog)(messages, source, { showSourceCode: true });
+      const formattedLog = (0, import_core18.formatCompilerLog)(messages, source, { showSourceCode: true });
       const shaderName = getShaderInfo(source).name;
       const shaderDescription = `${this.stage} shader ${shaderName}`;
-      import_core20.log.error(`GLSL compilation errors in ${shaderDescription}
+      import_core18.log.error(`GLSL compilation errors in ${shaderDescription}
 ${formattedLog}`)();
       throw new Error(`GLSL compilation errors in ${shaderName}`);
     }
   }
 };
 function getShaderIdFromProps(props) {
-  return getShaderInfo(props.source).name || props.id || (0, import_core20.uid)(`unnamed ${props.stage}-shader`);
+  return getShaderInfo(props.source).name || props.id || (0, import_core18.uid)(`unnamed ${props.stage}-shader`);
 }
 
 // src/adapter/resources/webgl-render-pass.ts
-var import_core21 = require("@luma.gl/core");
-var import_constants20 = require("@luma.gl/constants");
+var import_core19 = require("@luma.gl/core");
+var import_constants17 = require("@luma.gl/constants");
 var GL_DEPTH_BUFFER_BIT = 256;
 var GL_STENCIL_BUFFER_BIT = 1024;
 var GL_COLOR_BUFFER_BIT = 16384;
 var GL_COLOR = 6144;
-var WEBGLRenderPass = class extends import_core21.RenderPass {
+var WEBGLRenderPass = class extends import_core19.RenderPass {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -4729,7 +4250,7 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
       glParameters.depthMask = !this.props.depthReadOnly;
     }
     glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;
-    glParameters[import_constants20.GL.RASTERIZER_DISCARD] = this.props.discard;
+    glParameters[import_constants17.GL.RASTERIZER_DISCARD] = this.props.discard;
     if (parameters.viewport) {
       if (parameters.viewport.length >= 6) {
         glParameters.viewport = parameters.viewport.slice(0, 4);
@@ -4742,145 +4263,317 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
     if (parameters.scissorRect) {
       glParameters.scissor = parameters.scissorRect;
     }
-    if (parameters.blendConstant) {
-      glParameters.blendColor = parameters.blendConstant;
+    if (parameters.blendConstant) {
+      glParameters.blendColor = parameters.blendConstant;
+    }
+    if (parameters.stencilReference) {
+      console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
+      parameters[import_constants17.GL.STENCIL_REF] = parameters.stencilReference;
+    }
+    this.glParameters = glParameters;
+    setGLParameters(this.device, glParameters);
+  }
+  // Internal
+  /**
+   * Optionally clears depth, color and stencil buffers based on parameters
+   */
+  clear() {
+    const glParameters = __spreadValues({}, this.glParameters);
+    let clearMask = 0;
+    if (this.props.clearColor !== false) {
+      clearMask |= GL_COLOR_BUFFER_BIT;
+      glParameters.clearColor = this.props.clearColor;
+    }
+    if (this.props.clearDepth !== false) {
+      clearMask |= GL_DEPTH_BUFFER_BIT;
+      glParameters.clearDepth = this.props.clearDepth;
+    }
+    if (this.props.clearStencil !== false) {
+      clearMask |= GL_STENCIL_BUFFER_BIT;
+      glParameters.clearStencil = this.props.clearStencil;
+    }
+    if (clearMask !== 0) {
+      withGLParameters(this.device, glParameters, () => {
+        this.device.gl.clear(clearMask);
+      });
+    }
+  }
+  /** 
+   * WebGL2 - clear a specific color buffer 
+   */
+  clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
+    withGLParameters(this.device.gl2, { framebuffer: this.props.framebuffer }, () => {
+      switch (value.constructor) {
+        case Int32Array:
+          this.device.gl2.clearBufferiv(GL_COLOR, drawBuffer, value);
+          break;
+        case Uint32Array:
+          this.device.gl2.clearBufferuiv(GL_COLOR, drawBuffer, value);
+          break;
+        case Float32Array:
+        default:
+          this.device.gl2.clearBufferfv(GL_COLOR, drawBuffer, value);
+          break;
+      }
+    });
+  }
+  // clearDepthStencil() {
+  // const GL_DEPTH = 0x1801;
+  // const GL_STENCIL = 0x1802;
+  // const GL_DEPTH_STENCIL = 0x84f9;
+  //     case GL_DEPTH:
+  //       this.device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);
+  //       break;
+  //     case GL_STENCIL:
+  //       this.device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);
+  //       break;
+  //     case GL_DEPTH_STENCIL:
+  //       const [depth, stencil] = value;
+  //       this.device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
+  //       break;
+  //     default:
+  //       assert(false, ERR_ARGUMENTS);
+  //   }
+  // });
+};
+
+// src/adapter/resources/webgl-render-pipeline.ts
+var import_core21 = require("@luma.gl/core");
+var import_core22 = require("@luma.gl/core");
+var import_constants24 = require("@luma.gl/constants");
+
+// src/adapter/helpers/get-shader-layout.ts
+var import_constants21 = require("@luma.gl/constants");
+
+// src/classic/accessor.ts
+var import_core20 = require("@luma.gl/core");
+var import_constants19 = require("@luma.gl/constants");
+
+// src/classic/typed-array-utils.ts
+var import_constants18 = require("@luma.gl/constants");
+var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array";
+function getGLTypeFromTypedArray(arrayOrType) {
+  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+  switch (type) {
+    case Float32Array:
+      return import_constants18.GL.FLOAT;
+    case Uint16Array:
+      return import_constants18.GL.UNSIGNED_SHORT;
+    case Uint32Array:
+      return import_constants18.GL.UNSIGNED_INT;
+    case Uint8Array:
+      return import_constants18.GL.UNSIGNED_BYTE;
+    case Uint8ClampedArray:
+      return import_constants18.GL.UNSIGNED_BYTE;
+    case Int8Array:
+      return import_constants18.GL.BYTE;
+    case Int16Array:
+      return import_constants18.GL.SHORT;
+    case Int32Array:
+      return import_constants18.GL.INT;
+    default:
+      throw new Error(ERR_TYPE_DEDUCTION);
+  }
+}
+function getTypedArrayFromGLType(glType, options) {
+  const { clamped = true } = options || {};
+  switch (glType) {
+    case import_constants18.GL.FLOAT:
+      return Float32Array;
+    case import_constants18.GL.UNSIGNED_SHORT:
+    case import_constants18.GL.UNSIGNED_SHORT_5_6_5:
+    case import_constants18.GL.UNSIGNED_SHORT_4_4_4_4:
+    case import_constants18.GL.UNSIGNED_SHORT_5_5_5_1:
+      return Uint16Array;
+    case import_constants18.GL.UNSIGNED_INT:
+      return Uint32Array;
+    case import_constants18.GL.UNSIGNED_BYTE:
+      return clamped ? Uint8ClampedArray : Uint8Array;
+    case import_constants18.GL.BYTE:
+      return Int8Array;
+    case import_constants18.GL.SHORT:
+      return Int16Array;
+    case import_constants18.GL.INT:
+      return Int32Array;
+    default:
+      throw new Error("Failed to deduce typed array type from GL constant");
+  }
+}
+
+// src/classic/accessor.ts
+var DEFAULT_ACCESSOR_VALUES = {
+  offset: 0,
+  stride: 0,
+  type: import_constants19.GL.FLOAT,
+  size: 1,
+  divisor: 0,
+  normalized: false,
+  integer: false
+};
+var PROP_CHECKS = {
+  deprecatedProps: {
+    instanced: "divisor",
+    isInstanced: "divisor"
+  }
+};
+var Accessor = class {
+  static getBytesPerElement(accessor) {
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants19.GL.FLOAT);
+    return ArrayType.BYTES_PER_ELEMENT;
+  }
+  static getBytesPerVertex(accessor) {
+    (0, import_core20.assert)(accessor.size);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants19.GL.FLOAT);
+    return ArrayType.BYTES_PER_ELEMENT * accessor.size;
+  }
+  // Combines (merges) a list of accessors. On top of default values
+  // Usually [programAccessor, bufferAccessor, appAccessor]
+  // All props will be set in the returned object.
+  // TODO check for conflicts between values in the supplied accessors
+  static resolve(...accessors) {
+    return new Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]);
+  }
+  constructor(...accessors) {
+    accessors.forEach((accessor) => this._assign(accessor));
+    Object.freeze(this);
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  // ACCESSORS
+  // TODO - remove>
+  get BYTES_PER_ELEMENT() {
+    return Accessor.getBytesPerElement(this);
+  }
+  get BYTES_PER_VERTEX() {
+    return Accessor.getBytesPerVertex(this);
+  }
+  // PRIVATE
+  // eslint-disable-next-line complexity, max-statements
+  _assign(props = {}) {
+    props = (0, import_core20.checkProps)("Accessor", props, PROP_CHECKS);
+    if (props.type !== void 0) {
+      this.type = props.type;
+      if (props.type === import_constants19.GL.INT || props.type === import_constants19.GL.UNSIGNED_INT) {
+        this.integer = true;
+      }
+    }
+    if (props.size !== void 0) {
+      this.size = props.size;
+    }
+    if (props.offset !== void 0) {
+      this.offset = props.offset;
+    }
+    if (props.stride !== void 0) {
+      this.stride = props.stride;
     }
-    if (parameters.stencilReference) {
-      console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
-      parameters[import_constants20.GL.STENCIL_REF] = parameters.stencilReference;
+    if (props.normalize !== void 0) {
+      this.normalized = props.normalize;
     }
-    this.glParameters = glParameters;
-    setGLParameters(this.device, glParameters);
-  }
-  // Internal
-  /**
-   * Optionally clears depth, color and stencil buffers based on parameters
-   */
-  clear() {
-    const glParameters = __spreadValues({}, this.glParameters);
-    let clearMask = 0;
-    if (this.props.clearColor !== false) {
-      clearMask |= GL_COLOR_BUFFER_BIT;
-      glParameters.clearColor = this.props.clearColor;
+    if (props.normalized !== void 0) {
+      this.normalized = props.normalized;
     }
-    if (this.props.clearDepth !== false) {
-      clearMask |= GL_DEPTH_BUFFER_BIT;
-      glParameters.clearDepth = this.props.clearDepth;
+    if (props.integer !== void 0) {
+      this.integer = props.integer;
     }
-    if (this.props.clearStencil !== false) {
-      clearMask |= GL_STENCIL_BUFFER_BIT;
-      glParameters.clearStencil = this.props.clearStencil;
+    if (props.divisor !== void 0) {
+      this.divisor = props.divisor;
     }
-    if (clearMask !== 0) {
-      withGLParameters(this.device, glParameters, () => {
-        this.device.gl.clear(clearMask);
-      });
+    if (props.buffer !== void 0) {
+      this.buffer = props.buffer;
     }
-  }
-  /** 
-   * WebGL2 - clear a specific color buffer 
-   */
-  clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
-    withGLParameters(this.device.gl2, { framebuffer: this.props.framebuffer }, () => {
-      switch (value.constructor) {
-        case Int32Array:
-          this.device.gl2.clearBufferiv(GL_COLOR, drawBuffer, value);
-          break;
-        case Uint32Array:
-          this.device.gl2.clearBufferuiv(GL_COLOR, drawBuffer, value);
-          break;
-        case Float32Array:
-        default:
-          this.device.gl2.clearBufferfv(GL_COLOR, drawBuffer, value);
-          break;
+    if (props.index !== void 0) {
+      if (typeof props.index === "boolean") {
+        this.index = props.index ? 1 : 0;
+      } else {
+        this.index = props.index;
       }
-    });
+    }
+    if (props.instanced !== void 0) {
+      this.divisor = props.instanced ? 1 : 0;
+    }
+    if (props.isInstanced !== void 0) {
+      this.divisor = props.isInstanced ? 1 : 0;
+    }
+    if (this.offset === void 0)
+      delete this.offset;
+    if (this.stride === void 0)
+      delete this.stride;
+    if (this.type === void 0)
+      delete this.type;
+    if (this.size === void 0)
+      delete this.size;
+    if (this.divisor === void 0)
+      delete this.divisor;
+    if (this.normalized === void 0)
+      delete this.normalized;
+    if (this.integer === void 0)
+      delete this.integer;
+    if (this.buffer === void 0)
+      delete this.buffer;
+    if (this.index === void 0)
+      delete this.index;
+    return this;
   }
-  // clearDepthStencil() {
-  // const GL_DEPTH = 0x1801;
-  // const GL_STENCIL = 0x1802;
-  // const GL_DEPTH_STENCIL = 0x84f9;
-  //     case GL_DEPTH:
-  //       this.device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);
-  //       break;
-  //     case GL_STENCIL:
-  //       this.device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);
-  //       break;
-  //     case GL_DEPTH_STENCIL:
-  //       const [depth, stencil] = value;
-  //       this.device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
-  //       break;
-  //     default:
-  //       assert(false, ERR_ARGUMENTS);
-  //   }
-  // });
 };
 
-// src/adapter/resources/webgl-render-pipeline.ts
-var import_core22 = require("@luma.gl/core");
-var import_core23 = require("@luma.gl/core");
-var import_constants24 = require("@luma.gl/constants");
-
-// src/adapter/helpers/get-shader-layout.ts
-var import_constants22 = require("@luma.gl/constants");
-
 // src/adapter/helpers/decode-webgl-types.ts
-var import_constants21 = require("@luma.gl/constants");
+var import_constants20 = require("@luma.gl/constants");
 function isSamplerUniform(type) {
   return SAMPLER_TYPES.includes(type);
 }
 var SAMPLER_TYPES = [
-  import_constants21.GL.SAMPLER_2D,
-  import_constants21.GL.SAMPLER_CUBE,
-  import_constants21.GL.SAMPLER_3D,
-  import_constants21.GL.SAMPLER_2D_SHADOW,
-  import_constants21.GL.SAMPLER_2D_ARRAY,
-  import_constants21.GL.SAMPLER_2D_ARRAY_SHADOW,
-  import_constants21.GL.SAMPLER_CUBE_SHADOW,
-  import_constants21.GL.INT_SAMPLER_2D,
-  import_constants21.GL.INT_SAMPLER_3D,
-  import_constants21.GL.INT_SAMPLER_CUBE,
-  import_constants21.GL.INT_SAMPLER_2D_ARRAY,
-  import_constants21.GL.UNSIGNED_INT_SAMPLER_2D,
-  import_constants21.GL.UNSIGNED_INT_SAMPLER_3D,
-  import_constants21.GL.UNSIGNED_INT_SAMPLER_CUBE,
-  import_constants21.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
+  import_constants20.GL.SAMPLER_2D,
+  import_constants20.GL.SAMPLER_CUBE,
+  import_constants20.GL.SAMPLER_3D,
+  import_constants20.GL.SAMPLER_2D_SHADOW,
+  import_constants20.GL.SAMPLER_2D_ARRAY,
+  import_constants20.GL.SAMPLER_2D_ARRAY_SHADOW,
+  import_constants20.GL.SAMPLER_CUBE_SHADOW,
+  import_constants20.GL.INT_SAMPLER_2D,
+  import_constants20.GL.INT_SAMPLER_3D,
+  import_constants20.GL.INT_SAMPLER_CUBE,
+  import_constants20.GL.INT_SAMPLER_2D_ARRAY,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_2D,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_3D,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_CUBE,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
 ];
 var COMPOSITE_GL_TYPES = {
-  [import_constants21.GL.FLOAT]: [import_constants21.GL.FLOAT, 1, "float", "f32", "float32"],
-  [import_constants21.GL.FLOAT_VEC2]: [import_constants21.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
-  [import_constants21.GL.FLOAT_VEC3]: [import_constants21.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
-  [import_constants21.GL.FLOAT_VEC4]: [import_constants21.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
-  [import_constants21.GL.INT]: [import_constants21.GL.INT, 1, "int", "i32", "sint32"],
-  [import_constants21.GL.INT_VEC2]: [import_constants21.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
-  [import_constants21.GL.INT_VEC3]: [import_constants21.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
-  [import_constants21.GL.INT_VEC4]: [import_constants21.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
-  [import_constants21.GL.UNSIGNED_INT]: [import_constants21.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
-  [import_constants21.GL.UNSIGNED_INT_VEC2]: [import_constants21.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
-  [import_constants21.GL.UNSIGNED_INT_VEC3]: [import_constants21.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
-  [import_constants21.GL.UNSIGNED_INT_VEC4]: [import_constants21.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
-  [import_constants21.GL.BOOL]: [import_constants21.GL.FLOAT, 1, "bool", "f32", "float32"],
-  [import_constants21.GL.BOOL_VEC2]: [import_constants21.GL.FLOAT, 2, "bvec2", "vec2<f32>", "float32x2"],
-  [import_constants21.GL.BOOL_VEC3]: [import_constants21.GL.FLOAT, 3, "bvec3", "vec3<f32>", "float32x3"],
-  [import_constants21.GL.BOOL_VEC4]: [import_constants21.GL.FLOAT, 4, "bvec4", "vec4<f32>", "float32x4"],
+  [import_constants20.GL.FLOAT]: [import_constants20.GL.FLOAT, 1, "float", "f32", "float32"],
+  [import_constants20.GL.FLOAT_VEC2]: [import_constants20.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
+  [import_constants20.GL.FLOAT_VEC3]: [import_constants20.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
+  [import_constants20.GL.FLOAT_VEC4]: [import_constants20.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
+  [import_constants20.GL.INT]: [import_constants20.GL.INT, 1, "int", "i32", "sint32"],
+  [import_constants20.GL.INT_VEC2]: [import_constants20.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
+  [import_constants20.GL.INT_VEC3]: [import_constants20.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
+  [import_constants20.GL.INT_VEC4]: [import_constants20.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
+  [import_constants20.GL.UNSIGNED_INT]: [import_constants20.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
+  [import_constants20.GL.UNSIGNED_INT_VEC2]: [import_constants20.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
+  [import_constants20.GL.UNSIGNED_INT_VEC3]: [import_constants20.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
+  [import_constants20.GL.UNSIGNED_INT_VEC4]: [import_constants20.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
+  [import_constants20.GL.BOOL]: [import_constants20.GL.FLOAT, 1, "bool", "f32", "float32"],
+  [import_constants20.GL.BOOL_VEC2]: [import_constants20.GL.FLOAT, 2, "bvec2", "vec2<f32>", "float32x2"],
+  [import_constants20.GL.BOOL_VEC3]: [import_constants20.GL.FLOAT, 3, "bvec3", "vec3<f32>", "float32x3"],
+  [import_constants20.GL.BOOL_VEC4]: [import_constants20.GL.FLOAT, 4, "bvec4", "vec4<f32>", "float32x4"],
   // TODO - are sizes/components below correct?
-  [import_constants21.GL.FLOAT_MAT2]: [import_constants21.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
+  [import_constants20.GL.FLOAT_MAT2]: [import_constants20.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
   // 4
-  [import_constants21.GL.FLOAT_MAT2x3]: [import_constants21.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
+  [import_constants20.GL.FLOAT_MAT2x3]: [import_constants20.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
   // 6
-  [import_constants21.GL.FLOAT_MAT2x4]: [import_constants21.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
+  [import_constants20.GL.FLOAT_MAT2x4]: [import_constants20.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
   // 8
-  [import_constants21.GL.FLOAT_MAT3x2]: [import_constants21.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
+  [import_constants20.GL.FLOAT_MAT3x2]: [import_constants20.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
   // 6
-  [import_constants21.GL.FLOAT_MAT3]: [import_constants21.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
+  [import_constants20.GL.FLOAT_MAT3]: [import_constants20.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
   // 9
-  [import_constants21.GL.FLOAT_MAT3x4]: [import_constants21.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
+  [import_constants20.GL.FLOAT_MAT3x4]: [import_constants20.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
   // 12
-  [import_constants21.GL.FLOAT_MAT4x2]: [import_constants21.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
+  [import_constants20.GL.FLOAT_MAT4x2]: [import_constants20.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
   // 8
-  [import_constants21.GL.FLOAT_MAT4x3]: [import_constants21.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
+  [import_constants20.GL.FLOAT_MAT4x3]: [import_constants20.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
   // 12
-  [import_constants21.GL.FLOAT_MAT4]: [import_constants21.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
+  [import_constants20.GL.FLOAT_MAT4]: [import_constants20.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
   // 16
 };
 function decodeGLUniformType(glUniformType) {
@@ -4986,7 +4679,7 @@ function readVaryings(gl, program) {
   }
   const gl2 = gl;
   const varyings = [];
-  const count = gl.getProgramParameter(program, import_constants22.GL.TRANSFORM_FEEDBACK_VARYINGS);
+  const count = gl.getProgramParameter(program, import_constants21.GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
     const activeInfo = gl2.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
@@ -5003,7 +4696,7 @@ function readVaryings(gl, program) {
 }
 function readUniformBindings(gl, program) {
   const uniforms = [];
-  const uniformCount = gl.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORMS);
+  const uniformCount = gl.getProgramParameter(program, import_constants21.GL.ACTIVE_UNIFORMS);
   for (let i = 0; i < uniformCount; i++) {
     const activeInfo = gl.getActiveUniform(program, i);
     if (!activeInfo) {
@@ -5042,22 +4735,22 @@ function readUniformBlocks(gl, program) {
   const gl2 = gl;
   const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
   const uniformBlocks = [];
-  const blockCount = gl2.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl2.getProgramParameter(program, import_constants21.GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo = {
       name: gl2.getActiveUniformBlockName(program, blockIndex) || "",
-      location: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_BINDING),
-      byteLength: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_DATA_SIZE),
-      vertex: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-      fragment: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-      uniformCount: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      location: getBlockParameter(blockIndex, import_constants21.GL.UNIFORM_BLOCK_BINDING),
+      byteLength: getBlockParameter(blockIndex, import_constants21.GL.UNIFORM_BLOCK_DATA_SIZE),
+      vertex: getBlockParameter(blockIndex, import_constants21.GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
+      fragment: getBlockParameter(blockIndex, import_constants21.GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+      uniformCount: getBlockParameter(blockIndex, import_constants21.GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
       uniforms: []
     };
-    const uniformIndices = getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-    const uniformType = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_TYPE);
-    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_SIZE);
-    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_OFFSET);
-    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_ARRAY_STRIDE);
+    const uniformIndices = getBlockParameter(blockIndex, import_constants21.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
+    const uniformType = gl2.getActiveUniforms(program, uniformIndices, import_constants21.GL.UNIFORM_TYPE);
+    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, import_constants21.GL.UNIFORM_SIZE);
+    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, import_constants21.GL.UNIFORM_OFFSET);
+    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, import_constants21.GL.UNIFORM_ARRAY_STRIDE);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
       const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
@@ -5080,21 +4773,21 @@ function readUniformBlocks(gl, program) {
   return uniformBlocks;
 }
 var SAMPLER_UNIFORMS_GL_TO_GPU = {
-  [import_constants22.GL.SAMPLER_2D]: ["2d", "float"],
-  [import_constants22.GL.SAMPLER_CUBE]: ["cube", "float"],
-  [import_constants22.GL.SAMPLER_3D]: ["3d", "float"],
-  [import_constants22.GL.SAMPLER_2D_SHADOW]: ["3d", "depth"],
-  [import_constants22.GL.SAMPLER_2D_ARRAY]: ["2d-array", "float"],
-  [import_constants22.GL.SAMPLER_2D_ARRAY_SHADOW]: ["2d-array", "depth"],
-  [import_constants22.GL.SAMPLER_CUBE_SHADOW]: ["cube", "float"],
-  [import_constants22.GL.INT_SAMPLER_2D]: ["2d", "sint"],
-  [import_constants22.GL.INT_SAMPLER_3D]: ["3d", "sint"],
-  [import_constants22.GL.INT_SAMPLER_CUBE]: ["cube", "sint"],
-  [import_constants22.GL.INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"],
-  [import_constants22.GL.UNSIGNED_INT_SAMPLER_2D]: ["2d", "uint"],
-  [import_constants22.GL.UNSIGNED_INT_SAMPLER_3D]: ["3d", "uint"],
-  [import_constants22.GL.UNSIGNED_INT_SAMPLER_CUBE]: ["cube", "uint"],
-  [import_constants22.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"]
+  [import_constants21.GL.SAMPLER_2D]: ["2d", "float"],
+  [import_constants21.GL.SAMPLER_CUBE]: ["cube", "float"],
+  [import_constants21.GL.SAMPLER_3D]: ["3d", "float"],
+  [import_constants21.GL.SAMPLER_2D_SHADOW]: ["3d", "depth"],
+  [import_constants21.GL.SAMPLER_2D_ARRAY]: ["2d-array", "float"],
+  [import_constants21.GL.SAMPLER_2D_ARRAY_SHADOW]: ["2d-array", "depth"],
+  [import_constants21.GL.SAMPLER_CUBE_SHADOW]: ["cube", "float"],
+  [import_constants21.GL.INT_SAMPLER_2D]: ["2d", "sint"],
+  [import_constants21.GL.INT_SAMPLER_3D]: ["3d", "sint"],
+  [import_constants21.GL.INT_SAMPLER_CUBE]: ["cube", "sint"],
+  [import_constants21.GL.INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"],
+  [import_constants21.GL.UNSIGNED_INT_SAMPLER_2D]: ["2d", "uint"],
+  [import_constants21.GL.UNSIGNED_INT_SAMPLER_3D]: ["3d", "uint"],
+  [import_constants21.GL.UNSIGNED_INT_SAMPLER_CUBE]: ["cube", "uint"],
+  [import_constants21.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"]
 };
 function getSamplerInfo(type) {
   const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
@@ -5125,7 +4818,7 @@ function parseUniformName(name) {
 }
 
 // src/adapter/helpers/set-uniform.ts
-var import_constants23 = require("@luma.gl/constants");
+var import_constants22 = require("@luma.gl/constants");
 function setUniform(gl, location, type, value) {
   const gl2 = gl;
   let uniformValue = value;
@@ -5137,82 +4830,125 @@ function setUniform(gl, location, type, value) {
   }
   const arrayValue = typeof uniformValue === "number" ? [uniformValue] : uniformValue;
   switch (type) {
-    case import_constants23.GL.SAMPLER_2D:
-    case import_constants23.GL.SAMPLER_CUBE:
-    case import_constants23.GL.SAMPLER_3D:
-    case import_constants23.GL.SAMPLER_2D_SHADOW:
-    case import_constants23.GL.SAMPLER_2D_ARRAY:
-    case import_constants23.GL.SAMPLER_2D_ARRAY_SHADOW:
-    case import_constants23.GL.SAMPLER_CUBE_SHADOW:
-    case import_constants23.GL.INT_SAMPLER_2D:
-    case import_constants23.GL.INT_SAMPLER_3D:
-    case import_constants23.GL.INT_SAMPLER_CUBE:
-    case import_constants23.GL.INT_SAMPLER_2D_ARRAY:
-    case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D:
-    case import_constants23.GL.UNSIGNED_INT_SAMPLER_3D:
-    case import_constants23.GL.UNSIGNED_INT_SAMPLER_CUBE:
-    case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
+    case import_constants22.GL.SAMPLER_2D:
+    case import_constants22.GL.SAMPLER_CUBE:
+    case import_constants22.GL.SAMPLER_3D:
+    case import_constants22.GL.SAMPLER_2D_SHADOW:
+    case import_constants22.GL.SAMPLER_2D_ARRAY:
+    case import_constants22.GL.SAMPLER_2D_ARRAY_SHADOW:
+    case import_constants22.GL.SAMPLER_CUBE_SHADOW:
+    case import_constants22.GL.INT_SAMPLER_2D:
+    case import_constants22.GL.INT_SAMPLER_3D:
+    case import_constants22.GL.INT_SAMPLER_CUBE:
+    case import_constants22.GL.INT_SAMPLER_2D_ARRAY:
+    case import_constants22.GL.UNSIGNED_INT_SAMPLER_2D:
+    case import_constants22.GL.UNSIGNED_INT_SAMPLER_3D:
+    case import_constants22.GL.UNSIGNED_INT_SAMPLER_CUBE:
+    case import_constants22.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
       if (typeof value !== "number") {
         throw new Error("samplers must be set to integers");
       }
       return gl.uniform1i(location, value);
-    case import_constants23.GL.FLOAT:
+    case import_constants22.GL.FLOAT:
       return gl.uniform1fv(location, arrayValue);
-    case import_constants23.GL.FLOAT_VEC2:
+    case import_constants22.GL.FLOAT_VEC2:
       return gl.uniform2fv(location, arrayValue);
-    case import_constants23.GL.FLOAT_VEC3:
+    case import_constants22.GL.FLOAT_VEC3:
       return gl.uniform3fv(location, arrayValue);
-    case import_constants23.GL.FLOAT_VEC4:
+    case import_constants22.GL.FLOAT_VEC4:
       return gl.uniform4fv(location, arrayValue);
-    case import_constants23.GL.INT:
+    case import_constants22.GL.INT:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants23.GL.INT_VEC2:
+    case import_constants22.GL.INT_VEC2:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants23.GL.INT_VEC3:
+    case import_constants22.GL.INT_VEC3:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants23.GL.INT_VEC4:
+    case import_constants22.GL.INT_VEC4:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants23.GL.BOOL:
+    case import_constants22.GL.BOOL:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants23.GL.BOOL_VEC2:
+    case import_constants22.GL.BOOL_VEC2:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants23.GL.BOOL_VEC3:
+    case import_constants22.GL.BOOL_VEC3:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants23.GL.BOOL_VEC4:
+    case import_constants22.GL.BOOL_VEC4:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants23.GL.UNSIGNED_INT:
+    case import_constants22.GL.UNSIGNED_INT:
       return gl2.uniform1uiv(location, arrayValue, 1);
-    case import_constants23.GL.UNSIGNED_INT_VEC2:
+    case import_constants22.GL.UNSIGNED_INT_VEC2:
       return gl2.uniform2uiv(location, arrayValue, 2);
-    case import_constants23.GL.UNSIGNED_INT_VEC3:
+    case import_constants22.GL.UNSIGNED_INT_VEC3:
       return gl2.uniform3uiv(location, arrayValue, 3);
-    case import_constants23.GL.UNSIGNED_INT_VEC4:
+    case import_constants22.GL.UNSIGNED_INT_VEC4:
       return gl2.uniform4uiv(location, arrayValue, 4);
-    case import_constants23.GL.FLOAT_MAT2:
+    case import_constants22.GL.FLOAT_MAT2:
       return gl.uniformMatrix2fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT3:
+    case import_constants22.GL.FLOAT_MAT3:
       return gl.uniformMatrix3fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT4:
+    case import_constants22.GL.FLOAT_MAT4:
       return gl.uniformMatrix4fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT2x3:
+    case import_constants22.GL.FLOAT_MAT2x3:
       return gl2.uniformMatrix2x3fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT2x4:
+    case import_constants22.GL.FLOAT_MAT2x4:
       return gl2.uniformMatrix2x4fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT3x2:
+    case import_constants22.GL.FLOAT_MAT3x2:
       return gl2.uniformMatrix3x2fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT3x4:
+    case import_constants22.GL.FLOAT_MAT3x4:
       return gl2.uniformMatrix3x4fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT4x2:
+    case import_constants22.GL.FLOAT_MAT4x2:
       return gl2.uniformMatrix4x2fv(location, false, arrayValue);
-    case import_constants23.GL.FLOAT_MAT4x3:
+    case import_constants22.GL.FLOAT_MAT4x3:
       return gl2.uniformMatrix4x3fv(location, false, arrayValue);
   }
   throw new Error("Illegal uniform");
 }
 
+// src/adapter/helpers/webgl-topology-utils.ts
+var import_constants23 = require("@luma.gl/constants");
+function getGLDrawMode(topology) {
+  switch (topology) {
+    case "point-list":
+      return import_constants23.GL.POINTS;
+    case "line-list":
+      return import_constants23.GL.LINES;
+    case "line-strip":
+      return import_constants23.GL.LINE_STRIP;
+    case "line-loop-webgl":
+      return import_constants23.GL.LINE_LOOP;
+    case "triangle-list":
+      return import_constants23.GL.TRIANGLES;
+    case "triangle-strip":
+      return import_constants23.GL.TRIANGLE_STRIP;
+    case "triangle-fan-webgl":
+      return import_constants23.GL.TRIANGLE_FAN;
+    default:
+      throw new Error(topology);
+  }
+}
+function getGLPrimitive(topology) {
+  switch (topology) {
+    case "point-list":
+      return import_constants23.GL.POINTS;
+    case "line-list":
+      return import_constants23.GL.LINES;
+    case "line-strip":
+      return import_constants23.GL.LINES;
+    case "line-loop-webgl":
+      return import_constants23.GL.LINES;
+    case "triangle-list":
+      return import_constants23.GL.TRIANGLES;
+    case "triangle-strip":
+      return import_constants23.GL.TRIANGLES;
+    case "triangle-fan-webgl":
+      return import_constants23.GL.TRIANGLES;
+    default:
+      throw new Error(topology);
+  }
+}
+
 // src/adapter/resources/webgl-render-pipeline.ts
 var LOG_PROGRAM_PERF_PRIORITY = 4;
-var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
+var WEBGLRenderPipeline = class extends import_core21.RenderPipeline {
   // TODO are these used?
   constructor(device, props) {
     var _a;
@@ -5228,8 +4964,8 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
     this.device = device;
     this.handle = this.props.handle || this.device.gl.createProgram();
     this.device.setSpectorMetadata(this.handle, { id: this.props.id });
-    this.vs = (0, import_core22.cast)(props.vs);
-    this.fs = (0, import_core22.cast)(props.fs);
+    this.vs = (0, import_core21.cast)(props.vs);
+    this.fs = (0, import_core21.cast)(props.fs);
     const { varyings, bufferMode = import_constants24.GL.SEPARATE_ATTRIBS } = props;
     if (varyings && varyings.length > 0) {
       this.device.assertWebGL2();
@@ -5238,7 +4974,7 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
     }
     this._compileAndLink();
     this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-    this.shaderLayout = (0, import_core23.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
+    this.shaderLayout = (0, import_core22.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
   }
   destroy() {
     if (this.handle) {
@@ -5286,13 +5022,13 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
       const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name}Uniforms`);
       if (!binding) {
         const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
-        import_core22.log.warn(
+        import_core21.log.warn(
           `Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`
         )();
         continue;
       }
       if (!value) {
-        import_core22.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+        import_core21.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
       }
       switch (binding.type) {
         case "uniform":
@@ -5306,7 +5042,7 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
           }
           break;
         case "sampler":
-          import_core22.log.warn(`Ignoring sampler ${name}`)();
+          import_core21.log.warn(`Ignoring sampler ${name}`)();
           break;
         default:
           throw new Error(binding.type);
@@ -5315,9 +5051,9 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
     }
   }
   setUniforms(uniforms) {
-    const { bindings } = (0, import_core22.splitUniformsAndBindings)(uniforms);
+    const { bindings } = (0, import_core21.splitUniformsAndBindings)(uniforms);
     Object.keys(bindings).forEach((name) => {
-      import_core22.log.warn(
+      import_core21.log.warn(
         `Unsupported value "${bindings[name]}" used in setUniforms() for key ${name}. Use setBindings() instead?`
       )();
     });
@@ -5335,10 +5071,11 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
       vertexCount,
       // indexCount,
       instanceCount,
-      firstVertex = 0
+      firstVertex = 0,
       // firstIndex,
       // firstInstance,
-      // baseVertex
+      // baseVertex,
+      transformFeedback
     } = options;
     const glDrawMode = getGLDrawMode(this.props.topology);
     const isIndexed = Boolean(vertexArray.indexBuffer);
@@ -5349,10 +5086,8 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
     }
     this.device.gl.useProgram(this.handle);
     vertexArray.bindBeforeRender(renderPass);
-    const primitiveMode = getGLPrimitive(this.props.topology);
-    const transformFeedback = null;
     if (transformFeedback) {
-      transformFeedback.begin(primitiveMode);
+      transformFeedback.begin(this.props.topology);
     }
     this._applyBindings();
     this._applyUniforms();
@@ -5398,10 +5133,10 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
     const { gl } = this.device;
     gl.attachShader(this.handle, this.vs.handle);
     gl.attachShader(this.handle, this.fs.handle);
-    import_core22.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    import_core21.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
     gl.linkProgram(this.handle);
-    import_core22.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (!gl.debug && import_core22.log.level === 0) {
+    import_core21.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (!gl.debug && import_core21.log.level === 0) {
     }
     const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
     if (!linked) {
@@ -5496,7 +5231,7 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
           if (value instanceof WEBGLTexture) {
             texture = value;
           } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {
-            import_core22.log.warn(
+            import_core21.log.warn(
               "Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead"
             )();
             texture = value.colorAttachments[0];
@@ -5530,59 +5265,19 @@ var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
     }
   }
 };
-function getGLDrawMode(topology) {
-  switch (topology) {
-    case "point-list":
-      return import_constants24.GL.POINTS;
-    case "line-list":
-      return import_constants24.GL.LINES;
-    case "line-strip":
-      return import_constants24.GL.LINE_STRIP;
-    case "line-loop-webgl":
-      return import_constants24.GL.LINE_LOOP;
-    case "triangle-list":
-      return import_constants24.GL.TRIANGLES;
-    case "triangle-strip":
-      return import_constants24.GL.TRIANGLE_STRIP;
-    case "triangle-fan-webgl":
-      return import_constants24.GL.TRIANGLE_FAN;
-    default:
-      throw new Error(topology);
-  }
-}
-function getGLPrimitive(topology) {
-  switch (topology) {
-    case "point-list":
-      return import_constants24.GL.POINTS;
-    case "line-list":
-      return import_constants24.GL.LINES;
-    case "line-strip":
-      return import_constants24.GL.LINES;
-    case "line-loop-webgl":
-      return import_constants24.GL.LINES;
-    case "triangle-list":
-      return import_constants24.GL.TRIANGLES;
-    case "triangle-strip":
-      return import_constants24.GL.TRIANGLES;
-    case "triangle-fan-webgl":
-      return import_constants24.GL.TRIANGLES;
-    default:
-      throw new Error(topology);
-  }
-}
 
 // src/adapter/resources/webgl-command-encoder.ts
-var import_core25 = require("@luma.gl/core");
+var import_core24 = require("@luma.gl/core");
 
 // src/adapter/resources/webgl-command-buffer.ts
-var import_core24 = require("@luma.gl/core");
+var import_core23 = require("@luma.gl/core");
 var import_constants25 = require("@luma.gl/constants");
 function cast3(value) {
   return value;
 }
-var WEBGLCommandBuffer = class extends import_core24.CommandBuffer {
+var WEBGLCommandBuffer = class extends import_core23.CommandBuffer {
   constructor(device) {
-    super({});
+    super(device, {});
     this.commands = [];
     this.device = device;
   }
@@ -5663,7 +5358,7 @@ function _copyTextureToBuffer(device, options) {
   if (aspect !== "all") {
     throw new Error("not supported");
   }
-  if (mipLevel !== 0 || depthOrArrayLayers !== void 0 || bytesPerRow || rowsPerImage) {
+  if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
     throw new Error("not implemented");
   }
   const gl2 = device.assertWebGL2();
@@ -5672,8 +5367,9 @@ function _copyTextureToBuffer(device, options) {
     const webglBuffer = destination;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
-    const sourceFormat = import_constants25.GL.RGBA;
-    const sourceType = import_constants25.GL.UNSIGNED_BYTE;
+    const sourceParams = getWebGLTextureParameters(framebuffer.texture.format, true);
+    const sourceFormat = sourceParams.dataFormat;
+    const sourceType = sourceParams.type;
     gl2.bindBuffer(import_constants25.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
     gl2.bindFramebuffer(import_constants25.GL.FRAMEBUFFER, framebuffer.handle);
     gl2.readPixels(
@@ -5757,7 +5453,7 @@ function _copyTextureToTexture(device, options) {
   return texture;
 }
 function getFramebuffer(source) {
-  if (source instanceof import_core24.Texture) {
+  if (source instanceof import_core23.Texture) {
     const { width, height, id } = source;
     const framebuffer = source.device.createFramebuffer({
       id: `framebuffer-for-${id}`,
@@ -5771,7 +5467,7 @@ function getFramebuffer(source) {
 }
 
 // src/adapter/resources/webgl-command-encoder.ts
-var WEBGLCommandEncoder = class extends import_core25.CommandEncoder {
+var WEBGLCommandEncoder = class extends import_core24.CommandEncoder {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -5814,10 +5510,10 @@ var WEBGLCommandEncoder = class extends import_core25.CommandEncoder {
 };
 
 // src/adapter/resources/webgl-vertex-array.ts
-var import_core26 = require("@luma.gl/core");
+var import_core25 = require("@luma.gl/core");
 var import_constants26 = require("@luma.gl/constants");
 var import_env2 = require("@probe.gl/env");
-var WEBGLVertexArray = class extends import_core26.VertexArray {
+var WEBGLVertexArray = class extends import_core25.VertexArray {
   // Create a VertexArray
   constructor(device, props) {
     super(device, props);
@@ -5854,7 +5550,7 @@ var WEBGLVertexArray = class extends import_core26.VertexArray {
    */
   setIndexBuffer(indexBuffer) {
     const buffer = indexBuffer;
-    if (buffer && buffer.glTarget !== import_constants26.GL.ELEMENT_ARRAY_BUFFER) {
+    if ((buffer == null ? void 0 : buffer.glTarget) !== import_constants26.GL.ELEMENT_ARRAY_BUFFER) {
       throw new Error("Use .setBuffer()");
     }
     this.device.gl2.bindVertexArray(this.handle);
@@ -5980,14 +5676,18 @@ var WEBGLVertexArray = class extends import_core26.VertexArray {
     const constantValue = normalizeConstantArrayValue(value);
     const byteLength = constantValue.byteLength * elementCount;
     const length = constantValue.length * elementCount;
+    if (this.buffer && byteLength !== this.buffer.byteLength) {
+      throw new Error(
+        `Buffer size is immutable, byte length ${byteLength} !== ${this.buffer.byteLength}.`
+      );
+    }
     let updateNeeded = !this.buffer;
     this.buffer = this.buffer || this.device.createBuffer({ byteLength });
-    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
     updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
     if (updateNeeded) {
-      const typedArray = (0, import_core26.getScratchArray)(value.constructor, length);
-      (0, import_core26.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
-      this.buffer.subData(typedArray);
+      const typedArray = (0, import_core25.getScratchArray)(value.constructor, length);
+      (0, import_core25.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
+      this.buffer.write(typedArray);
       this.bufferValue = value;
     }
     return this.buffer;
@@ -6011,6 +5711,150 @@ function compareConstantArrayValues(v1, v2) {
   return true;
 }
 
+// src/adapter/resources/webgl-transform-feedback.ts
+var import_core26 = require("@luma.gl/core");
+var import_constants27 = require("@luma.gl/constants");
+var WEBGLTransformFeedback = class extends import_core26.TransformFeedback {
+  constructor(device, props) {
+    super(device, props);
+    this.buffers = {};
+    this.unusedBuffers = {};
+    /**
+     * Allows us to avoid a Chrome bug where a buffer that is already bound to a
+     * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+     * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
+     */
+    this.bindOnUse = true;
+    this._bound = false;
+    device.assertWebGL2();
+    this.device = device;
+    this.gl2 = device.gl2;
+    this.handle = this.props.handle || this.gl2.createTransformFeedback();
+    this.layout = this.props.layout;
+    if (props.buffers) {
+      this.setBuffers(props.buffers);
+    }
+    Object.seal(this);
+  }
+  destroy() {
+    this.gl2.deleteTransformFeedback(this.handle);
+    super.destroy();
+  }
+  begin(topology = "point-list") {
+    this.gl2.bindTransformFeedback(import_constants27.GL.TRANSFORM_FEEDBACK, this.handle);
+    if (this.bindOnUse) {
+      this._bindBuffers();
+    }
+    this.gl2.beginTransformFeedback(getGLPrimitive(topology));
+  }
+  end() {
+    this.gl2.endTransformFeedback();
+    if (!this.bindOnUse) {
+      this._unbindBuffers();
+    }
+    this.gl2.bindTransformFeedback(import_constants27.GL.TRANSFORM_FEEDBACK, null);
+  }
+  // SUBCLASS
+  setBuffers(buffers) {
+    this.buffers = {};
+    this.unusedBuffers = {};
+    this.bind(() => {
+      for (const bufferName in buffers) {
+        this.setBuffer(bufferName, buffers[bufferName]);
+      }
+    });
+  }
+  setBuffer(locationOrName, bufferOrRange) {
+    const location = this._getVaryingIndex(locationOrName);
+    const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
+    if (location < 0) {
+      this.unusedBuffers[locationOrName] = buffer;
+      import_core26.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+      return;
+    }
+    this.buffers[location] = { buffer, byteLength, byteOffset };
+    if (!this.bindOnUse) {
+      this._bindBuffer(location, buffer, byteOffset, byteLength);
+    }
+  }
+  getBuffer(locationOrName) {
+    if (isIndex(locationOrName)) {
+      return this.buffers[locationOrName] || null;
+    }
+    const location = this._getVaryingIndex(locationOrName);
+    return location >= 0 ? this.buffers[location] : null;
+  }
+  bind(funcOrHandle = this.handle) {
+    if (typeof funcOrHandle !== "function") {
+      this.gl2.bindTransformFeedback(import_constants27.GL.TRANSFORM_FEEDBACK, funcOrHandle);
+      return this;
+    }
+    let value;
+    if (!this._bound) {
+      this.gl2.bindTransformFeedback(import_constants27.GL.TRANSFORM_FEEDBACK, this.handle);
+      this._bound = true;
+      value = funcOrHandle();
+      this._bound = false;
+      this.gl2.bindTransformFeedback(import_constants27.GL.TRANSFORM_FEEDBACK, null);
+    } else {
+      value = funcOrHandle();
+    }
+    return value;
+  }
+  unbind() {
+    this.bind(null);
+  }
+  // PRIVATE METHODS
+  /** Extract offsets for bindBufferRange */
+  _getBufferRange(bufferOrRange) {
+    if (bufferOrRange instanceof WEBGLBuffer) {
+      return { buffer: bufferOrRange, byteOffset: 0, byteLength: bufferOrRange.byteLength };
+    }
+    const { buffer, byteOffset = 0, byteLength = bufferOrRange.buffer.byteLength } = bufferOrRange;
+    return { buffer, byteOffset, byteLength };
+  }
+  _getVaryingIndex(locationOrName) {
+    if (isIndex(locationOrName)) {
+      return Number(locationOrName);
+    }
+    for (const varying of this.layout.varyings) {
+      if (locationOrName === varying.name) {
+        return varying.location;
+      }
+    }
+    return -1;
+  }
+  /**
+   * Need to avoid chrome bug where buffer that is already bound to a different target
+   * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+   */
+  _bindBuffers() {
+    for (const bufferIndex in this.buffers) {
+      const { buffer, byteLength, byteOffset } = this._getBufferRange(this.buffers[bufferIndex]);
+      this._bindBuffer(Number(bufferIndex), buffer, byteOffset, byteLength);
+    }
+  }
+  _unbindBuffers() {
+    for (const bufferIndex in this.buffers) {
+      this.gl2.bindBufferBase(import_constants27.GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
+    }
+  }
+  _bindBuffer(index, buffer, byteOffset = 0, byteLength) {
+    const handle = buffer && buffer.handle;
+    if (!handle || byteLength === void 0) {
+      this.gl2.bindBufferBase(import_constants27.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);
+    } else {
+      this.gl2.bindBufferRange(import_constants27.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
+    }
+  }
+};
+function isIndex(value) {
+  if (typeof value === "number") {
+    return Number.isInteger(value);
+  }
+  return /^\d+$/.test(value);
+}
+
 // src/adapter/webgl-device.ts
 var LOG_LEVEL2 = 1;
 var _WebGLDevice = class extends import_core27.Device {
@@ -6171,7 +6015,7 @@ var _WebGLDevice = class extends import_core27.Device {
   }
   createBuffer(props) {
     const newProps = this._getBufferProps(props);
-    return new BufferWithAccessor(this, newProps);
+    return new WEBGLBuffer(this, newProps);
   }
   _createTexture(props) {
     return new WEBGLTexture(this, props);
@@ -6201,7 +6045,10 @@ var _WebGLDevice = class extends import_core27.Device {
     throw new Error("ComputePipeline not supported in WebGL");
   }
   beginComputePass(props) {
-    throw new Error("compute shaders not supported in WebGL");
+    throw new Error("ComputePass not supported in WebGL");
+  }
+  createTransformFeedback(props) {
+    return new WEBGLTransformFeedback(this, props);
   }
   getDefaultRenderPass() {
     this.renderPass = this.renderPass || this.beginRenderPass({
@@ -6403,25 +6250,25 @@ function clear(gl, options) {
 
 // src/classic/copy-and-blit.ts
 var import_core30 = require("@luma.gl/core");
-var import_constants28 = require("@luma.gl/constants");
+var import_constants29 = require("@luma.gl/constants");
 
 // src/classic/format-utils.ts
 var import_core29 = require("@luma.gl/core");
-var import_constants27 = require("@luma.gl/constants");
+var import_constants28 = require("@luma.gl/constants");
 function glFormatToComponents(format) {
   switch (format) {
-    case import_constants27.GL.ALPHA:
-    case import_constants27.GL.R32F:
-    case import_constants27.GL.RED:
+    case import_constants28.GL.ALPHA:
+    case import_constants28.GL.R32F:
+    case import_constants28.GL.RED:
       return 1;
-    case import_constants27.GL.RG32F:
-    case import_constants27.GL.RG:
+    case import_constants28.GL.RG32F:
+    case import_constants28.GL.RG:
       return 2;
-    case import_constants27.GL.RGB:
-    case import_constants27.GL.RGB32F:
+    case import_constants28.GL.RGB:
+    case import_constants28.GL.RGB32F:
       return 3;
-    case import_constants27.GL.RGBA:
-    case import_constants27.GL.RGBA32F:
+    case import_constants28.GL.RGBA:
+    case import_constants28.GL.RGBA32F:
       return 4;
     default:
       (0, import_core29.assert)(false);
@@ -6430,13 +6277,13 @@ function glFormatToComponents(format) {
 }
 function glTypeToBytes(type) {
   switch (type) {
-    case import_constants27.GL.UNSIGNED_BYTE:
+    case import_constants28.GL.UNSIGNED_BYTE:
       return 1;
-    case import_constants27.GL.UNSIGNED_SHORT_5_6_5:
-    case import_constants27.GL.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants27.GL.UNSIGNED_SHORT_5_5_5_1:
+    case import_constants28.GL.UNSIGNED_SHORT_5_6_5:
+    case import_constants28.GL.UNSIGNED_SHORT_4_4_4_4:
+    case import_constants28.GL.UNSIGNED_SHORT_5_5_5_1:
       return 2;
-    case import_constants27.GL.FLOAT:
+    case import_constants28.GL.FLOAT:
       return 4;
     default:
       (0, import_core29.assert)(false);
@@ -6450,8 +6297,8 @@ function readPixelsToArray(source, options) {
   const {
     sourceX = 0,
     sourceY = 0,
-    sourceFormat = import_constants28.GL.RGBA,
-    sourceAttachment = import_constants28.GL.COLOR_ATTACHMENT0
+    sourceFormat = import_constants29.GL.RGBA,
+    sourceAttachment = import_constants29.GL.COLOR_ATTACHMENT0
     // TODO - support gl.readBuffer
   } = options || {};
   let {
@@ -6466,47 +6313,43 @@ function readPixelsToArray(source, options) {
   const { gl, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
-  const attachment = sourceAttachment - import_constants28.GL.COLOR_ATTACHMENT0;
-  sourceType = sourceType || ((_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.type) || import_constants28.GL.UNSIGNED_BYTE;
+  const attachment = sourceAttachment - import_constants29.GL.COLOR_ATTACHMENT0;
+  sourceType = sourceType || ((_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.type) || import_constants29.GL.UNSIGNED_BYTE;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
-  const prevHandle = gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  const prevHandle = gl.bindFramebuffer(import_constants29.GL.FRAMEBUFFER, handle);
   gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle || null);
+  gl.bindFramebuffer(import_constants29.GL.FRAMEBUFFER, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
   return target;
 }
 function readPixelsToBuffer(source, options) {
-  const { sourceX = 0, sourceY = 0, sourceFormat = import_constants28.GL.RGBA, targetByteOffset = 0 } = options || {};
+  const { sourceX = 0, sourceY = 0, sourceFormat = import_constants29.GL.RGBA, targetByteOffset = 0 } = options || {};
   let { target, sourceWidth, sourceHeight, sourceType } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
   (0, import_core30.assert)(framebuffer);
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   const webglFramebuffer = framebuffer;
-  const gl2 = webglFramebuffer.device.assertWebGL2();
-  sourceType = sourceType || (target ? target.type : import_constants28.GL.UNSIGNED_BYTE);
+  sourceType = sourceType || import_constants29.GL.UNSIGNED_BYTE;
   if (!target) {
     const components = glFormatToComponents(sourceFormat);
     const byteCount = glTypeToBytes(sourceType);
     const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
-    target = new BufferWithAccessor(gl2, { byteLength, accessor: { type: sourceType, size: components } });
+    target = webglFramebuffer.device.createBuffer({ byteLength });
   }
-  target.bind({ glTarget: import_constants28.GL.PIXEL_PACK_BUFFER });
-  withGLParameters(gl2, { framebuffer }, () => {
-    gl2.readPixels(
-      sourceX,
-      sourceY,
-      sourceWidth,
-      sourceHeight,
-      sourceFormat,
-      sourceType,
-      targetByteOffset
-    );
+  const commandEncoder = source.device.createCommandEncoder();
+  commandEncoder.copyTextureToBuffer({
+    source,
+    width: sourceWidth,
+    height: sourceHeight,
+    origin: [sourceX, sourceY],
+    destination: target,
+    byteOffset: targetByteOffset
   });
-  target.unbind({ glTarget: import_constants28.GL.PIXEL_PACK_BUFFER });
+  commandEncoder.destroy();
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
@@ -6518,7 +6361,7 @@ function copyToTexture(source, target, options) {
     sourceY = 0,
     // attachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer
     targetMipmaplevel = 0,
-    targetInternalFormat = import_constants28.GL.RGBA
+    targetInternalFormat = import_constants29.GL.RGBA
   } = options || {};
   let {
     targetX,
@@ -6537,7 +6380,7 @@ function copyToTexture(source, target, options) {
   targetX = targetX || 0;
   targetY = targetY || 0;
   targetZ = targetZ || 0;
-  const prevHandle = device.gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  const prevHandle = device.gl.bindFramebuffer(import_constants29.GL.FRAMEBUFFER, handle);
   (0, import_core30.assert)(target);
   let texture = null;
   let textureTarget;
@@ -6564,8 +6407,8 @@ function copyToTexture(source, target, options) {
     );
   } else {
     switch (textureTarget) {
-      case import_constants28.GL.TEXTURE_2D:
-      case import_constants28.GL.TEXTURE_CUBE_MAP:
+      case import_constants29.GL.TEXTURE_2D:
+      case import_constants29.GL.TEXTURE_CUBE_MAP:
         device.gl.copyTexSubImage2D(
           textureTarget,
           targetMipmaplevel,
@@ -6577,8 +6420,8 @@ function copyToTexture(source, target, options) {
           height
         );
         break;
-      case import_constants28.GL.TEXTURE_2D_ARRAY:
-      case import_constants28.GL.TEXTURE_3D:
+      case import_constants29.GL.TEXTURE_2D_ARRAY:
+      case import_constants29.GL.TEXTURE_3D:
         device.assertWebGL2();
         device.gl2.copyTexSubImage3D(
           textureTarget,
@@ -6598,7 +6441,7 @@ function copyToTexture(source, target, options) {
   if (texture) {
     texture.unbind();
   }
-  device.gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle || null);
+  device.gl.bindFramebuffer(import_constants29.GL.FRAMEBUFFER, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
@@ -6624,7 +6467,7 @@ function getPixelArray(pixelArray, type, format, width, height) {
   if (pixelArray) {
     return pixelArray;
   }
-  type = type || import_constants28.GL.UNSIGNED_BYTE;
+  type = type || import_constants29.GL.UNSIGNED_BYTE;
   const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
   const components = glFormatToComponents(format);
   return new ArrayType(width * height * components);