@luma.gl/webgl 9.0.11 → 9.1.0-alpha.2

package/dist/index.cjs

@@ -30,7 +30,6 @@ __export(dist_exports, {
   WEBGLFramebuffer: () => WEBGLFramebuffer,
   WEBGLRenderPass: () => WEBGLRenderPass,
   WEBGLRenderPipeline: () => WEBGLRenderPipeline,
-  WEBGLResource: () => WebGLResource,
   WEBGLSampler: () => WEBGLSampler,
   WEBGLShader: () => WEBGLShader,
   WEBGLTexture: () => WEBGLTexture,
@@ -38,10 +37,7 @@ __export(dist_exports, {
   WEBGLVertexArray: () => WEBGLVertexArray,
   WebGLCanvasContext: () => WebGLCanvasContext,
   WebGLDevice: () => WebGLDevice,
-  WebGLResource: () => WebGLResource,
   _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
-  _WEBGLRenderbuffer: () => WEBGLRenderbuffer,
-  convertGLToTextureFormat: () => convertGLToTextureFormat,
   getGLParameters: () => getGLParameters,
   getShaderLayout: () => getShaderLayout,
   popContextState: () => popContextState,
@@ -56,10 +52,7 @@ __export(dist_exports, {
 module.exports = __toCommonJS(dist_exports);
 
 // dist/adapter/webgl-device.js
-var import_core27 = require("@luma.gl/core");
-
-// dist/context/state-tracker/track-context-state.js
-var import_core = require("@luma.gl/core");
+var import_core22 = require("@luma.gl/core");
 
 // dist/context/parameters/webgl-parameter-tables.js
 var import_constants = require("@luma.gl/constants");
@@ -295,7 +288,7 @@ var GL_PARAMETER_SETTERS = {
   lineWidth: (gl, value) => gl.lineWidth(value),
   polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823),
   polygonOffset: (gl, value) => gl.polygonOffset(...value),
-  sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
+  sampleCoverage: (gl, value) => gl.sampleCoverage(value[0], value[1] || false),
   scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089),
   scissor: (gl, value) => gl.scissor(...value),
   stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960),
@@ -626,7 +619,6 @@ var GLState = class {
     this.stateStack.push({});
   }
   pop() {
-    (0, import_core.assert)(this.stateStack.length > 0);
     const oldValues = this.stateStack[this.stateStack.length - 1];
     setGLParameters(this.gl, oldValues);
     this.stateStack.pop();
@@ -642,7 +634,6 @@ var GLState = class {
     let oldValue;
     const oldValues = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
     for (const key in values) {
-      (0, import_core.assert)(key !== void 0);
       const value = values[key];
       const cached = this.cache[key];
       if (!deepArrayEqual(value, cached)) {
@@ -661,8 +652,7 @@ function getContextState(gl) {
   return gl.state;
 }
 function trackContextState(gl, options) {
-  const { enable: enable2 = true, copyState } = options;
-  (0, import_core.assert)(copyState !== void 0);
+  const { enable: enable2 = true, copyState } = options || {};
   if (!gl.state) {
     gl.state = new GLState(gl, { copyState });
     installProgramSpy(gl);
@@ -687,7 +677,6 @@ function pushContextState(gl) {
 }
 function popContextState(gl) {
   const glState = getContextState(gl);
-  (0, import_core.assert)(glState);
   glState.pop();
 }
 function installGetterOverride(gl, functionName) {
@@ -857,10 +846,10 @@ function identifyGPUType(vendor, renderer) {
 }
 
 // dist/adapter/device-helpers/webgl-device-features.js
-var import_core3 = require("@luma.gl/core");
+var import_core2 = require("@luma.gl/core");
 
 // dist/adapter/converters/texture-formats.js
-var import_core2 = require("@luma.gl/core");
+var import_core = require("@luma.gl/core");
 var import_constants4 = require("@luma.gl/constants");
 
 // dist/adapter/converters/vertex-formats.js
@@ -1005,7 +994,6 @@ var TEXTURE_FORMATS = {
   "bgra8unorm-srgb": { b: 4, c: 4 },
   "rg16uint": { gl: 33338, b: 4, c: 1, bpp: 4 },
   "rg16sint": { gl: 33337, b: 4, c: 2, bpp: 4 },
-  // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
   "rg16float": { gl: 33327, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true },
   "rg16unorm-webgl": { gl: 33324, b: 2, c: 2, render: norm16_renderable },
   "rg16snorm-webgl": { gl: 36761, b: 2, c: 2, render: snorm16_renderable },
@@ -1179,31 +1167,6 @@ var TEXTURE_FORMATS = {
   "atc-rgba-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl },
   "atc-rgbai-unorm-webgl": { gl: 34798, f: texture_compression_atc_webgl }
 };
-var DATA_FORMAT_CHANNELS = {
-  [6403]: 1,
-  [36244]: 1,
-  [33319]: 2,
-  [33320]: 2,
-  [6407]: 3,
-  [36248]: 3,
-  [6408]: 4,
-  [36249]: 4,
-  [6402]: 1,
-  [34041]: 1,
-  [6406]: 1,
-  [6409]: 1,
-  [6410]: 2
-};
-var TYPE_SIZES = {
-  [5126]: 4,
-  [5125]: 4,
-  [5124]: 4,
-  [5123]: 2,
-  [5122]: 2,
-  [5131]: 2,
-  [5120]: 1,
-  [5121]: 1
-};
 function isTextureFormatSupported(gl, format, extensions) {
   const info = TEXTURE_FORMATS[format];
   if (!info) {
@@ -1218,28 +1181,6 @@ function isTextureFormatSupported(gl, format, extensions) {
   }
   return true;
 }
-function isRenderbufferFormatSupported(gl, format, extensions) {
-  var _a;
-  return isTextureFormatSupported(gl, format, extensions) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.rb);
-}
-function convertGLToTextureFormat(format) {
-  if (typeof format === "string") {
-    return format;
-  }
-  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry2]) => entry2.gl === format);
-  if (!entry) {
-    throw new Error(`Unknown texture format ${format}`);
-  }
-  return entry[0];
-}
-function convertTextureFormatToGL(format) {
-  const formatInfo = TEXTURE_FORMATS[format];
-  const webglFormat = formatInfo == null ? void 0 : formatInfo.gl;
-  if (webglFormat === void 0) {
-    throw new Error(`Unsupported texture format ${format}`);
-  }
-  return webglFormat;
-}
 function isTextureFormatFilterable(gl, format, extensions) {
   if (!isTextureFormatSupported(gl, format, extensions)) {
     return false;
@@ -1248,7 +1189,7 @@ function isTextureFormatFilterable(gl, format, extensions) {
     return false;
   }
   try {
-    const decoded = (0, import_core2.decodeTextureFormat)(format);
+    const decoded = (0, import_core.decodeTextureFormat)(format);
     if (decoded.signed) {
       return false;
     }
@@ -1272,14 +1213,14 @@ function isTextureFormatRenderable(gl, format, extensions) {
   }
   return true;
 }
-function getWebGLTextureParameters(format) {
+function getTextureFormatWebGL(format) {
   var _a;
   const formatData = TEXTURE_FORMATS[format];
   const webglFormat = convertTextureFormatToGL(format);
-  const decoded = (0, import_core2.decodeTextureFormat)(format);
+  const decoded = (0, import_core.decodeTextureFormat)(format);
   return {
-    format: webglFormat,
-    dataFormat: (formatData == null ? void 0 : formatData.dataFormat) || getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
+    internalFormat: webglFormat,
+    format: (formatData == null ? void 0 : formatData.dataFormat) || getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
     // depth formats don't have a type
     type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : ((_a = formatData == null ? void 0 : formatData.types) == null ? void 0 : _a[0]) || 5121,
     // @ts-expect-error
@@ -1293,12 +1234,6 @@ function getDepthStencilAttachmentWebGL(format) {
   }
   return info.attachment;
 }
-function getTextureFormatBytesPerPixel(format) {
-  const params = getWebGLTextureParameters(format);
-  const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
-  const channelSize = TYPE_SIZES[params.type] || 1;
-  return channels * channelSize;
-}
 function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
   if (format === 6408 || format === 6407) {
     return format;
@@ -1316,6 +1251,14 @@ function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
       return 6408;
   }
 }
+function convertTextureFormatToGL(format) {
+  const formatInfo = TEXTURE_FORMATS[format];
+  const webglFormat = formatInfo == null ? void 0 : formatInfo.gl;
+  if (webglFormat === void 0) {
+    throw new Error(`Unsupported texture format ${format}`);
+  }
+  return webglFormat;
+}
 
 // dist/adapter/device-helpers/webgl-device-features.js
 var WEBGL_FEATURES = {
@@ -1337,7 +1280,7 @@ var WEBGL_FEATURES = {
   "shader-conservative-depth-webgl": "EXT_conservative_depth"
   // Textures are handled by getTextureFeatures()
 };
-var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
+var WebGLDeviceFeatures = class extends import_core2.DeviceFeatures {
   gl;
   extensions;
   testedFeatures = /* @__PURE__ */ new Set();
@@ -1357,7 +1300,8 @@ var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
     return [];
   }
   has(feature) {
-    if (this.disabledFeatures[feature]) {
+    var _a;
+    if ((_a = this.disabledFeatures) == null ? void 0 : _a[feature]) {
       return false;
     }
     if (!this.testedFeatures.has(feature)) {
@@ -1391,9 +1335,9 @@ var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
 };
 
 // dist/adapter/device-helpers/webgl-device-limits.js
-var import_core4 = require("@luma.gl/core");
+var import_core3 = require("@luma.gl/core");
 var import_constants5 = require("@luma.gl/constants");
-var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
+var WebGLDeviceLimits = class extends import_core3.DeviceLimits {
   get maxTextureDimension1D() {
     return 0;
   }
@@ -1497,19 +1441,19 @@ var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
     if (this.limits[parameter] === void 0) {
       this.limits[parameter] = this.gl.getParameter(parameter);
     }
-    return this.limits[parameter];
+    return this.limits[parameter] || 0;
   }
 };
 
 // dist/adapter/webgl-canvas-context.js
-var import_core11 = require("@luma.gl/core");
+var import_core9 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgl-framebuffer.js
-var import_core10 = require("@luma.gl/core");
+var import_core8 = require("@luma.gl/core");
 var import_constants11 = require("@luma.gl/constants");
 
 // dist/adapter/resources/webgl-texture.js
-var import_core9 = require("@luma.gl/core");
+var import_core7 = require("@luma.gl/core");
 var import_constants10 = require("@luma.gl/constants");
 
 // dist/context/state-tracker/with-parameters.js
@@ -1544,10 +1488,10 @@ function isObjectEmpty2(object) {
 var import_constants7 = require("@luma.gl/constants");
 
 // dist/adapter/converters/device-parameters.js
-var import_core5 = require("@luma.gl/core");
+var import_core4 = require("@luma.gl/core");
 var import_constants6 = require("@luma.gl/constants");
 function withDeviceAndGLParameters(device, parameters, glParameters, func) {
-  if ((0, import_core5.isObjectEmpty)(parameters)) {
+  if (isObjectEmpty3(parameters)) {
     return func(device);
   }
   const webglDevice = device;
@@ -1561,7 +1505,7 @@ function withDeviceAndGLParameters(device, parameters, glParameters, func) {
   }
 }
 function withDeviceParameters(device, parameters, func) {
-  if ((0, import_core5.isObjectEmpty)(parameters)) {
+  if (isObjectEmpty3(parameters)) {
     return func(device);
   }
   pushContextState(device.gl);
@@ -1672,7 +1616,7 @@ function setDeviceParameters(device, parameters) {
     gl.stencilMaskSeparate(1029, mask);
   }
   if (parameters.stencilReadMask) {
-    import_core5.log.warn("stencilReadMask not supported under WebGL");
+    import_core4.log.warn("stencilReadMask not supported under WebGL");
   }
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
@@ -1764,6 +1708,14 @@ function map(parameter, value, valueMap) {
 function mapBoolean(parameter, value) {
   return value;
 }
+function isObjectEmpty3(obj) {
+  let isEmpty = true;
+  for (const key in obj) {
+    isEmpty = false;
+    break;
+  }
+  return isEmpty;
+}
 
 // dist/adapter/converters/sampler-parameters.js
 function convertSamplerParametersToWebGL(props) {
@@ -1830,136 +1782,10 @@ function convertMinFilterMode(minFilter, mipmapFilter) {
   }
 }
 
-// dist/adapter/resources/webgl-buffer.js
-var import_core6 = require("@luma.gl/core");
-var import_constants8 = require("@luma.gl/constants");
-var WEBGLBuffer = class extends import_core6.Buffer {
-  device;
-  gl;
-  handle;
-  /** Target in OpenGL defines the type of buffer */
-  glTarget;
-  /** Usage is a hint on how frequently the buffer will be updates */
-  glUsage;
-  /** Index type is needed when issuing draw calls, so we pre-compute it */
-  glIndexType = 5123;
-  /** Number of bytes allocated on the GPU for this buffer */
-  byteLength;
-  /** Number of bytes used */
-  bytesUsed;
-  constructor(device, props = {}) {
-    super(device, props);
-    this.device = device;
-    this.gl = this.device.gl;
-    const handle = typeof props === "object" ? props.handle : void 0;
-    this.handle = handle || this.gl.createBuffer();
-    device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
-    this.glTarget = getWebGLTarget(this.props.usage);
-    this.glUsage = getWebGLUsage(this.props.usage);
-    this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123;
-    if (props.data) {
-      this._initWithData(props.data, props.byteOffset, props.byteLength);
-    } else {
-      this._initWithByteLength(props.byteLength || 0);
-    }
-  }
-  // PRIVATE METHODS
-  /** Allocate a new buffer and initialize to contents of typed array */
-  _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
-    const glTarget = this.glTarget;
-    this.gl.bindBuffer(glTarget, this.handle);
-    this.gl.bufferData(glTarget, byteLength, this.glUsage);
-    this.gl.bufferSubData(glTarget, byteOffset, data);
-    this.gl.bindBuffer(glTarget, null);
-    this.bytesUsed = byteLength;
-    this.byteLength = byteLength;
-    this._setDebugData(data, byteOffset, byteLength);
-    this.trackAllocatedMemory(byteLength);
-  }
-  // Allocate a GPU buffer of specified size.
-  _initWithByteLength(byteLength) {
-    (0, import_core6.assert)(byteLength >= 0);
-    let data = byteLength;
-    if (byteLength === 0) {
-      data = new Float32Array(0);
-    }
-    const glTarget = this.glTarget;
-    this.gl.bindBuffer(glTarget, this.handle);
-    this.gl.bufferData(glTarget, data, this.glUsage);
-    this.gl.bindBuffer(glTarget, null);
-    this.bytesUsed = byteLength;
-    this.byteLength = byteLength;
-    this._setDebugData(null, 0, byteLength);
-    this.trackAllocatedMemory(byteLength);
-    return this;
-  }
-  destroy() {
-    if (!this.destroyed && this.handle) {
-      this.removeStats();
-      this.trackDeallocatedMemory();
-      this.gl.deleteBuffer(this.handle);
-      this.destroyed = true;
-      this.handle = null;
-    }
-  }
-  write(data, byteOffset = 0) {
-    const srcOffset = 0;
-    const byteLength = void 0;
-    const glTarget = 36663;
-    this.gl.bindBuffer(glTarget, this.handle);
-    if (srcOffset !== 0 || byteLength !== void 0) {
-      this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
-    } else {
-      this.gl.bufferSubData(glTarget, byteOffset, data);
-    }
-    this.gl.bindBuffer(glTarget, null);
-    this._setDebugData(data, byteOffset, data.byteLength);
-  }
-  /** Asynchronously read data from the buffer */
-  async readAsync(byteOffset = 0, byteLength) {
-    return this.readSyncWebGL(byteOffset, byteLength);
-  }
-  /** Synchronously read data from the buffer. WebGL only. */
-  readSyncWebGL(byteOffset = 0, byteLength) {
-    byteLength = byteLength ?? this.byteLength - byteOffset;
-    const data = new Uint8Array(byteLength);
-    const dstOffset = 0;
-    this.gl.bindBuffer(36662, this.handle);
-    this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength);
-    this.gl.bindBuffer(36662, null);
-    this._setDebugData(data, byteOffset, byteLength);
-    return data;
-  }
-};
-function getWebGLTarget(usage) {
-  if (usage & import_core6.Buffer.INDEX) {
-    return 34963;
-  }
-  if (usage & import_core6.Buffer.VERTEX) {
-    return 34962;
-  }
-  if (usage & import_core6.Buffer.UNIFORM) {
-    return 35345;
-  }
-  return 34962;
-}
-function getWebGLUsage(usage) {
-  if (usage & import_core6.Buffer.INDEX) {
-    return 35044;
-  }
-  if (usage & import_core6.Buffer.VERTEX) {
-    return 35044;
-  }
-  if (usage & import_core6.Buffer.UNIFORM) {
-    return 35048;
-  }
-  return 35044;
-}
-
 // dist/adapter/resources/webgl-sampler.js
-var import_core7 = require("@luma.gl/core");
-var import_constants9 = require("@luma.gl/constants");
-var WEBGLSampler = class extends import_core7.Sampler {
+var import_core5 = require("@luma.gl/core");
+var import_constants8 = require("@luma.gl/constants");
+var WEBGLSampler = class extends import_core5.Sampler {
   device;
   handle;
   parameters;
@@ -1997,14 +1823,15 @@ var WEBGLSampler = class extends import_core7.Sampler {
 };
 
 // dist/adapter/resources/webgl-texture-view.js
-var import_core8 = require("@luma.gl/core");
-var WEBGLTextureView = class extends import_core8.TextureView {
+var import_core6 = require("@luma.gl/core");
+var WEBGLTextureView = class extends import_core6.TextureView {
   device;
   gl;
   handle;
+  // Does not have a WebGL representation
   texture;
   constructor(device, props) {
-    super(device, { ...import_core8.Texture.defaultProps, ...props });
+    super(device, { ...import_core6.Texture.defaultProps, ...props });
     this.device = device;
     this.gl = this.device.gl;
     this.handle = null;
@@ -2012,164 +1839,253 @@ var WEBGLTextureView = class extends import_core8.TextureView {
   }
 };
 
+// dist/adapter/helpers/webgl-texture-utils.js
+var import_constants9 = require("@luma.gl/constants");
+function initializeTextureStorage(gl, levels, options) {
+  const { dimension, width, height, depth = 0 } = options;
+  const { glInternalFormat } = options;
+  const glTarget = options.glTarget;
+  switch (dimension) {
+    case "2d-array":
+    case "3d":
+      gl.texStorage3D(glTarget, levels, glInternalFormat, width, height, depth);
+      break;
+    default:
+      gl.texStorage2D(glTarget, levels, glInternalFormat, width, height);
+  }
+}
+function copyCPUImageToMipLevel(gl, image, options) {
+  const { dimension, width, height, depth = 0, level = 0 } = options;
+  const { x = 0, y = 0, z = 0 } = options;
+  const { glFormat, glType } = options;
+  const glTarget = getCubeTargetWebGL(options.glTarget, dimension, depth);
+  switch (dimension) {
+    case "2d-array":
+    case "3d":
+      gl.texSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, glType, image);
+      break;
+    case "2d":
+    case "cube":
+      gl.texSubImage2D(glTarget, level, x, y, width, height, glFormat, glType, image);
+      break;
+    default:
+      throw new Error(dimension);
+  }
+}
+function copyCPUDataToMipLevel(gl, typedArray, options) {
+  const { dimension, width, height, depth = 0, level = 0, byteOffset = 0 } = options;
+  const { x = 0, y = 0, z = 0 } = options;
+  const { glFormat, glType, compressed } = options;
+  const glTarget = getCubeTargetWebGL(options.glTarget, dimension, depth);
+  switch (dimension) {
+    case "2d-array":
+    case "3d":
+      if (compressed) {
+        gl.compressedTexSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, typedArray, byteOffset);
+      } else {
+        gl.texSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, glType, typedArray, byteOffset);
+      }
+      break;
+    case "2d":
+    case "cube":
+      if (compressed) {
+        gl.compressedTexSubImage2D(glTarget, level, x, y, width, height, glFormat, typedArray, byteOffset);
+      } else {
+        gl.texSubImage2D(glTarget, level, x, y, width, height, glFormat, glType, typedArray, byteOffset);
+      }
+      break;
+    default:
+      throw new Error(dimension);
+  }
+}
+function getWebGLTextureTarget(dimension) {
+  switch (dimension) {
+    case "1d":
+      break;
+    case "2d":
+      return 3553;
+    case "3d":
+      return 32879;
+    case "cube":
+      return 34067;
+    case "2d-array":
+      return 35866;
+    case "cube-array":
+      break;
+  }
+  throw new Error(dimension);
+}
+function getCubeTargetWebGL(glTarget, dimension, level) {
+  return dimension === "cube" ? 34069 + level : glTarget;
+}
+
 // dist/adapter/resources/webgl-texture.js
-var DEFAULT_WEBGL_TEXTURE_PROPS = {
-  // deprecated
-  parameters: {},
-  pixelStore: {},
-  pixels: null,
-  border: 0,
-  dataFormat: void 0,
-  textureUnit: void 0,
-  target: void 0
-};
-var _WEBGLTexture = class extends import_core9.Texture {
+function normalizeTextureData(data, options) {
+  let lodArray;
+  if (ArrayBuffer.isView(data)) {
+    lodArray = [
+      {
+        // ts-expect-error does data really need to be Uint8ClampedArray?
+        data,
+        width: options.width,
+        height: options.height
+        // depth: options.depth
+      }
+    ];
+  } else if (!Array.isArray(data)) {
+    lodArray = [data];
+  } else {
+    lodArray = data;
+  }
+  return lodArray;
+}
+var WEBGLTexture = class extends import_core7.Texture {
   MAX_ATTRIBUTES;
   device;
   gl;
   handle;
-  // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
   sampler = void 0;
+  // TODO - currently unused in WebGL. Create dummy sampler?
   view = void 0;
-  // data;
-  glFormat = void 0;
-  type = void 0;
-  dataFormat = void 0;
-  mipmaps = void 0;
+  // TODO - currently unused in WebGL. Create dummy view?
+  mipmaps = false;
   /**
    * @note `target` cannot be modified by bind:
    * textures are special because when you first bind them to a target,
-   * they get special information. When you first bind a texture as a
-   * GL_TEXTURE_2D, you are saying that this texture is a 2D texture.
+   * When you first bind a texture as a GL_TEXTURE_2D, you are saying that this texture is a 2D texture.
    * And it will always be a 2D texture; this state cannot be changed ever.
    * A texture that was first bound as a GL_TEXTURE_2D, must always be bound as a GL_TEXTURE_2D;
    * attempting to bind it as GL_TEXTURE_3D will give rise to a run-time error
-   * */
-  target;
-  textureUnit = void 0;
-  /**
-   * Program.draw() checks the loaded flag of all textures to avoid
-   * Textures that are still loading from promises
-   * Set to true as soon as texture has been initialized with valid data
    */
-  loaded = false;
-  _video;
+  glTarget;
+  // Texture type
+  /** The WebGL format - essentially channel structure */
+  glFormat;
+  /** The WebGL data format - the type of each channel */
+  glType;
+  /** The WebGL constant corresponding to the WebGPU style constant in format */
+  glInternalFormat;
+  /** Whether the internal format is compressed */
+  compressed;
+  // data;
+  // inherited props
+  // dimension: ...
+  // format: GLTextureTarget;
+  // width: number = undefined;
+  // height: number = undefined;
+  // depth: number = undefined;
+  // state
+  /** Texture binding slot */
+  textureUnit = 0;
+  /** For automatically updating video */
+  _video = null;
   constructor(device, props) {
-    var _a;
-    super(device, { ...DEFAULT_WEBGL_TEXTURE_PROPS, format: "rgba8unorm", ...props });
+    super(device, { ...import_core7.Texture.defaultProps, ...props, data: void 0 });
     this.device = device;
     this.gl = this.device.gl;
-    this.handle = this.props.handle || this.gl.createTexture();
-    this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
-    this.glFormat = 6408;
-    this.target = getWebGLTextureTarget(this.props);
-    this.loaded = false;
-    if (typeof ((_a = this.props) == null ? void 0 : _a.data) === "string") {
-      Object.assign(this.props, { data: (0, import_core9.loadImage)(this.props.data) });
+    this.glTarget = getWebGLTextureTarget(this.props.dimension);
+    const format = getTextureFormatWebGL(this.props.format);
+    this.glInternalFormat = format.internalFormat;
+    this.glFormat = format.format;
+    this.glType = format.type;
+    this.compressed = format.compressed;
+    if (typeof HTMLVideoElement !== "undefined" && props.data instanceof HTMLVideoElement && // @ts-expect-error
+    props.data.readyState < HTMLVideoElement.HAVE_METADATA) {
+      const video = props.data;
+      this._video = null;
+      video.addEventListener("loadeddata", () => this.initialize(props));
     }
-    this.initialize(this.props);
+    this.initialize({ ...this.props, data: props.data });
     Object.seal(this);
   }
-  destroy() {
-    if (this.handle) {
-      this.gl.deleteTexture(this.handle);
-      this.removeStats();
-      this.trackDeallocatedMemory("Texture");
-      this.destroyed = true;
-    }
-  }
-  toString() {
-    return `Texture(${this.id},${this.width}x${this.height})`;
-  }
-  createView(props) {
-    return new WEBGLTextureView(this.device, { ...props, texture: this });
-  }
+  /**
+   * Initialize texture with supplied props
+   */
   // eslint-disable-next-line max-statements
   initialize(props = {}) {
-    if (this.props.dimension === "cube") {
-      return this.initializeCube(props);
-    }
-    let data = props.data;
-    if (data instanceof Promise) {
-      data.then((resolvedImageData) => this.initialize(Object.assign({}, props, {
-        pixels: resolvedImageData,
-        data: resolvedImageData
-      })));
-      return this;
-    }
-    const isVideo = typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement;
-    if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) {
-      this._video = null;
-      data.addEventListener("loadeddata", () => this.initialize(props));
-      return this;
-    }
-    const { parameters = {} } = props;
-    const { pixels = null, pixelStore = {}, textureUnit = void 0, mipmaps = true } = props;
-    if (!data) {
-      data = pixels;
+    this.handle = this.props.handle || this.gl.createTexture();
+    this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
+    const data = props.data;
+    let { width, height } = props;
+    if (!width || !height) {
+      const textureSize = this.getTextureDataSize(data);
+      width = (textureSize == null ? void 0 : textureSize.width) || 1;
+      height = (textureSize == null ? void 0 : textureSize.height) || 1;
     }
-    let { width, height, dataFormat, type, compressed = false } = props;
-    const { depth = 0 } = props;
-    const glFormat = convertTextureFormatToGL(props.format);
-    ({ width, height, compressed, dataFormat, type } = this._deduceParameters({
-      format: props.format,
-      type,
-      dataFormat,
-      compressed,
-      data,
-      width,
-      height
-    }));
     this.width = width;
     this.height = height;
-    this.glFormat = glFormat;
-    this.type = type;
-    this.dataFormat = dataFormat;
-    this.textureUnit = textureUnit;
-    if (Number.isFinite(this.textureUnit)) {
-      this.gl.activeTexture(33984 + this.textureUnit);
-      this.gl.bindTexture(this.target, this.handle);
-    }
-    this.mipmaps = mipmaps;
-    this.setImageData({
-      data,
-      width,
-      height,
-      depth,
-      format: glFormat,
-      type,
-      dataFormat,
-      // @ts-expect-error
-      parameters: pixelStore,
-      compressed
-    });
+    this.depth = props.depth;
     this.setSampler(props.sampler);
-    this._setSamplerParameters(parameters);
-    this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 });
-    if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
+    this.view = new WEBGLTextureView(this.device, { ...this.props, texture: this });
+    this.bind();
+    if (!this.props.data) {
+      initializeTextureStorage(this.gl, this.mipLevels, this);
+    }
+    if (props.data) {
+      switch (props.dimension) {
+        case "1d":
+          this.setTexture1DData(props.data);
+          break;
+        case "2d":
+          this.setTexture2DData(props.data);
+          break;
+        case "3d":
+          this.setTexture3DData(props.data);
+          break;
+        case "cube":
+          this.setTextureCubeData(props.data);
+          break;
+        case "2d-array":
+          this.setTextureArrayData(props.data);
+          break;
+        case "cube-array":
+          this.setTextureCubeArrayData(props.data);
+          break;
+        default:
+          throw new Error(props.dimension);
+      }
+    }
+    this.mipmaps = Boolean(props.mipmaps);
+    if (this.mipmaps) {
       this.generateMipmap();
     }
-    if (isVideo) {
-      this._video = {
-        video: data,
-        parameters,
-        // @ts-expect-error
-        lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1
-      };
+  }
+  /*
+    initializeCube(props?: TextureProps): void {
+      const {mipmaps = true} = props; // , parameters = {} as Record<GL, any>} = props;
+  
+      // Store props for accessors
+      // this.props = props;
+  
+      // @ts-expect-error
+      this.setCubeMapData(props).then(() => {
+        // TODO - should genMipmap() be called on the cubemap or on the faces?
+        // TODO - without generateMipmap() cube textures do not work at all!!! Why?
+        if (mipmaps) {
+          this.generateMipmap(props);
+        }
+  
+        this.setSampler(props.sampler);
+  
+        // v8 compatibility?
+        // const {parameters = {} as Record<GL, any>} = props;
+        // this._setSamplerParameters(parameters);
+      });
+    }
+    */
+  destroy() {
+    if (this.handle) {
+      this.gl.deleteTexture(this.handle);
+      this.removeStats();
+      this.trackDeallocatedMemory("Texture");
+      this.destroyed = true;
     }
-    return this;
   }
-  initializeCube(props) {
-    const { mipmaps = true, parameters = {} } = props;
-    this.setCubeMapImageData(props).then(() => {
-      this.loaded = true;
-      if (mipmaps) {
-        this.generateMipmap(props);
-      }
-      this.setSampler(props.sampler);
-      this._setSamplerParameters(parameters);
-    });
-    return this;
+  toString() {
+    return `Texture(${this.id},${this.width}x${this.height})`;
+  }
+  createView(props) {
+    return new WEBGLTextureView(this.device, { ...props, texture: this });
   }
   setSampler(sampler = {}) {
     let samplerProps;
@@ -2182,300 +2098,88 @@ var _WEBGLTexture = class extends import_core9.Texture {
     }
     const parameters = convertSamplerParametersToWebGL(samplerProps);
     this._setSamplerParameters(parameters);
-    return this;
   }
-  /**
-   * If size has changed, reinitializes with current format
-   * @note note clears image and mipmaps
-   */
-  resize(options) {
-    const { height, width, mipmaps = false } = options;
-    if (width !== this.width || height !== this.height) {
-      return this.initialize({
-        width,
-        height,
-        format: this.format,
-        type: this.type,
-        dataFormat: this.dataFormat,
-        mipmaps
-      });
-    }
-    return this;
-  }
-  /** Update external texture (video frame) */
+  /** Update external texture (video frame or canvas) */
   update() {
-    if (this._video) {
-      const { video, parameters, lastTime } = this._video;
-      if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) {
-        return;
-      }
-      this.setSubImageData({
-        data: video,
-        parameters
-      });
-      if (this.mipmaps) {
-        this.generateMipmap();
-      }
-      this._video.lastTime = video.currentTime;
-    }
+    import_core7.log.warn("Texture.update() not implemented");
   }
   // Call to regenerate mipmaps after modifying texture(s)
   generateMipmap(params = {}) {
+    if (!this.props.data) {
+      return;
+    }
     this.mipmaps = true;
-    this.gl.bindTexture(this.target, this.handle);
+    this.gl.bindTexture(this.glTarget, this.handle);
     withGLParameters(this.gl, params, () => {
-      this.gl.generateMipmap(this.target);
+      this.gl.generateMipmap(this.glTarget);
     });
-    this.gl.bindTexture(this.target, null);
-    return this;
+    this.gl.bindTexture(this.glTarget, null);
   }
-  /*
-   * Allocates storage
-   * @param {*} pixels -
-   *  null - create empty texture of specified format
-   *  Typed array - init from image data in typed array
-   *  Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer
-   *  HTMLImageElement|Image - Inits with content of image. Auto width/height
-   *  HTMLCanvasElement - Inits with contents of canvas. Auto width/height
-   *  HTMLVideoElement - Creates video texture. Auto width/height
-   *
-   * @param  width -
-   * @param  height -
-   * @param  mipMapLevel -
-   * @param {GLenum} format - format of image data.
-   * @param {GLenum} type
-   *  - format of array (autodetect from type) or
-   *  - (WEBGL2) format of buffer
-   * @param {Number} offset - (WEBGL2) offset from start of buffer
-   * @parameters - temporary settings to be applied, can be used to supply pixel store settings.
-   */
-  // eslint-disable-next-line max-statements, complexity
-  setImageData(options) {
-    if (this.props.dimension === "3d" || this.props.dimension === "2d-array") {
-      return this.setImageData3D(options);
-    }
-    this.trackDeallocatedMemory("Texture");
-    const { target = this.target, pixels = null, level = 0, glFormat = this.glFormat, offset = 0, parameters = {} } = options;
-    let { data = null, type = this.type, width = this.width, height = this.height, dataFormat = this.dataFormat, compressed = false } = options;
-    if (!data) {
-      data = pixels;
-    }
-    ({ type, dataFormat, compressed, width, height } = this._deduceParameters({
-      format: this.props.format,
-      type,
-      dataFormat,
-      compressed,
-      data,
-      width,
-      height
-    }));
-    const { gl } = this;
-    gl.bindTexture(this.target, this.handle);
-    let dataType = null;
-    ({ data, dataType } = this._getDataType({ data, compressed }));
-    withGLParameters(this.gl, parameters, () => {
-      switch (dataType) {
-        case "null":
-          gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
-          break;
-        case "typed-array":
-          gl.texImage2D(
-            target,
-            level,
-            glFormat,
-            width,
-            height,
-            0,
-            // border (must be 0)
-            dataFormat,
-            type,
-            data,
-            offset
-          );
-          break;
-        case "buffer":
-          this.device.gl.bindBuffer(35052, data.handle || data);
-          this.device.gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset);
-          this.device.gl.bindBuffer(35052, null);
-          break;
-        case "browser-object":
-          gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
-          break;
-        case "compressed":
-          for (const [levelIndex, levelData] of data.entries()) {
-            gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data);
-          }
-          break;
-        default:
-          (0, import_core9.assert)(false, "Unknown image data type");
-      }
-    });
-    if (data && data.byteLength) {
-      this.trackAllocatedMemory(data.byteLength, "Texture");
-    } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
-      this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture");
+  // Image Data Setters
+  setTexture1DData(data) {
+    throw new Error("setTexture1DData not supported in WebGL.");
+  }
+  /** Set a simple texture */
+  setTexture2DData(lodData, depth = 0, glTarget = this.glTarget) {
+    this.bind();
+    const lodArray = normalizeTextureData(lodData, this);
+    if (lodArray.length > 1 && this.props.mipmaps !== false) {
+      import_core7.log.warn(`Texture ${this.id} mipmap and multiple LODs.`)();
     }
-    this.loaded = true;
-    return this;
+    for (let lodLevel = 0; lodLevel < lodArray.length; lodLevel++) {
+      const imageData = lodArray[lodLevel];
+      this._setMipLevel(depth, lodLevel, imageData);
+    }
+    this.unbind();
   }
   /**
-   * Redefines an area of an existing texture
-   * Note: does not allocate storage
-   * Redefines an area of an existing texture
+   * Sets a 3D texture
+   * @param data
    */
-  setSubImageData({ target = this.target, pixels = null, data = null, x = 0, y = 0, width = this.width, height = this.height, level = 0, glFormat = this.glFormat, type = this.type, dataFormat = this.dataFormat, compressed = false, offset = 0, parameters = {} }) {
-    ({ type, dataFormat, compressed, width, height } = this._deduceParameters({
-      format: this.props.format,
-      type,
-      dataFormat,
-      compressed,
-      data,
-      width,
-      height
-    }));
-    (0, import_core9.assert)(this.depth === 1, "texSubImage not supported for 3D textures");
-    if (!data) {
-      data = pixels;
+  setTexture3DData(data) {
+    if (this.props.dimension !== "3d") {
+      throw new Error(this.id);
     }
-    if (data && data.data) {
-      const ndarray = data;
-      data = ndarray.data;
-      width = ndarray.shape[0];
-      height = ndarray.shape[1];
-    }
-    if (data instanceof WEBGLBuffer) {
-      data = data.handle;
+    if (ArrayBuffer.isView(data)) {
+      copyCPUDataToMipLevel(this.device.gl, data, this);
     }
-    this.gl.bindTexture(this.target, this.handle);
-    withGLParameters(this.gl, parameters, () => {
-      if (compressed) {
-        this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data);
-      } else if (data === null) {
-        this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);
-      } else if (ArrayBuffer.isView(data)) {
-        this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
-      } else if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) {
-        this.device.gl.bindBuffer(35052, data);
-        this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-        this.device.gl.bindBuffer(35052, null);
-      } else {
-        this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
-      }
-    });
-    this.gl.bindTexture(this.target, null);
   }
   /**
-   * Defines a two-dimensional texture image or cube-map texture image with
-   * pixels from the current framebuffer (rather than from client memory).
-   * (gl.copyTexImage2D wrapper)
-   *
-   * Note that binding a texture into a Framebuffer's color buffer and
-   * rendering can be faster.
+   * Set a Texture Cube Data
+   * @todo - could support TextureCubeArray with depth
+   * @param data
+   * @param index
    */
-  copyFramebuffer(opts = {}) {
-    import_core9.log.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")();
-    return null;
-  }
-  getActiveUnit() {
-    return this.gl.getParameter(34016) - 33984;
-  }
-  bind(textureUnit = this.textureUnit) {
-    const { gl } = this;
-    if (textureUnit !== void 0) {
-      this.textureUnit = textureUnit;
-      gl.activeTexture(33984 + textureUnit);
+  setTextureCubeData(data, depth = 0) {
+    if (this.props.dimension !== "cube") {
+      throw new Error(this.id);
     }
-    gl.bindTexture(this.target, this.handle);
-    return textureUnit;
   }
-  unbind(textureUnit = this.textureUnit) {
-    const { gl } = this;
-    if (textureUnit !== void 0) {
-      this.textureUnit = textureUnit;
-      gl.activeTexture(33984 + textureUnit);
+  /**
+   * Sets an entire texture array
+   * @param data
+   */
+  setTextureArrayData(data) {
+    if (this.props.dimension !== "2d-array") {
+      throw new Error(this.id);
     }
-    gl.bindTexture(this.target, null);
-    return textureUnit;
+    throw new Error("setTextureArrayData not implemented.");
   }
-  // PRIVATE METHODS
-  _getDataType({ data, compressed = false }) {
-    if (compressed) {
-      return { data, dataType: "compressed" };
-    }
-    if (data === null) {
-      return { data, dataType: "null" };
-    }
-    if (ArrayBuffer.isView(data)) {
-      return { data, dataType: "typed-array" };
-    }
-    if (data instanceof WEBGLBuffer) {
-      return { data: data.handle, dataType: "buffer" };
-    }
-    if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) {
-      return { data, dataType: "buffer" };
-    }
-    return { data, dataType: "browser-object" };
-  }
-  // HELPER METHODS
-  _deduceParameters(opts) {
-    const { format, data } = opts;
-    let { width, height, dataFormat, type, compressed } = opts;
-    const parameters = getWebGLTextureParameters(format);
-    dataFormat = dataFormat || parameters.dataFormat;
-    type = type || parameters.type;
-    compressed = compressed || parameters.compressed;
-    ({ width, height } = this._deduceImageSize(data, width, height));
-    return { dataFormat, type, compressed, width, height, format, data };
-  }
-  // eslint-disable-next-line complexity
-  _deduceImageSize(data, width, height) {
-    let size;
-    if (typeof ImageData !== "undefined" && data instanceof ImageData) {
-      size = { width: data.width, height: data.height };
-    } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) {
-      size = { width: data.naturalWidth, height: data.naturalHeight };
-    } else if (typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement) {
-      size = { width: data.width, height: data.height };
-    } else if (typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap) {
-      size = { width: data.width, height: data.height };
-    } else if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) {
-      size = { width: data.videoWidth, height: data.videoHeight };
-    } else if (!data) {
-      size = { width: width >= 0 ? width : 1, height: height >= 0 ? height : 1 };
-    } else {
-      size = { width, height };
-    }
-    (0, import_core9.assert)(size, "Could not deduced texture size");
-    (0, import_core9.assert)(width === void 0 || size.width === width, "Deduced texture width does not match supplied width");
-    (0, import_core9.assert)(height === void 0 || size.height === height, "Deduced texture height does not match supplied height");
-    return size;
+  /**
+   * Sets an entire texture cube array
+   * @param data
+   */
+  setTextureCubeArrayData(data) {
+    throw new Error("setTextureCubeArrayData not supported in WebGL2.");
   }
-  // CUBE MAP METHODS
-  /* eslint-disable max-statements, max-len */
-  async setCubeMapImageData(options) {
-    const { gl } = this;
-    const { width, height, pixels, data, format = 6408, type = 5121 } = options;
-    const imageDataMap = pixels || data;
-    const resolvedFaces = await Promise.all(_WEBGLTexture.FACES.map((face) => {
-      const facePixels = imageDataMap[face];
-      return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]);
-    }));
+  setTextureCubeFaceData(lodData, face, depth = 0) {
+    if (Array.isArray(lodData) && lodData.length > 1 && this.props.mipmaps !== false) {
+      import_core7.log.warn(`${this.id} has mipmap and multiple LODs.`)();
+    }
     this.bind();
-    _WEBGLTexture.FACES.forEach((face, index) => {
-      if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
-        import_core9.log.warn(`${this.id} has mipmap and multiple LODs.`)();
-      }
-      resolvedFaces[index].forEach((image, lodLevel) => {
-        if (width && height) {
-          gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
-        } else {
-          gl.texImage2D(face, lodLevel, format, format, type, image);
-        }
-      });
-    });
     this.unbind();
   }
+  // INTERNAL METHODS
   /** @todo update this method to accept LODs */
   setImageDataForFace(options) {
     const {
@@ -2502,121 +2206,157 @@ var _WEBGLTexture = class extends import_core9.Texture {
     } else {
       gl.texImage2D(face, 0, format, format, type, imageData);
     }
-    return this;
   }
-  /** Image 3D copies from Typed Array or WebGLBuffer */
-  setImageData3D(options) {
-    const {
-      level = 0,
-      dataFormat,
-      format,
-      type,
-      // = GL.UNSIGNED_BYTE,
-      width,
-      height,
-      depth = 1,
-      offset = 0,
-      data,
-      parameters = {}
-    } = options;
-    this.trackDeallocatedMemory("Texture");
-    this.gl.bindTexture(this.target, this.handle);
-    const webglTextureFormat = getWebGLTextureParameters(format);
-    withGLParameters(this.gl, parameters, () => {
-      if (ArrayBuffer.isView(data)) {
-        this.gl.texImage3D(
-          this.target,
-          level,
-          webglTextureFormat.format,
-          width,
-          height,
-          depth,
-          0,
-          webglTextureFormat.dataFormat,
-          webglTextureFormat.type,
-          // dataType: getWebGL,
-          data
-        );
-      }
-      if (data instanceof WEBGLBuffer) {
-        this.gl.bindBuffer(35052, data.handle);
-        this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, 0, format, type, offset);
+  _getImageDataMap(faceData) {
+    for (let i = 0; i < import_core7.Texture.CubeFaces.length; ++i) {
+      const faceName = import_core7.Texture.CubeFaces[i];
+      if (faceData[faceName]) {
+        faceData[34069 + i] = faceData[faceName];
+        delete faceData[faceName];
       }
-    });
-    if (data && data.byteLength) {
-      this.trackAllocatedMemory(data.byteLength, "Texture");
-    } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
-      this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, "Texture");
     }
-    this.loaded = true;
-    return this;
+    return faceData;
   }
   // RESOURCE METHODS
   /**
    * Sets sampler parameters on texture
    */
   _setSamplerParameters(parameters) {
-    if ((0, import_core9.isObjectEmpty)(parameters)) {
-      return;
-    }
-    logParameters(parameters);
-    this.gl.bindTexture(this.target, this.handle);
+    import_core7.log.log(1, "texture sampler parameters", parameters)();
+    this.gl.bindTexture(this.glTarget, this.handle);
     for (const [pname, pvalue] of Object.entries(parameters)) {
       const param = Number(pname);
       const value = pvalue;
       switch (param) {
         case 33082:
         case 33083:
-          this.gl.texParameterf(this.target, param, value);
+          this.gl.texParameterf(this.glTarget, param, value);
+          break;
+        case 10241:
+          this.gl.texParameteri(this.glTarget, param, value);
+          break;
+        case 10242:
+        case 10243:
+          this.gl.texParameteri(this.glTarget, param, value);
+          break;
+        case 34046:
+          if (this.device.features.has("texture-filterable-anisotropic-webgl")) {
+            this.gl.texParameteri(this.glTarget, param, value);
+          }
           break;
         default:
-          this.gl.texParameteri(this.target, param, value);
+          this.gl.texParameteri(this.glTarget, param, value);
           break;
       }
     }
-    this.gl.bindTexture(this.target, null);
-    return;
+    this.gl.bindTexture(this.glTarget, null);
   }
-};
-var WEBGLTexture = _WEBGLTexture;
-// TODO - remove?
-__publicField(WEBGLTexture, "FACES", [
-  34069,
-  34070,
-  34071,
-  34072,
-  34073,
-  34074
-]);
-function getWebGLTextureTarget(props) {
-  switch (props.dimension) {
-    case "2d":
-      return 3553;
-    case "cube":
-      return 34067;
-    case "2d-array":
-      return 35866;
-    case "3d":
-      return 32879;
-    case "1d":
-    case "cube-array":
-    default:
-      throw new Error(props.dimension);
+  // CLASSIC
+  /*
+    setCubeMapData(options: {
+      width: number;
+      height: number;
+      data: Record<GL, Texture2DData> | Record<TextureCubeFace, Texture2DData>;
+      format?: any;
+      type?: any;
+      /** @deprecated Use .data *
+      pixels: any;
+    }): void {
+      const {gl} = this;
+  
+      const {width, height, pixels, data, format = GL.RGBA, type = GL.UNSIGNED_BYTE} = options;
+  
+      // pixel data (imageDataMap) is an Object from Face to Image or Promise.
+      // For example:
+      // {
+      // GL.TEXTURE_CUBE_MAP_POSITIVE_X : Image-or-Promise,
+      // GL.TEXTURE_CUBE_MAP_NEGATIVE_X : Image-or-Promise,
+      // ... }
+      // To provide multiple level-of-details (LODs) this can be Face to Array
+      // of Image or Promise, like this
+      // {
+      // GL.TEXTURE_CUBE_MAP_POSITIVE_X : [Image-or-Promise-LOD-0, Image-or-Promise-LOD-1],
+      // GL.TEXTURE_CUBE_MAP_NEGATIVE_X : [Image-or-Promise-LOD-0, Image-or-Promise-LOD-1],
+      // ... }
+  
+      const imageDataMap = this._getImageDataMap(pixels || data);
+  
+      const resolvedFaces = WEBGLTexture.FACES.map(face => {
+        const facePixels = imageDataMap[face];
+        return Array.isArray(facePixels) ? facePixels : [facePixels];
+      });
+      this.bind();
+  
+      WEBGLTexture.FACES.forEach((face, index) => {
+        if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
+          // If the user provides multiple LODs, then automatic mipmap
+          // generation generateMipmap() should be disabled to avoid overwritting them.
+          log.warn(`${this.id} has mipmap and multiple LODs.`)();
+        }
+        resolvedFaces[index].forEach((image, lodLevel) => {
+          // TODO: adjust width & height for LOD!
+          if (width && height) {
+            gl.texImage2D(face, lodLevel, format, width, height, 0 /* border*, format, type, image);
+          } else {
+            gl.texImage2D(face, lodLevel, format, format, type, image);
+          }
+        });
+      });
+  
+      this.unbind();
+    }
+    */
+  // INTERNAL SETTERS
+  /**
+   * Copy a region of data from a CPU memory buffer into this texture.
+   * @todo -   GLUnpackParameters parameters
+   */
+  _setMipLevel(depth, level, textureData, offset = 0) {
+    if (import_core7.Texture.isExternalImage(textureData)) {
+      copyCPUImageToMipLevel(this.device.gl, textureData, { ...this, depth, level });
+      return;
+    }
+    if (this.isTextureLevelData(textureData)) {
+      copyCPUDataToMipLevel(this.device.gl, textureData.data, {
+        ...this,
+        depth,
+        level
+      });
+      return;
+    }
+    throw new Error("Texture: invalid image data");
   }
-}
-function logParameters(parameters) {
-  import_core9.log.log(1, "texture sampler parameters", parameters)();
-}
+  // HELPERS
+  getActiveUnit() {
+    return this.gl.getParameter(34016) - 33984;
+  }
+  bind(textureUnit) {
+    const { gl } = this;
+    if (textureUnit !== void 0) {
+      this.textureUnit = textureUnit;
+      gl.activeTexture(33984 + textureUnit);
+    }
+    gl.bindTexture(this.glTarget, this.handle);
+    return textureUnit;
+  }
+  unbind(textureUnit) {
+    const { gl } = this;
+    if (textureUnit !== void 0) {
+      this.textureUnit = textureUnit;
+      gl.activeTexture(33984 + textureUnit);
+    }
+    gl.bindTexture(this.glTarget, null);
+    return textureUnit;
+  }
+};
 
 // dist/adapter/resources/webgl-framebuffer.js
-var WEBGLFramebuffer = class extends import_core10.Framebuffer {
+var WEBGLFramebuffer = class extends import_core8.Framebuffer {
   device;
   gl;
   handle;
-  get texture() {
-    return this.colorAttachments[0];
-  }
+  colorAttachments = [];
+  depthStencilAttachment = null;
   constructor(device, props) {
     super(device, props);
     const isDefaultFramebuffer = props.handle === null;
@@ -2631,11 +2371,11 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
         const attachment = this.colorAttachments[i];
         const attachmentPoint = 36064 + i;
         if (attachment) {
-          this._attachOne(attachmentPoint, attachment);
+          this._attachTexture(attachmentPoint, attachment);
         }
       }
       if (this.depthStencilAttachment) {
-        this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format), this.depthStencilAttachment);
+        this._attachTexture(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format), this.depthStencilAttachment);
       }
       if (props.check !== false) {
         const status = this.gl.checkFramebufferStatus(36160);
@@ -2665,68 +2405,55 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
     });
   }
   /**
-   * Attachment resize is expected to be a noop if size is same
-   */
-  resizeAttachments(width, height) {
-    if (this.handle === null) {
-      this.width = this.gl.drawingBufferWidth;
-      this.height = this.gl.drawingBufferHeight;
+     * Attachment resize is expected to be a noop if size is same
+     *
+    protected override resizeAttachments(width: number, height: number): this {
+      // for default framebuffer, just update the stored size
+      if (this.handle === null) {
+        // assert(width === undefined && height === undefined);
+        this.width = this.gl.drawingBufferWidth;
+        this.height = this.gl.drawingBufferHeight;
+        return this;
+      }
+  
+      if (width === undefined) {
+        width = this.gl.drawingBufferWidth;
+      }
+      if (height === undefined) {
+        height = this.gl.drawingBufferHeight;
+      }
+  
+      // TODO Not clear that this is better than default destroy/create implementation
+  
+      for (const colorAttachment of this.colorAttachments) {
+        colorAttachment.texture.clone({width, height});
+      }
+      if (this.depthStencilAttachment) {
+        this.depthStencilAttachment.texture.resize({width, height});
+      }
       return this;
     }
-    if (width === void 0) {
-      width = this.gl.drawingBufferWidth;
-    }
-    if (height === void 0) {
-      height = this.gl.drawingBufferHeight;
-    }
-    for (const colorAttachment of this.colorAttachments) {
-      colorAttachment.texture.resize({ width, height });
-    }
-    if (this.depthStencilAttachment) {
-      this.depthStencilAttachment.texture.resize({ width, height });
-    }
-    return this;
-  }
+    */
   /** Attach one attachment */
-  _attachOne(attachmentPoint, attachment) {
-    if (Array.isArray(attachment)) {
-      const [texture, layer = 0, level = 0] = attachment;
-      this._attachTexture(attachmentPoint, texture, layer, level);
-      return texture;
-    }
-    if (attachment instanceof WEBGLTexture) {
-      this._attachTexture(attachmentPoint, attachment, 0, 0);
-      return attachment;
-    }
-    if (attachment instanceof WEBGLTextureView) {
-      const textureView = attachment;
-      this._attachTexture(attachmentPoint, textureView.texture, textureView.props.baseMipLevel, textureView.props.baseArrayLayer);
-      return attachment.texture;
-    }
-    throw new Error("attach");
-  }
-  // TODO - we do not seem to need render buffers in WebGL 2
-  // protected _attachWEBGLRenderbuffer(attachment: GL, renderbuffer: WEBGLRenderbuffer): void {
-  //   this.gl.framebufferRenderbuffer(
-  //     GL.FRAMEBUFFER,
-  //     attachment,
-  //     GL.RENDERBUFFER,
-  //     renderbuffer.handle
-  //   );
-  // }
+  _attachTexture(attachmentPoint, textureView) {
+    this._attachTextureView(attachmentPoint, textureView);
+  }
   /**
    * @param attachment
    * @param texture
    * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
    * @param level = 0 - mipmapLevel
    */
-  _attachTexture(attachment, texture, layer, level) {
+  _attachTextureView(attachment, textureView) {
     const { gl } = this.device;
-    gl.bindTexture(texture.target, texture.handle);
-    switch (texture.target) {
+    const { texture } = textureView;
+    const level = textureView.props.baseMipLevel;
+    const layer = textureView.props.baseArrayLayer;
+    gl.bindTexture(texture.glTarget, texture.handle);
+    switch (texture.glTarget) {
       case 35866:
       case 32879:
-        gl.framebufferTextureLayer(36160, attachment, texture.target, level, layer);
+        gl.framebufferTextureLayer(36160, attachment, texture.glTarget, level, layer);
         break;
       case 34067:
         const face = mapIndexToCubeMapFace(layer);
@@ -2736,9 +2463,9 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
         gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level);
         break;
       default:
-        (0, import_core10.assert)(false, "Illegal texture type");
+        throw new Error("Illegal texture type");
     }
-    gl.bindTexture(texture.target, null);
+    gl.bindTexture(texture.glTarget, null);
   }
 };
 function mapIndexToCubeMapFace(layer) {
@@ -2764,8 +2491,10 @@ function _getFrameBufferStatus(status) {
 }
 
 // dist/adapter/webgl-canvas-context.js
-var WebGLCanvasContext = class extends import_core11.CanvasContext {
+var WebGLCanvasContext = class extends import_core9.CanvasContext {
   device;
+  format = "rgba8unorm";
+  depthStencilFormat = "depth24plus";
   presentationSize;
   _framebuffer = null;
   constructor(device, props) {
@@ -2815,9 +2544,30 @@ var WebGLCanvasContext = class extends import_core11.CanvasContext {
 };
 
 // dist/context/debug/spector.js
-var import_core12 = require("@luma.gl/core");
+var import_core10 = require("@luma.gl/core");
+
+// dist/utils/load-script.js
+async function loadScript(scriptUrl, scriptId) {
+  const head = document.getElementsByTagName("head")[0];
+  if (!head) {
+    throw new Error("loadScript");
+  }
+  const script = document.createElement("script");
+  script.setAttribute("type", "text/javascript");
+  script.setAttribute("src", scriptUrl);
+  if (scriptId) {
+    script.id = scriptId;
+  }
+  return new Promise((resolve, reject) => {
+    script.onload = resolve;
+    script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error}`));
+    head.appendChild(script);
+  });
+}
+
+// dist/context/debug/spector.js
 var DEFAULT_SPECTOR_PROPS = {
-  spector: import_core12.log.get("spector") || import_core12.log.get("inspect")
+  spector: import_core10.log.get("spector") || import_core10.log.get("inspect")
 };
 var SPECTOR_CDN_URL = "https://spectorcdn.babylonjs.com/spector.bundle.js";
 var LOG_LEVEL = 1;
@@ -2826,9 +2576,9 @@ var initialized = false;
 async function loadSpectorJS(props) {
   if (!globalThis.SPECTOR) {
     try {
-      await (0, import_core12.loadScript)(SPECTOR_CDN_URL);
+      await loadScript(SPECTOR_CDN_URL);
     } catch (error) {
-      import_core12.log.warn(String(error));
+      import_core10.log.warn(String(error));
     }
   }
 }
@@ -2838,7 +2588,7 @@ function initializeSpectorJS(props) {
     return null;
   }
   if (!spector && globalThis.SPECTOR) {
-    import_core12.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
+    import_core10.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
     spector = new globalThis.SPECTOR.Spector();
     if (globalThis.luma) {
       globalThis.luma.spector = spector;
@@ -2850,9 +2600,9 @@ function initializeSpectorJS(props) {
   if (!initialized) {
     initialized = true;
     spector.spyCanvases();
-    spector == null ? void 0 : spector.onCaptureStarted.add((capture) => import_core12.log.info("Spector capture started:", capture)());
+    spector == null ? void 0 : spector.onCaptureStarted.add((capture) => import_core10.log.info("Spector capture started:", capture)());
     spector == null ? void 0 : spector.onCapture.add((capture) => {
-      import_core12.log.info("Spector capture complete:", capture)();
+      import_core10.log.info("Spector capture complete:", capture)();
       spector == null ? void 0 : spector.getResultUI();
       spector == null ? void 0 : spector.resultView.display();
       spector == null ? void 0 : spector.resultView.addCapture(capture);
@@ -2864,7 +2614,7 @@ function initializeSpectorJS(props) {
     }
     spector == null ? void 0 : spector.startCapture(props == null ? void 0 : props.canvas, 500);
     new Promise((resolve) => setTimeout(resolve, 2e3)).then((_) => {
-      import_core12.log.info("Spector capture stopped after 2 seconds")();
+      import_core10.log.info("Spector capture stopped after 2 seconds")();
       spector == null ? void 0 : spector.stopCapture();
     });
   }
@@ -2872,7 +2622,7 @@ function initializeSpectorJS(props) {
 }
 
 // dist/context/debug/webgl-developer-tools.js
-var import_core13 = require("@luma.gl/core");
+var import_core11 = require("@luma.gl/core");
 var import_constants12 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
@@ -2884,91 +2634,213 @@ async function loadWebGLDeveloperTools() {
   if ((0, import_env.isBrowser)() && !globalThis.WebGLDebugUtils) {
     globalThis.global = globalThis.global || globalThis;
     globalThis.global.module = {};
-    await (0, import_core13.loadScript)(WEBGL_DEBUG_CDN_URL);
+    await loadScript(WEBGL_DEBUG_CDN_URL);
+  }
+}
+function makeDebugContext(gl, props = {}) {
+  return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
+}
+function getRealContext(gl) {
+  const data = getWebGLContextData(gl);
+  return data.realContext ? data.realContext : gl;
+}
+function getDebugContext(gl, props) {
+  if (!globalThis.WebGLDebugUtils) {
+    import_core11.log.warn("webgl-debug not loaded")();
+    return gl;
+  }
+  const data = getWebGLContextData(gl);
+  if (data.debugContext) {
+    return data.debugContext;
+  }
+  globalThis.WebGLDebugUtils.init({ ...import_constants12.GL, ...gl });
+  const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
+  for (const key in import_constants12.GL) {
+    if (!(key in glDebug) && typeof import_constants12.GL[key] === "number") {
+      glDebug[key] = import_constants12.GL[key];
+    }
+  }
+  class WebGLDebugContext {
+  }
+  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
+  Object.setPrototypeOf(WebGLDebugContext, glDebug);
+  const debugContext = Object.create(WebGLDebugContext);
+  data.realContext = gl;
+  data.debugContext = debugContext;
+  debugContext.debug = true;
+  return debugContext;
+}
+function getFunctionString(functionName, functionArgs) {
+  functionArgs = Array.from(functionArgs).map((arg) => arg === void 0 ? "undefined" : arg);
+  let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
+  args = `${args.slice(0, 100)}${args.length > 100 ? "..." : ""}`;
+  return `gl.${functionName}(${args})`;
+}
+function onGLError(props, err, functionName, args) {
+  args = Array.from(args).map((arg) => arg === void 0 ? "undefined" : arg);
+  const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
+  const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
+  const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
+  import_core11.log.error(message2)();
+  debugger;
+  if (props.throwOnError) {
+    throw new Error(message2);
+  }
+}
+function onValidateGLFunc(props, functionName, functionArgs) {
+  let functionString = "";
+  if (import_core11.log.level >= 1) {
+    functionString = getFunctionString(functionName, functionArgs);
+    import_core11.log.log(1, functionString)();
+  }
+  if (props.break && props.break.length > 0) {
+    functionString = functionString || getFunctionString(functionName, functionArgs);
+    const isBreakpoint = props.break.every((breakOn) => functionString.indexOf(breakOn) !== -1);
+    if (isBreakpoint) {
+      debugger;
+    }
+  }
+  for (const arg of functionArgs) {
+    if (arg === void 0) {
+      functionString = functionString || getFunctionString(functionName, functionArgs);
+      if (props.throwOnError) {
+        throw new Error(`Undefined argument: ${functionString}`);
+      } else {
+        import_core11.log.error(`Undefined argument: ${functionString}`)();
+        debugger;
+      }
+    }
+  }
+}
+
+// dist/adapter/resources/webgl-buffer.js
+var import_core12 = require("@luma.gl/core");
+var import_constants13 = require("@luma.gl/constants");
+var WEBGLBuffer = class extends import_core12.Buffer {
+  device;
+  gl;
+  handle;
+  /** Target in OpenGL defines the type of buffer */
+  glTarget;
+  /** Usage is a hint on how frequently the buffer will be updates */
+  glUsage;
+  /** Index type is needed when issuing draw calls, so we pre-compute it */
+  glIndexType = 5123;
+  /** Number of bytes allocated on the GPU for this buffer */
+  byteLength;
+  /** Number of bytes used */
+  bytesUsed;
+  constructor(device, props = {}) {
+    super(device, props);
+    this.device = device;
+    this.gl = this.device.gl;
+    const handle = typeof props === "object" ? props.handle : void 0;
+    this.handle = handle || this.gl.createBuffer();
+    device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
+    this.glTarget = getWebGLTarget(this.props.usage);
+    this.glUsage = getWebGLUsage(this.props.usage);
+    this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123;
+    if (props.data) {
+      this._initWithData(props.data, props.byteOffset, props.byteLength);
+    } else {
+      this._initWithByteLength(props.byteLength || 0);
+    }
+  }
+  // PRIVATE METHODS
+  /** Allocate a new buffer and initialize to contents of typed array */
+  _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
+    const glTarget = this.glTarget;
+    this.gl.bindBuffer(glTarget, this.handle);
+    this.gl.bufferData(glTarget, byteLength, this.glUsage);
+    this.gl.bufferSubData(glTarget, byteOffset, data);
+    this.gl.bindBuffer(glTarget, null);
+    this.bytesUsed = byteLength;
+    this.byteLength = byteLength;
+    this._setDebugData(data, byteOffset, byteLength);
+    this.trackAllocatedMemory(byteLength);
+  }
+  // Allocate a GPU buffer of specified size.
+  _initWithByteLength(byteLength) {
+    let data = byteLength;
+    if (byteLength === 0) {
+      data = new Float32Array(0);
+    }
+    const glTarget = this.glTarget;
+    this.gl.bindBuffer(glTarget, this.handle);
+    this.gl.bufferData(glTarget, data, this.glUsage);
+    this.gl.bindBuffer(glTarget, null);
+    this.bytesUsed = byteLength;
+    this.byteLength = byteLength;
+    this._setDebugData(null, 0, byteLength);
+    this.trackAllocatedMemory(byteLength);
+    return this;
+  }
+  destroy() {
+    if (!this.destroyed && this.handle) {
+      this.removeStats();
+      this.trackDeallocatedMemory();
+      this.gl.deleteBuffer(this.handle);
+      this.destroyed = true;
+      this.handle = null;
+    }
   }
-}
-function makeDebugContext(gl, props = {}) {
-  if (!gl) {
-    return null;
+  write(data, byteOffset = 0) {
+    const srcOffset = 0;
+    const byteLength = void 0;
+    const glTarget = 36663;
+    this.gl.bindBuffer(glTarget, this.handle);
+    if (srcOffset !== 0 || byteLength !== void 0) {
+      this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
+    } else {
+      this.gl.bufferSubData(glTarget, byteOffset, data);
+    }
+    this.gl.bindBuffer(glTarget, null);
+    this._setDebugData(data, byteOffset, data.byteLength);
   }
-  return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
-}
-function getRealContext(gl) {
-  const data = getWebGLContextData(gl);
-  return data.realContext ? data.realContext : gl;
-}
-function getDebugContext(gl, props) {
-  if (!globalThis.WebGLDebugUtils) {
-    import_core13.log.warn("webgl-debug not loaded")();
-    return gl;
+  /** Asynchronously read data from the buffer */
+  async readAsync(byteOffset = 0, byteLength) {
+    return this.readSyncWebGL(byteOffset, byteLength);
   }
-  const data = getWebGLContextData(gl);
-  if (data.debugContext) {
-    return data.debugContext;
+  /** Synchronously read data from the buffer. WebGL only. */
+  readSyncWebGL(byteOffset = 0, byteLength) {
+    byteLength = byteLength ?? this.byteLength - byteOffset;
+    const data = new Uint8Array(byteLength);
+    const dstOffset = 0;
+    this.gl.bindBuffer(36662, this.handle);
+    this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength);
+    this.gl.bindBuffer(36662, null);
+    this._setDebugData(data, byteOffset, byteLength);
+    return data;
   }
-  globalThis.WebGLDebugUtils.init({ ...import_constants12.GL, ...gl });
-  const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
-  for (const key in import_constants12.GL) {
-    if (!(key in glDebug) && typeof import_constants12.GL[key] === "number") {
-      glDebug[key] = import_constants12.GL[key];
-    }
+};
+function getWebGLTarget(usage) {
+  if (usage & import_core12.Buffer.INDEX) {
+    return 34963;
   }
-  class WebGLDebugContext {
+  if (usage & import_core12.Buffer.VERTEX) {
+    return 34962;
   }
-  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
-  Object.setPrototypeOf(WebGLDebugContext, glDebug);
-  const debugContext = Object.create(WebGLDebugContext);
-  data.realContext = gl;
-  data.debugContext = debugContext;
-  debugContext.debug = true;
-  return debugContext;
-}
-function getFunctionString(functionName, functionArgs) {
-  functionArgs = Array.from(functionArgs).map((arg) => arg === void 0 ? "undefined" : arg);
-  let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
-  args = `${args.slice(0, 100)}${args.length > 100 ? "..." : ""}`;
-  return `gl.${functionName}(${args})`;
-}
-function onGLError(props, err, functionName, args) {
-  args = Array.from(args).map((arg) => arg === void 0 ? "undefined" : arg);
-  const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
-  const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
-  const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
-  import_core13.log.error(message2)();
-  debugger;
-  if (props.throwOnError) {
-    throw new Error(message2);
+  if (usage & import_core12.Buffer.UNIFORM) {
+    return 35345;
   }
+  return 34962;
 }
-function onValidateGLFunc(props, functionName, functionArgs) {
-  let functionString = "";
-  if (import_core13.log.level >= 1) {
-    functionString = getFunctionString(functionName, functionArgs);
-    import_core13.log.log(1, functionString)();
+function getWebGLUsage(usage) {
+  if (usage & import_core12.Buffer.INDEX) {
+    return 35044;
   }
-  if (props.break && props.break.length > 0) {
-    functionString = functionString || getFunctionString(functionName, functionArgs);
-    const isBreakpoint = props.break.every((breakOn) => functionString.indexOf(breakOn) !== -1);
-    if (isBreakpoint) {
-      debugger;
-    }
+  if (usage & import_core12.Buffer.VERTEX) {
+    return 35044;
   }
-  for (const arg of functionArgs) {
-    if (arg === void 0) {
-      functionString = functionString || getFunctionString(functionName, functionArgs);
-      if (props.throwOnError) {
-        throw new Error(`Undefined argument: ${functionString}`);
-      } else {
-        import_core13.log.error(`Undefined argument: ${functionString}`)();
-        debugger;
-      }
-    }
+  if (usage & import_core12.Buffer.UNIFORM) {
+    return 35048;
   }
+  return 35044;
 }
 
 // dist/adapter/resources/webgl-shader.js
-var import_core14 = require("@luma.gl/core");
-var import_constants13 = require("@luma.gl/constants");
+var import_core13 = require("@luma.gl/core");
+var import_constants14 = require("@luma.gl/constants");
 
 // dist/adapter/helpers/parse-shader-compiler-log.js
 function parseShaderCompilerLog(errLog) {
@@ -3015,7 +2887,7 @@ function getMessageType(messageType) {
 }
 
 // dist/adapter/resources/webgl-shader.js
-var WEBGLShader = class extends import_core14.Shader {
+var WEBGLShader = class extends import_core13.Shader {
   device;
   handle;
   constructor(device, props) {
@@ -3046,12 +2918,12 @@ var WEBGLShader = class extends import_core14.Shader {
   }
   getCompilationInfoSync() {
     const log9 = this.device.gl.getShaderInfoLog(this.handle);
-    return parseShaderCompilerLog(log9);
+    return log9 ? parseShaderCompilerLog(log9) : [];
   }
   getTranslatedSource() {
     const extensions = this.device.getExtension("WEBGL_debug_shaders");
     const ext = extensions.WEBGL_debug_shaders;
-    return ext == null ? void 0 : ext.getTranslatedShaderSource(this.handle);
+    return (ext == null ? void 0 : ext.getTranslatedShaderSource(this.handle)) || null;
   }
   // PRIVATE METHODS
   /** Compile a shader and get compilation status */
@@ -3062,7 +2934,7 @@ ${source2}`;
     const { gl } = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
-    if (import_core14.log.level === 0) {
+    if (import_core13.log.level === 0) {
       this.compilationStatus = "pending";
       return;
     }
@@ -3074,9 +2946,9 @@ ${source2}`;
       }
       return;
     }
-    import_core14.log.once(1, "Shader compilation is asynchronous")();
+    import_core13.log.once(1, "Shader compilation is asynchronous")();
     await this._waitForCompilationComplete();
-    import_core14.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+    import_core13.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
     this._getCompilationStatus();
     this.debugShader();
   }
@@ -3108,14 +2980,14 @@ ${source2}`;
 };
 
 // dist/adapter/resources/webgl-render-pass.js
-var import_core15 = require("@luma.gl/core");
-var import_constants14 = require("@luma.gl/constants");
+var import_core14 = require("@luma.gl/core");
+var import_constants15 = 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 COLOR_CHANNELS = [1, 2, 4, 8];
-var WEBGLRenderPass = class extends import_core15.RenderPass {
+var WEBGLRenderPass = class extends import_core14.RenderPass {
   device;
   /** Parameters that should be applied before each draw call */
   glParameters;
@@ -3143,9 +3015,7 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
    */
   setParameters(parameters = {}) {
     const glParameters = { ...this.glParameters };
-    if (this.props.framebuffer) {
-      glParameters.framebuffer = this.props.framebuffer;
-    }
+    glParameters.framebuffer = this.props.framebuffer || null;
     if (this.props.depthReadOnly) {
       glParameters.depthMask = !this.props.depthReadOnly;
     }
@@ -3231,19 +3101,17 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
 };
 
 // dist/adapter/resources/webgl-render-pipeline.js
-var import_core17 = require("@luma.gl/core");
-var import_core18 = require("@luma.gl/core");
-var import_constants21 = require("@luma.gl/constants");
+var import_core15 = require("@luma.gl/core");
+var import_constants22 = require("@luma.gl/constants");
 
 // dist/adapter/helpers/get-shader-layout.js
-var import_constants18 = require("@luma.gl/constants");
+var import_constants19 = require("@luma.gl/constants");
 
 // dist/classic/accessor.js
-var import_core16 = require("@luma.gl/core");
-var import_constants16 = require("@luma.gl/constants");
+var import_constants17 = require("@luma.gl/constants");
 
 // dist/classic/typed-array-utils.js
-var import_constants15 = require("@luma.gl/constants");
+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;
@@ -3303,12 +3171,6 @@ var DEFAULT_ACCESSOR_VALUES = {
   normalized: false,
   integer: false
 };
-var PROP_CHECKS = {
-  deprecatedProps: {
-    instanced: "divisor",
-    isInstanced: "divisor"
-  }
-};
 var Accessor = class {
   offset;
   stride;
@@ -3324,7 +3186,6 @@ var Accessor = class {
     return ArrayType.BYTES_PER_ELEMENT;
   }
   static getBytesPerVertex(accessor) {
-    (0, import_core16.assert)(accessor.size);
     const ArrayType = getTypedArrayFromGLType(accessor.type || 5126);
     return ArrayType.BYTES_PER_ELEMENT * accessor.size;
   }
@@ -3353,7 +3214,6 @@ var Accessor = class {
   // PRIVATE
   // eslint-disable-next-line complexity, max-statements
   _assign(props = {}) {
-    props = (0, import_core16.checkProps)("Accessor", props, PROP_CHECKS);
     if (props.type !== void 0) {
       this.type = props.type;
       if (props.type === 5124 || props.type === 5125) {
@@ -3420,7 +3280,7 @@ var Accessor = class {
 };
 
 // dist/adapter/helpers/decode-webgl-types.js
-var import_constants17 = require("@luma.gl/constants");
+var import_constants18 = require("@luma.gl/constants");
 function isSamplerUniform(type) {
   return SAMPLER_TYPES.includes(type);
 }
@@ -3713,7 +3573,7 @@ function parseUniformName(name) {
 }
 
 // dist/adapter/helpers/set-uniform.js
-var import_constants19 = require("@luma.gl/constants");
+var import_constants20 = require("@luma.gl/constants");
 function setUniform(gl, location, type, value) {
   const gl2 = gl;
   let uniformValue = value;
@@ -3798,8 +3658,26 @@ function setUniform(gl, location, type, value) {
   throw new Error("Illegal uniform");
 }
 
+// dist/utils/split-uniforms-and-bindings.js
+var import_types = require("@math.gl/types");
+function isUniformValue(value) {
+  return (0, import_types.isNumericArray)(value) !== null || typeof value === "number" || typeof value === "boolean";
+}
+function splitUniformsAndBindings(uniforms) {
+  const result = { bindings: {}, uniforms: {} };
+  Object.keys(uniforms).forEach((name) => {
+    const uniform = uniforms[name];
+    if (isUniformValue(uniform)) {
+      result.uniforms[name] = uniform;
+    } else {
+      result.bindings[name] = uniform;
+    }
+  });
+  return result;
+}
+
 // dist/adapter/helpers/webgl-topology-utils.js
-var import_constants20 = require("@luma.gl/constants");
+var import_constants21 = require("@luma.gl/constants");
 function getGLDrawMode(topology) {
   switch (topology) {
     case "point-list":
@@ -3808,14 +3686,10 @@ function getGLDrawMode(topology) {
       return 1;
     case "line-strip":
       return 3;
-    case "line-loop-webgl":
-      return 2;
     case "triangle-list":
       return 4;
     case "triangle-strip":
       return 5;
-    case "triangle-fan-webgl":
-      return 6;
     default:
       throw new Error(topology);
   }
@@ -3828,14 +3702,10 @@ function getGLPrimitive(topology) {
       return 1;
     case "line-strip":
       return 1;
-    case "line-loop-webgl":
-      return 1;
     case "triangle-list":
       return 4;
     case "triangle-strip":
       return 4;
-    case "triangle-fan-webgl":
-      return 4;
     default:
       throw new Error(topology);
   }
@@ -3843,7 +3713,7 @@ function getGLPrimitive(topology) {
 
 // dist/adapter/resources/webgl-render-pipeline.js
 var LOG_PROGRAM_PERF_PRIORITY = 4;
-var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
+var WEBGLRenderPipeline = class extends import_core15.RenderPipeline {
   /** The WebGL device that created this render pipeline */
   device;
   /** Handle to underlying WebGL program */
@@ -3868,25 +3738,18 @@ var WEBGLRenderPipeline = class extends import_core17.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_core17.cast)(props.vs);
-    this.fs = (0, import_core17.cast)(props.fs);
+    this.vs = props.vs;
+    this.fs = props.fs;
     const { varyings, bufferMode = 35981 } = props;
     if (varyings && varyings.length > 0) {
       this.varyings = varyings;
       this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
     }
     this._linkShaders();
-    import_core17.log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+    import_core15.log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
     this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-    import_core17.log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
-    this.shaderLayout = (0, import_core18.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
-    switch (this.props.topology) {
-      case "triangle-fan-webgl":
-      case "line-loop-webgl":
-        import_core17.log.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);
-        break;
-      default:
-    }
+    import_core15.log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+    this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
   }
   destroy() {
     if (this.handle) {
@@ -3904,12 +3767,12 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
       if (!binding) {
         const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
         if (!(options == null ? void 0 : options.disableWarnings)) {
-          import_core17.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
+          import_core15.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
         }
         continue;
       }
       if (!value) {
-        import_core17.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+        import_core15.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
       }
       switch (binding.type) {
         case "uniform":
@@ -3923,7 +3786,7 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
           }
           break;
         case "sampler":
-          import_core17.log.warn(`Ignoring sampler ${name}`)();
+          import_core15.log.warn(`Ignoring sampler ${name}`)();
           break;
         default:
           throw new Error(binding.type);
@@ -3956,17 +3819,13 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     const isIndexed = Boolean(vertexArray.indexBuffer);
     const glIndexType = (_a = vertexArray.indexBuffer) == null ? void 0 : _a.glIndexType;
     if (this.linkStatus !== "success") {
-      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+      import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
       return false;
     }
-    if (!this._areTexturesRenderable() || vertexCount === 0) {
-      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
+    if (!this._areTexturesRenderable()) {
+      import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
       return false;
     }
-    if (vertexCount === 0) {
-      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)();
-      return true;
-    }
     this.device.gl.useProgram(this.handle);
     vertexArray.bindBeforeRender(renderPass);
     if (transformFeedback) {
@@ -4001,9 +3860,9 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
   }
   // DEPRECATED METHODS
   setUniformsWebGL(uniforms) {
-    const { bindings } = (0, import_core17.splitUniformsAndBindings)(uniforms);
+    const { bindings } = splitUniformsAndBindings(uniforms);
     Object.keys(bindings).forEach((name) => {
-      import_core17.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
+      import_core15.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
     });
     Object.assign(this.uniforms, uniforms);
   }
@@ -4014,19 +3873,19 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     const { gl } = this.device;
     gl.attachShader(this.handle, this.vs.handle);
     gl.attachShader(this.handle, this.fs.handle);
-    import_core17.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    import_core15.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
     gl.linkProgram(this.handle);
-    import_core17.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (import_core17.log.level === 0) {
+    import_core15.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (import_core15.log.level === 0) {
     }
     if (!this.device.features.has("compilation-status-async-webgl")) {
       const status2 = this._getLinkStatus();
       this._reportLinkStatus(status2);
       return;
     }
-    import_core17.log.once(1, "RenderPipeline linking is asynchronous")();
+    import_core15.log.once(1, "RenderPipeline linking is asynchronous")();
     await this._waitForLinkComplete();
-    import_core17.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+    import_core15.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
     const status = this._getLinkStatus();
     this._reportLinkStatus(status);
   }
@@ -4093,10 +3952,15 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
    */
   _areTexturesRenderable() {
     let texturesRenderable = true;
+    for (const bindingInfo of this.shaderLayout.bindings) {
+      if (!this.bindings[bindingInfo.name] && !this.bindings[bindingInfo.name.replace(/Uniforms$/, "")]) {
+        import_core15.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
+        texturesRenderable = false;
+      }
+    }
     for (const [, texture] of Object.entries(this.bindings)) {
       if (texture instanceof WEBGLTexture) {
         texture.update();
-        texturesRenderable = texturesRenderable && texture.loaded;
       }
     }
     return texturesRenderable;
@@ -4149,13 +4013,13 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
           } else if (value instanceof WEBGLTexture) {
             texture = value;
           } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
-            import_core17.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
+            import_core15.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
             texture = value.colorAttachments[0].texture;
           } else {
             throw new Error("No texture");
           }
           gl.activeTexture(33984 + textureUnit);
-          gl.bindTexture(texture.target, texture.handle);
+          gl.bindTexture(texture.glTarget, texture.handle);
           textureUnit += 1;
           break;
         case "sampler":
@@ -4180,17 +4044,30 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     }
   }
 };
+function mergeShaderLayout(baseLayout, overrideLayout) {
+  const mergedLayout = {
+    ...baseLayout,
+    attributes: baseLayout.attributes.map((attribute) => ({ ...attribute }))
+  };
+  for (const attribute of (overrideLayout == null ? void 0 : overrideLayout.attributes) || []) {
+    const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
+    if (!baseAttribute) {
+      import_core15.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
+    } else {
+      baseAttribute.type = attribute.type || baseAttribute.type;
+      baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
+    }
+  }
+  return mergedLayout;
+}
 
 // dist/adapter/resources/webgl-command-encoder.js
-var import_core20 = require("@luma.gl/core");
+var import_core17 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgl-command-buffer.js
-var import_core19 = require("@luma.gl/core");
-var import_constants22 = require("@luma.gl/constants");
-function cast2(value) {
-  return value;
-}
-var WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
+var import_core16 = require("@luma.gl/core");
+var import_constants23 = require("@luma.gl/constants");
+var WEBGLCommandBuffer = class extends import_core16.CommandBuffer {
   device;
   commands = [];
   constructor(device) {
@@ -4217,8 +4094,8 @@ var WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
   }
 };
 function _copyBufferToBuffer(device, options) {
-  const source = cast2(options.source);
-  const destination = cast2(options.destination);
+  const source = options.source;
+  const destination = options.destination;
   device.gl.bindBuffer(36662, source.handle);
   device.gl.bindBuffer(36663, destination.handle);
   device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
@@ -4271,8 +4148,8 @@ function _copyTextureToBuffer(device, options) {
     const webglBuffer = destination;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
-    const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format);
-    const sourceFormat = sourceParams.dataFormat;
+    const sourceParams = getTextureFormatWebGL(framebuffer.colorAttachments[0].texture.props.format);
+    const sourceFormat = sourceParams.format;
     const sourceType = sourceParams.type;
     device.gl.bindBuffer(35051, webglBuffer.handle);
     prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle);
@@ -4324,7 +4201,7 @@ function _copyTextureToTexture(device, options) {
     width = Number.isFinite(width) ? width : texture.width;
     height = Number.isFinite(height) ? height : texture.height;
     texture.bind(0);
-    textureTarget = texture.target;
+    textureTarget = texture.glTarget;
   } else {
     throw new Error("invalid destination");
   }
@@ -4348,7 +4225,7 @@ function _copyTextureToTexture(device, options) {
   }
 }
 function getFramebuffer(source) {
-  if (source instanceof import_core19.Texture) {
+  if (source instanceof import_core16.Texture) {
     const { width, height, id } = source;
     const framebuffer = source.device.createFramebuffer({
       id: `framebuffer-for-${id}`,
@@ -4362,7 +4239,7 @@ function getFramebuffer(source) {
 }
 
 // dist/adapter/resources/webgl-command-encoder.js
-var WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
+var WEBGLCommandEncoder = class extends import_core17.CommandEncoder {
   device;
   commandBuffer;
   constructor(device, props) {
@@ -4401,10 +4278,33 @@ var WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
 };
 
 // dist/adapter/resources/webgl-vertex-array.js
-var import_core21 = require("@luma.gl/core");
-var import_constants23 = require("@luma.gl/constants");
+var import_core18 = require("@luma.gl/core");
+var import_constants24 = require("@luma.gl/constants");
 var import_env2 = require("@probe.gl/env");
-var WEBGLVertexArray = class extends import_core21.VertexArray {
+
+// dist/utils/fill-array.js
+function fillArray(options) {
+  const { target, source, start = 0, count = 1 } = options;
+  const length = source.length;
+  const total = count * length;
+  let copied = 0;
+  for (let i = start; copied < length; copied++) {
+    target[i++] = source[copied];
+  }
+  while (copied < total) {
+    if (copied < total - copied) {
+      target.copyWithin(start + copied, start, start + copied);
+      copied *= 2;
+    } else {
+      target.copyWithin(start + copied, start, start + total - copied);
+      copied = total;
+    }
+  }
+  return options.target;
+}
+
+// dist/adapter/resources/webgl-vertex-array.js
+var WEBGLVertexArray = class extends import_core18.VertexArray {
   get [Symbol.toStringTag]() {
     return "VertexArray";
   }
@@ -4464,6 +4364,7 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     } else {
       this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
     }
+    this.device.gl.bindBuffer(34962, null);
     this.device.gl.enableVertexAttribArray(location);
     this.device.gl.vertexAttribDivisor(location, divisor || 0);
     this.attributes[location] = buffer;
@@ -4570,8 +4471,8 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     this.buffer = this.buffer || this.device.createBuffer({ byteLength });
     updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
     if (updateNeeded) {
-      const typedArray = (0, import_core21.getScratchArray)(value.constructor, length);
-      (0, import_core21.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
+      const typedArray = (0, import_core18.getScratchArray)(value.constructor, length);
+      fillArray({ target: typedArray, source: constantValue, start: 0, count: length });
       this.buffer.write(typedArray);
       this.bufferValue = value;
     }
@@ -4597,9 +4498,9 @@ function compareConstantArrayValues(v1, v2) {
 }
 
 // dist/adapter/resources/webgl-transform-feedback.js
-var import_core22 = require("@luma.gl/core");
-var import_constants24 = require("@luma.gl/constants");
-var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
+var import_core19 = require("@luma.gl/core");
+var import_constants25 = require("@luma.gl/constants");
+var WEBGLTransformFeedback = class extends import_core19.TransformFeedback {
   device;
   gl;
   handle;
@@ -4642,7 +4543,7 @@ var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
   }
   end() {
     this.gl.endTransformFeedback();
-    if (!this.bindOnUse) {
+    if (this.bindOnUse) {
       this._unbindBuffers();
     }
     this.gl.bindTransformFeedback(36386, null);
@@ -4662,7 +4563,7 @@ var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
     const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
     if (location < 0) {
       this.unusedBuffers[locationOrName] = buffer;
-      import_core22.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+      import_core19.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
       return;
     }
     this.buffers[location] = { buffer, byteLength, byteOffset };
@@ -4749,9 +4650,9 @@ function isIndex(value) {
 }
 
 // dist/adapter/resources/webgl-query-set.js
-var import_core23 = require("@luma.gl/core");
-var import_constants25 = require("@luma.gl/constants");
-var WEBGLQuerySet = class extends import_core23.QuerySet {
+var import_core20 = require("@luma.gl/core");
+var import_constants26 = require("@luma.gl/constants");
+var WEBGLQuerySet = class extends import_core20.QuerySet {
   device;
   handle;
   target = null;
@@ -4879,12 +4780,11 @@ var WEBGLQuerySet = class extends import_core23.QuerySet {
 };
 
 // dist/classic/copy-and-blit.js
-var import_core25 = require("@luma.gl/core");
-var import_constants27 = require("@luma.gl/constants");
+var import_core21 = require("@luma.gl/core");
+var import_constants28 = require("@luma.gl/constants");
 
 // dist/classic/format-utils.js
-var import_core24 = require("@luma.gl/core");
-var import_constants26 = require("@luma.gl/constants");
+var import_constants27 = require("@luma.gl/constants");
 function glFormatToComponents(format) {
   switch (format) {
     case 6406:
@@ -4901,7 +4801,6 @@ function glFormatToComponents(format) {
     case 34836:
       return 4;
     default:
-      (0, import_core24.assert)(false);
       return 0;
   }
 }
@@ -4916,7 +4815,6 @@ function glTypeToBytes(type) {
     case 5126:
       return 4;
     default:
-      (0, import_core24.assert)(false);
       return 0;
   }
 }
@@ -4939,12 +4837,11 @@ function readPixelsToArray(source, options) {
     sourceType
   } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core25.assert)(framebuffer);
   const { gl, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   const attachment = sourceAttachment - 36064;
-  sourceType = sourceType || ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.type) || 5121;
+  sourceType = sourceType || ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.glType) || 5121;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
   const prevHandle = gl.bindFramebuffer(36160, handle);
@@ -4959,7 +4856,6 @@ function readPixelsToBuffer(source, options) {
   const { target, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {};
   let { sourceWidth, sourceHeight, sourceType } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core25.assert)(framebuffer);
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   const webglFramebuffer = framebuffer;
@@ -4987,7 +4883,7 @@ function readPixelsToBuffer(source, options) {
   return webglBufferTarget;
 }
 function getFramebuffer2(source) {
-  if (!(source instanceof import_core25.Framebuffer)) {
+  if (!(source instanceof import_core21.Framebuffer)) {
     return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
   }
   return { framebuffer: source, deleteFramebuffer: false };
@@ -5014,11 +4910,9 @@ function getPixelArray(pixelArray, type, format, width, height) {
 }
 
 // dist/classic/clear.js
-var import_core26 = require("@luma.gl/core");
 var GL_DEPTH_BUFFER_BIT2 = 256;
 var GL_STENCIL_BUFFER_BIT2 = 1024;
 var GL_COLOR_BUFFER_BIT2 = 16384;
-var ERR_ARGUMENTS = "clear: bad arguments";
 function clear(device, options) {
   const { framebuffer = null, color = null, depth = null, stencil = null } = options || {};
   const parameters = {};
@@ -5044,7 +4938,6 @@ function clear(device, options) {
       parameters.clearStencil = depth;
     }
   }
-  (0, import_core26.assert)(clearFlags !== 0, ERR_ARGUMENTS);
   const gl = device.gl;
   withGLParameters(gl, parameters, () => {
     gl.clear(clearFlags);
@@ -5053,7 +4946,7 @@ function clear(device, options) {
 
 // dist/adapter/webgl-device.js
 var LOG_LEVEL2 = 1;
-var _WebGLDevice = class extends import_core27.Device {
+var _WebGLDevice = class extends import_core22.Device {
   /** type of this device */
   type = "webgl";
   /** The underlying WebGL context */
@@ -5081,7 +4974,7 @@ var _WebGLDevice = class extends import_core27.Device {
     if (gl instanceof _WebGLDevice) {
       return gl;
     }
-    if ((gl == null ? void 0 : gl.device) instanceof import_core27.Device) {
+    if ((gl == null ? void 0 : gl.device) instanceof import_core22.Device) {
       return gl.device;
     }
     if (!isWebGL(gl)) {
@@ -5091,7 +4984,7 @@ var _WebGLDevice = class extends import_core27.Device {
   }
   static async create(props = {}) {
     var _a;
-    import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+    import_core22.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
     const promises = [];
     if (props.debug) {
       promises.push(loadWebGLDeveloperTools());
@@ -5100,24 +4993,24 @@ var _WebGLDevice = class extends import_core27.Device {
       promises.push(loadSpectorJS());
     }
     if (typeof props.canvas === "string") {
-      promises.push(import_core27.CanvasContext.pageLoaded);
+      promises.push(import_core22.CanvasContext.pageLoaded);
     }
     const results = await Promise.allSettled(promises);
     for (const result of results) {
       if (result.status === "rejected") {
-        import_core27.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+        import_core22.log.error(`Failed to initialize debug libraries ${result.reason}`)();
       }
     }
-    import_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+    import_core22.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
     if ((_a = props.gl) == null ? void 0 : _a.device) {
-      import_core27.log.warn("reattaching existing device")();
+      import_core22.log.warn("reattaching existing device")();
       return _WebGLDevice.attach(props.gl);
     }
     const device = new _WebGLDevice(props);
     const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-    import_core27.log.probe(LOG_LEVEL2, message2)();
-    import_core27.log.table(LOG_LEVEL2, device.info)();
-    import_core27.log.groupEnd(LOG_LEVEL2)();
+    import_core22.log.probe(LOG_LEVEL2, message2)();
+    import_core22.log.table(LOG_LEVEL2, device.info)();
+    import_core22.log.groupEnd(LOG_LEVEL2)();
     return device;
   }
   //
@@ -5125,7 +5018,7 @@ var _WebGLDevice = class extends import_core27.Device {
   //
   constructor(props) {
     var _a, _b;
-    super({ ...props, id: props.id || (0, import_core27.uid)("webgl-device") });
+    super({ ...props, id: props.id || "webgl-device" });
     const device = (_a = props.gl) == null ? void 0 : _a.device;
     if (device) {
       throw new Error(`WebGL context already attached to device ${device.id}`);
@@ -5164,13 +5057,13 @@ var _WebGLDevice = class extends import_core27.Device {
     trackContextState(this.gl, {
       enable: enable2,
       copyState,
-      log: (...args) => import_core27.log.log(1, ...args)()
+      log: (...args) => import_core22.log.log(1, ...args)()
     });
     if (props.debug) {
       this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
       this.debug = true;
-      import_core27.log.level = Math.max(import_core27.log.level, 1);
-      import_core27.log.warn("WebGL debug mode activated. Performance reduced.")();
+      import_core22.log.level = Math.max(import_core22.log.level, 1);
+      import_core22.log.warn("WebGL debug mode activated. Performance reduced.")();
     }
     if (props.spector) {
       this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
@@ -5205,6 +5098,7 @@ var _WebGLDevice = class extends import_core27.Device {
     const newProps = this._getBufferProps(props);
     return new WEBGLBuffer(this, newProps);
   }
+  // _createTexture(props: TextureProps): WEBGLTexture {
   _createTexture(props) {
     return new WEBGLTexture(this, props);
   }
@@ -5242,7 +5136,7 @@ var _WebGLDevice = class extends import_core27.Device {
     throw new Error("ComputePass not supported in WebGL");
   }
   renderPass = null;
-  createCommandEncoder(props) {
+  createCommandEncoder(props = {}) {
     return new WEBGLCommandEncoder(this, props);
   }
   /**
@@ -5279,7 +5173,7 @@ var _WebGLDevice = class extends import_core27.Device {
     clear(this, options);
   }
   resetWebGL() {
-    import_core27.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
+    import_core22.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
     resetGLParameters(this.gl);
   }
   //
@@ -5357,7 +5251,7 @@ var _WebGLDevice = class extends import_core27.Device {
     this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
     const currentConstant = this._constants[location];
     if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-      import_core27.log.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)();
+      import_core22.log.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)();
     }
     this._constants[location] = constant;
     switch (constant.constructor) {
@@ -5371,7 +5265,7 @@ var _WebGLDevice = class extends import_core27.Device {
         setConstantUintArray(this, location, constant);
         break;
       default:
-        (0, import_core27.assert)(false);
+        throw new Error("constant");
     }
   }
   /** Ensure extensions are only requested once */
@@ -5407,7 +5301,6 @@ function setConstantFloatArray(device, location, array) {
       device.gl.vertexAttrib4fv(location, array);
       break;
     default:
-      (0, import_core27.assert)(false);
   }
 }
 function setConstantIntArray(device, location, array) {
@@ -5427,174 +5320,4 @@ function compareConstantArrayValues2(v1, v2) {
   }
   return true;
 }
-
-// dist/adapter/objects/webgl-resource.js
-var import_core28 = require("@luma.gl/core");
-var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
-var WebGLResource = class extends import_core28.Resource {
-  device;
-  gl;
-  gl2;
-  _handle;
-  _bound = false;
-  // Only meaningful for resources that allocate GPU memory
-  byteLength = 0;
-  constructor(device, props, defaultProps) {
-    super(device, props, defaultProps);
-    this.device = device;
-    const gl = this.device.gl;
-    const { id } = props || {};
-    this.gl = gl;
-    this.gl2 = gl;
-    this.id = id || (0, import_core28.uid)(this.constructor.name);
-    this._handle = props == null ? void 0 : props.handle;
-    if (this._handle === void 0) {
-      this._handle = this._createHandle();
-    }
-    this.byteLength = 0;
-  }
-  toString() {
-    return `${this.constructor.name}(${this.id})`;
-  }
-  get handle() {
-    return this._handle;
-  }
-  delete({ deleteChildren = false } = {}) {
-    const children = this._handle && this._deleteHandle(this._handle);
-    if (this._handle) {
-      this.removeStats();
-    }
-    this._handle = null;
-    if (children && deleteChildren) {
-      children.filter(Boolean).forEach((child) => child.destroy());
-    }
-    return this;
-  }
-  bind(funcOrHandle = this.handle) {
-    if (typeof funcOrHandle !== "function") {
-      this._bindHandle(funcOrHandle);
-      return this;
-    }
-    let value;
-    if (!this._bound) {
-      this._bindHandle(this.handle);
-      this._bound = true;
-      value = funcOrHandle();
-      this._bound = false;
-      this._bindHandle(null);
-    } else {
-      value = funcOrHandle();
-    }
-    return value;
-  }
-  unbind() {
-    this.bind(null);
-  }
-  // Install stubs for removed methods
-  stubRemovedMethods(className, version, methodNames) {
-    return (0, import_core28.stubRemovedMethods)(this, className, version, methodNames);
-  }
-  // PUBLIC VIRTUAL METHODS
-  initialize(props) {
-  }
-  // PROTECTED METHODS - These must be overridden by subclass
-  _createHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _deleteHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _bindHandle(handle) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _getOptsFromHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _getParameter(pname, props) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _setParameter(pname, value) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-};
-
-// dist/adapter/objects/webgl-renderbuffer.js
-var import_core29 = require("@luma.gl/core");
-var import_constants28 = require("@luma.gl/constants");
-var _WEBGLRenderbuffer = class extends WebGLResource {
-  get [Symbol.toStringTag]() {
-    return "Renderbuffer";
-  }
-  get width() {
-    return this.props.width;
-  }
-  get height() {
-    return this.props.height;
-  }
-  get format() {
-    return this.props.format;
-  }
-  get samples() {
-    return this.props.samples;
-  }
-  get attachment() {
-    return;
-  }
-  /** WebGL format constant */
-  glFormat;
-  static isTextureFormatSupported(device, format) {
-    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
-  }
-  constructor(device, props) {
-    if (typeof props.format === "number") {
-      throw new Error("Renderbuffer");
-    }
-    super(device, props, _WEBGLRenderbuffer.defaultProps);
-    this.glFormat = convertTextureFormatToGL(this.props.format);
-    this._initialize(this.props);
-  }
-  resize(size) {
-    if (size.width !== this.width || size.height !== this.height) {
-      Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
-      this._initialize(this.props);
-    }
-  }
-  // PRIVATE METHODS
-  /** Creates and initializes a renderbuffer object's data store */
-  _initialize(props) {
-    const { format, width, height, samples } = props;
-    (0, import_core29.assert)(format, "Needs format");
-    this.trackDeallocatedMemory();
-    this.gl.bindRenderbuffer(36161, this.handle);
-    if (samples !== 0) {
-      this.gl.renderbufferStorageMultisample(36161, samples, this.glFormat, width, height);
-    } else {
-      this.gl.renderbufferStorage(36161, this.glFormat, width, height);
-    }
-    this.gl.bindRenderbuffer(36161, null);
-    this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format));
-  }
-  // RESOURCE IMPLEMENTATION
-  _createHandle() {
-    return this.gl.createRenderbuffer();
-  }
-  _deleteHandle() {
-    this.gl.deleteRenderbuffer(this.handle);
-    this.trackDeallocatedMemory();
-  }
-  _bindHandle(handle) {
-    this.gl.bindRenderbuffer(36161, handle);
-  }
-};
-var WEBGLRenderbuffer = _WEBGLRenderbuffer;
-__publicField(WEBGLRenderbuffer, "defaultProps", {
-  id: void 0,
-  handle: void 0,
-  userData: void 0,
-  format: void 0,
-  // 'depth16unorm'
-  width: 1,
-  height: 1,
-  samples: 0
-});
 //# sourceMappingURL=index.cjs.map