@luma.gl/webgl 9.0.17 → 9.1.0-alpha.10

package/dist/index.cjs

@@ -2,7 +2,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,10 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 
 // dist/index.js
 var dist_exports = {};
@@ -30,7 +25,6 @@ __export(dist_exports, {
   WEBGLFramebuffer: () => WEBGLFramebuffer,
   WEBGLRenderPass: () => WEBGLRenderPass,
   WEBGLRenderPipeline: () => WEBGLRenderPipeline,
-  WEBGLResource: () => WebGLResource,
   WEBGLSampler: () => WEBGLSampler,
   WEBGLShader: () => WEBGLShader,
   WEBGLTexture: () => WEBGLTexture,
@@ -38,28 +32,24 @@ __export(dist_exports, {
   WEBGLVertexArray: () => WEBGLVertexArray,
   WebGLCanvasContext: () => WebGLCanvasContext,
   WebGLDevice: () => WebGLDevice,
-  WebGLResource: () => WebGLResource,
+  WebGLStateTracker: () => WebGLStateTracker,
   _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
-  _WEBGLRenderbuffer: () => WEBGLRenderbuffer,
-  convertGLToTextureFormat: () => convertGLToTextureFormat,
   getGLParameters: () => getGLParameters,
   getShaderLayout: () => getShaderLayout,
-  popContextState: () => popContextState,
-  pushContextState: () => pushContextState,
   resetGLParameters: () => resetGLParameters,
   setDeviceParameters: () => setDeviceParameters,
   setGLParameters: () => setGLParameters,
-  trackContextState: () => trackContextState,
+  webgl2Adapter: () => webgl2Adapter,
   withDeviceParameters: () => withDeviceParameters,
   withGLParameters: () => withGLParameters
 });
 module.exports = __toCommonJS(dist_exports);
 
-// dist/adapter/webgl-device.js
-var import_core27 = require("@luma.gl/core");
+// dist/adapter/webgl-adapter.js
+var import_core23 = require("@luma.gl/core");
 
-// dist/context/state-tracker/track-context-state.js
-var import_core = require("@luma.gl/core");
+// dist/adapter/webgl-device.js
+var import_core22 = require("@luma.gl/core");
 
 // dist/context/parameters/webgl-parameter-tables.js
 var import_constants = require("@luma.gl/constants");
@@ -295,7 +285,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),
@@ -601,24 +591,22 @@ function deepArrayEqual(x, y) {
   return false;
 }
 
-// dist/context/state-tracker/track-context-state.js
-var GLState = class {
+// dist/context/state-tracker/webgl-state-tracker.js
+var WebGLStateTracker = class {
+  static get(gl) {
+    return gl.state;
+  }
   gl;
   program = null;
   stateStack = [];
   enable = true;
-  cache;
+  cache = null;
   log;
-  constructor(gl, {
-    copyState = false,
-    // Copy cache from params (slow) or initialize from WebGL defaults (fast)
-    log: log9 = () => {
-    }
-    // Logging function, called when gl parameter change calls are actually issued
-  } = {}) {
+  initialized = false;
+  constructor(gl, props) {
     this.gl = gl;
-    this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
-    this.log = log9;
+    this.log = (props == null ? void 0 : props.log) || (() => {
+    });
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
   }
@@ -626,11 +614,33 @@ 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();
   }
+  /**
+   * Initialize WebGL state caching on a context
+   * can be called multiple times to enable/disable
+   *
+   * @note After calling this function, context state will be cached
+   * .push() and .pop() will be available for saving,
+   * temporarily modifying, and then restoring state.
+   */
+  trackState(gl, options) {
+    this.cache = options.copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+    if (this.initialized) {
+      throw new Error("WebGLStateTracker");
+    }
+    this.initialized = true;
+    this.gl.state = this;
+    installProgramSpy(gl);
+    for (const key in GL_HOOKED_SETTERS) {
+      const setter = GL_HOOKED_SETTERS[key];
+      installSetterSpy(gl, key, setter);
+    }
+    installGetterOverride(gl, "getParameter");
+    installGetterOverride(gl, "isEnabled");
+  }
   /**
   // interceptor for context set functions - update our cache and our stack
   // values (Object) - the key values for this setter
@@ -642,7 +652,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)) {
@@ -657,46 +666,13 @@ var GLState = class {
     return { valueChanged, oldValue };
   }
 };
-function getContextState(gl) {
-  return gl.state;
-}
-function trackContextState(gl, options) {
-  const { enable: enable2 = true, copyState } = options;
-  (0, import_core.assert)(copyState !== void 0);
-  if (!gl.state) {
-    gl.state = new GLState(gl, { copyState });
-    installProgramSpy(gl);
-    for (const key in GL_HOOKED_SETTERS) {
-      const setter = GL_HOOKED_SETTERS[key];
-      installSetterSpy(gl, key, setter);
-    }
-    installGetterOverride(gl, "getParameter");
-    installGetterOverride(gl, "isEnabled");
-  }
-  const glState = getContextState(gl);
-  glState.enable = enable2;
-  return gl;
-}
-function pushContextState(gl) {
-  let glState = getContextState(gl);
-  if (!glState) {
-    trackContextState(gl, { copyState: false });
-    glState = getContextState(gl);
-  }
-  glState.push();
-}
-function popContextState(gl) {
-  const glState = getContextState(gl);
-  (0, import_core.assert)(glState);
-  glState.pop();
-}
 function installGetterOverride(gl, functionName) {
   const originalGetterFunc = gl[functionName].bind(gl);
   gl[functionName] = function get(pname) {
     if (pname === void 0 || NON_CACHE_PARAMETERS.has(pname)) {
       return originalGetterFunc(pname);
     }
-    const glState = getContextState(gl);
+    const glState = WebGLStateTracker.get(gl);
     if (!(pname in glState.cache)) {
       glState.cache[pname] = originalGetterFunc(pname);
     }
@@ -719,7 +695,7 @@ function installSetterSpy(gl, functionName, setter) {
   }
   const originalSetterFunc = gl[functionName].bind(gl);
   gl[functionName] = function set(...params) {
-    const glState = getContextState(gl);
+    const glState = WebGLStateTracker.get(gl);
     const { valueChanged, oldValue } = setter(glState._updateCache, ...params);
     if (valueChanged) {
       originalSetterFunc(...params);
@@ -734,7 +710,7 @@ function installSetterSpy(gl, functionName, setter) {
 function installProgramSpy(gl) {
   const originalUseProgram = gl.useProgram.bind(gl);
   gl.useProgram = function useProgramLuma(handle) {
-    const glState = getContextState(gl);
+    const glState = WebGLStateTracker.get(gl);
     if (glState.program !== handle) {
       originalUseProgram(handle);
       glState.program = handle;
@@ -857,10 +833,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
@@ -952,26 +928,6 @@ function checkTextureFeature(gl, feature, extensions) {
   return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions));
 }
 var TEXTURE_FORMATS = {
-  // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants
-  "rgb8unorm-unsized": {
-    gl: 6407,
-    b: 4,
-    c: 2,
-    bpp: 4,
-    dataFormat: 6407,
-    types: [5121, 33635]
-  },
-  "rgba8unorm-unsized": {
-    gl: 6408,
-    b: 4,
-    c: 2,
-    bpp: 4,
-    dataFormat: 6408,
-    types: [5121, 32819, 32820]
-  },
-  // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
-  // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
-  // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 8-bit formats
   "r8unorm": { gl: 33321, b: 1, c: 1, rb: true },
   "r8snorm": { gl: 36756, b: 1, c: 1, render: snorm8_renderable },
@@ -1005,7 +961,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 },
@@ -1087,17 +1042,6 @@ var TEXTURE_FORMATS = {
     dataFormat: 34041,
     types: [34042]
   },
-  // "depth24unorm-stencil8" feature
-  "depth24unorm-stencil8": {
-    gl: 35056,
-    b: 4,
-    c: 2,
-    p: 1,
-    attachment: 33306,
-    dataFormat: 34041,
-    types: [34042],
-    rb: true
-  },
   // "depth32float-stencil8" feature - TODO below is render buffer only?
   "depth32float-stencil8": {
     gl: 36013,
@@ -1179,31 +1123,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) {
@@ -1212,34 +1131,16 @@ function isTextureFormatSupported(gl, format, extensions) {
   if (info.gl === void 0) {
     return false;
   }
+  const feature = info.f;
+  if (feature) {
+    return checkTextureFeature(gl, feature, extensions);
+  }
   const extension = info.x || info.gl2ext;
   if (extension) {
     return Boolean(getWebGLExtension(gl, extension, 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 +1149,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,18 +1173,17 @@ 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.channels, 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
-    compressed: decoded.compressed
+    compressed: decoded.compressed || false
   };
 }
 function getDepthStencilAttachmentWebGL(format) {
@@ -1293,17 +1193,11 @@ 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) {
+function getWebGLPixelDataFormat(channels, integer, normalized, format) {
   if (format === 6408 || format === 6407) {
     return format;
   }
-  switch (dataFormat) {
+  switch (channels) {
     case "r":
       return integer && !normalized ? 36244 : 6403;
     case "rg":
@@ -1312,10 +1206,20 @@ function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
       return integer && !normalized ? 36248 : 6407;
     case "rgba":
       return integer && !normalized ? 36249 : 6408;
+    case "bgra":
+      throw new Error("bgra pixels not supported by WebGL");
     default:
       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 = {
@@ -1325,7 +1229,6 @@ var WEBGL_FEATURES = {
   // 'timestamp-query' // GPUQueryType "timestamp-query"
   // "indirect-first-instance"
   // Textures are handled by getTextureFeatures()
-  // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8'
   // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
   // optional WebGL features
   "timer-query-webgl": "EXT_disjoint_timer_query_webgl2",
@@ -1337,7 +1240,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 +1260,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 +1295,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 +1401,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
@@ -1518,17 +1422,18 @@ function withGLParameters(gl, parameters, func) {
     return func(gl);
   }
   const { nocatch = true } = parameters;
-  pushContextState(gl);
+  const webglState = WebGLStateTracker.get(gl);
+  webglState.push();
   setGLParameters(gl, parameters);
   let value;
   if (nocatch) {
     value = func(gl);
-    popContextState(gl);
+    webglState.pop();
   } else {
     try {
       value = func(gl);
     } finally {
-      popContextState(gl);
+      webglState.pop();
     }
   }
   return value;
@@ -1544,32 +1449,33 @@ 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;
-  pushContextState(webglDevice.gl);
+  webglDevice.pushState();
   try {
     setDeviceParameters(device, parameters);
     setGLParameters(webglDevice.gl, glParameters);
     return func(device);
   } finally {
-    popContextState(webglDevice.gl);
+    webglDevice.popState();
   }
 }
 function withDeviceParameters(device, parameters, func) {
-  if ((0, import_core5.isObjectEmpty)(parameters)) {
+  if (isObjectEmpty3(parameters)) {
     return func(device);
   }
-  pushContextState(device.gl);
+  const webglDevice = device;
+  webglDevice.pushState();
   try {
     setDeviceParameters(device, parameters);
     return func(device);
   } finally {
-    popContextState(device.gl);
+    webglDevice.popState();
   }
 }
 function setDeviceParameters(device, parameters) {
@@ -1672,7 +1578,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;
@@ -1688,8 +1594,16 @@ function setDeviceParameters(device, parameters) {
     gl.stencilOpSeparate(1028, sfail, dpfail, dppass);
     gl.stencilOpSeparate(1029, sfail, dpfail, dppass);
   }
+  switch (parameters.blend) {
+    case true:
+      gl.enable(3042);
+      break;
+    case false:
+      gl.disable(3042);
+      break;
+    default:
+  }
   if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
-    gl.enable(3042);
     const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add");
     const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add");
     gl.blendEquationSeparate(colorEquation, alphaEquation);
@@ -1764,6 +1678,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 +1752,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 +1793,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 +1809,253 @@ var WEBGLTextureView = class extends import_core8.TextureView {
   }
 };
 
-// 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 {
-  MAX_ATTRIBUTES;
-  device;
-  gl;
-  handle;
-  // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
-  sampler = void 0;
-  view = void 0;
-  // data;
-  glFormat = void 0;
-  type = void 0;
-  dataFormat = void 0;
-  mipmaps = void 0;
-  /**
-   * @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.
-   * 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;
-  constructor(device, props) {
-    var _a;
-    super(device, { ...DEFAULT_WEBGL_TEXTURE_PROPS, format: "rgba8unorm", ...props });
-    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.initialize(this.props);
-    Object.seal(this);
+// 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);
   }
-  destroy() {
-    if (this.handle) {
-      this.gl.deleteTexture(this.handle);
-      this.removeStats();
-      this.trackDeallocatedMemory("Texture");
-      this.destroyed = true;
-    }
+}
+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 = getWebGLCubeFaceTarget(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);
   }
-  toString() {
-    return `Texture(${this.id},${this.width}x${this.height})`;
+}
+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 = getWebGLCubeFaceTarget(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);
   }
-  createView(props) {
-    return new WEBGLTextureView(this.device, { ...props, texture: this });
+}
+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;
   }
-  // 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) {
+  throw new Error(dimension);
+}
+function getWebGLCubeFaceTarget(glTarget, dimension, level) {
+  return dimension === "cube" ? 34069 + level : glTarget;
+}
+
+// dist/adapter/resources/webgl-texture.js
+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;
+  sampler = void 0;
+  // TODO - currently unused in WebGL. Create dummy sampler?
+  view = 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,
+   * 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
+   */
+  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) {
+    super(device, { ...import_core7.Texture.defaultProps, ...props, data: void 0 });
+    this.device = device;
+    this.gl = this.device.gl;
+    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;
-      data.addEventListener("loadeddata", () => this.initialize(props));
-      return this;
+      video.addEventListener("loadeddata", () => this.initialize(props));
     }
-    const { parameters = {} } = props;
-    const { pixels = null, pixelStore = {}, textureUnit = void 0, mipmaps = true } = props;
-    if (!data) {
-      data = pixels;
+    this.initialize({ ...this.props, data: props.data });
+    Object.seal(this);
+  }
+  /**
+   * Initialize texture with supplied props
+   */
+  // eslint-disable-next-line max-statements
+  initialize(props = {}) {
+    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 = import_core7.Texture.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 +2068,102 @@ 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
+  copyExternalImage(options) {
+    const size = import_core7.Texture.getExternalImageSize(options.image);
+    const opts = { ...import_core7.Texture.defaultCopyExternalImageOptions, ...size, ...options };
+    const { depth, mipLevel: lodLevel, image } = opts;
+    this.bind();
+    this._setMipLevel(depth, lodLevel, image);
+    this.unbind();
+    return { width: opts.width, height: opts.height };
+  }
+  setTexture1DData(data) {
+    throw new Error("setTexture1DData not supported in WebGL.");
+  }
+  /** Set a simple texture */
+  setTexture2DData(lodData, depth = 0) {
+    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;
-    }
-    if (data && data.data) {
-      const ndarray = data;
-      data = ndarray.data;
-      width = ndarray.shape[0];
-      height = ndarray.shape[1];
+  setTexture3DData(data) {
+    if (this.props.dimension !== "3d") {
+      throw new Error(this.id);
     }
-    if (data instanceof WEBGLBuffer) {
-      data = data.handle;
+    if (ArrayBuffer.isView(data)) {
+      this.bind();
+      copyCPUDataToMipLevel(this.device.gl, data, this);
+      this.unbind();
     }
-    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);
+    for (const face of import_core7.Texture.CubeFaces) {
+      this.setTextureCubeFaceData(data[face], face);
     }
-    gl.bindTexture(this.target, null);
-    return textureUnit;
   }
-  // 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 };
+  /**
+   * Sets an entire texture array
+   * @param data
+   */
+  setTextureArrayData(data) {
+    if (this.props.dimension !== "2d-array") {
+      throw new Error(this.id);
     }
-    (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;
+    throw new Error("setTextureArrayData not implemented.");
   }
-  // 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]);
-    }));
-    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();
+  /**
+   * Sets an entire texture cube array
+   * @param data
+   */
+  setTextureCubeArrayData(data) {
+    throw new Error("setTextureCubeArrayData not supported in WebGL2.");
+  }
+  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.`)();
+    }
+    const faceDepth = import_core7.Texture.CubeFaces.indexOf(face);
+    this.setTexture2DData(lodData, faceDepth);
   }
+  // INTERNAL METHODS
   /** @todo update this method to accept LODs */
   setImageDataForFace(options) {
     const {
@@ -2502,121 +2190,158 @@ 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
-        );
+  _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 instanceof WEBGLBuffer) {
-        this.gl.bindBuffer(35052, data.handle);
-        this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, 0, format, type, offset);
-      }
-    });
-    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, glTarget = this.glTarget) {
+    if (import_core7.Texture.isExternalImage(textureData)) {
+      copyCPUImageToMipLevel(this.device.gl, textureData, { ...this, depth, level, glTarget });
+      return;
+    }
+    if (import_core7.Texture.isTextureLevelData(textureData)) {
+      copyCPUDataToMipLevel(this.device.gl, textureData.data, {
+        ...this,
+        depth,
+        level,
+        glTarget
+      });
+      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 +2356,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 +2390,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.handle, level, layer);
         break;
       case 34067:
         const face = mapIndexToCubeMapFace(layer);
@@ -2736,9 +2448,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 +2476,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,31 +2529,58 @@ var WebGLCanvasContext = class extends import_core11.CanvasContext {
 };
 
 // dist/context/debug/spector.js
-var import_core12 = require("@luma.gl/core");
-var DEFAULT_SPECTOR_PROPS = {
-  spector: import_core12.log.get("spector") || import_core12.log.get("spectorjs")
-};
-var SPECTOR_CDN_URL = "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js";
+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 LOG_LEVEL = 1;
 var spector = null;
 var initialized = false;
+var DEFAULT_SPECTOR_PROPS = {
+  debugWithSpectorJS: import_core10.log.get("spector") || import_core10.log.get("spectorjs"),
+  // https://github.com/BabylonJS/Spector.js#basic-usage
+  // https://forum.babylonjs.com/t/spectorcdn-is-temporarily-off/48241
+  // spectorUrl: 'https://spectorcdn.babylonjs.com/spector.bundle.js';
+  spectorUrl: "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js",
+  gl: void 0
+};
 async function loadSpectorJS(props) {
   if (!globalThis.SPECTOR) {
     try {
-      await (0, import_core12.loadScript)(SPECTOR_CDN_URL);
+      await loadScript(props.spectorUrl || DEFAULT_SPECTOR_PROPS.spectorUrl);
     } catch (error) {
-      import_core12.log.warn(String(error));
+      import_core10.log.warn(String(error));
     }
   }
 }
 function initializeSpectorJS(props) {
+  var _a;
   props = { ...DEFAULT_SPECTOR_PROPS, ...props };
-  if (!(props == null ? void 0 : props.spector)) {
+  if (!props.debugWithSpectorJS) {
     return null;
   }
-  if (!spector && globalThis.SPECTOR) {
-    import_core12.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
-    spector = new globalThis.SPECTOR.Spector();
+  if (!spector && globalThis.SPECTOR && !((_a = globalThis.luma) == null ? void 0 : _a.spector)) {
+    import_core10.log.probe(LOG_LEVEL, "SPECTOR found and initialized. Start with `luma.spector.displayUI()`")();
+    const { Spector } = globalThis.SPECTOR;
+    spector = new Spector();
     if (globalThis.luma) {
       globalThis.luma.spector = spector;
     }
@@ -2850,21 +2591,21 @@ 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);
     });
   }
-  if (props == null ? void 0 : props.canvas) {
-    if (typeof props.spector === "string" && props.spector !== props.canvas.id) {
-      return spector;
-    }
-    spector == null ? void 0 : spector.startCapture(props == null ? void 0 : props.canvas, 500);
+  if (props.gl) {
+    const gl = props.gl;
+    const device = gl.device;
+    spector == null ? void 0 : spector.startCapture(props.gl, 500);
+    gl.device = device;
     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 +2613,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,13 +2625,10 @@ 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 = {}) {
-  if (!gl) {
-    return null;
-  }
   return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
 }
 function getRealContext(gl) {
@@ -2899,7 +2637,7 @@ function getRealContext(gl) {
 }
 function getDebugContext(gl, props) {
   if (!globalThis.WebGLDebugUtils) {
-    import_core13.log.warn("webgl-debug not loaded")();
+    import_core11.log.warn("webgl-debug not loaded")();
     return gl;
   }
   const data = getWebGLContextData(gl);
@@ -2934,7 +2672,7 @@ function onGLError(props, err, functionName, args) {
   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)();
+  import_core11.log.error(message2)();
   debugger;
   if (props.throwOnError) {
     throw new Error(message2);
@@ -2942,9 +2680,9 @@ function onGLError(props, err, functionName, args) {
 }
 function onValidateGLFunc(props, functionName, functionArgs) {
   let functionString = "";
-  if (import_core13.log.level >= 1) {
+  if (import_core11.log.level >= 1) {
     functionString = getFunctionString(functionName, functionArgs);
-    import_core13.log.log(1, functionString)();
+    import_core11.log.log(1, functionString)();
   }
   if (props.break && props.break.length > 0) {
     functionString = functionString || getFunctionString(functionName, functionArgs);
@@ -2959,16 +2697,149 @@ function onValidateGLFunc(props, functionName, functionArgs) {
       if (props.throwOnError) {
         throw new Error(`Undefined argument: ${functionString}`);
       } else {
-        import_core13.log.error(`Undefined argument: ${functionString}`)();
+        import_core11.log.error(`Undefined argument: ${functionString}`)();
         debugger;
       }
     }
   }
 }
 
-// dist/adapter/resources/webgl-shader.js
-var import_core14 = require("@luma.gl/core");
+// dist/utils/uid.js
+var uidCounters = {};
+function uid(id = "id") {
+  uidCounters[id] = uidCounters[id] || 1;
+  const count = uidCounters[id]++;
+  return `${id}-${count}`;
+}
+
+// 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;
+    }
+  }
+  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_core12.Buffer.INDEX) {
+    return 34963;
+  }
+  if (usage & import_core12.Buffer.VERTEX) {
+    return 34962;
+  }
+  if (usage & import_core12.Buffer.UNIFORM) {
+    return 35345;
+  }
+  return 34962;
+}
+function getWebGLUsage(usage) {
+  if (usage & import_core12.Buffer.INDEX) {
+    return 35044;
+  }
+  if (usage & import_core12.Buffer.VERTEX) {
+    return 35044;
+  }
+  if (usage & import_core12.Buffer.UNIFORM) {
+    return 35048;
+  }
+  return 35044;
+}
+
+// dist/adapter/resources/webgl-shader.js
+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 +2886,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) {
@@ -3045,24 +2916,24 @@ var WEBGLShader = class extends import_core14.Shader {
     return this.getCompilationInfoSync();
   }
   getCompilationInfoSync() {
-    const log9 = this.device.gl.getShaderInfoLog(this.handle);
-    return parseShaderCompilerLog(log9);
+    const log10 = this.device.gl.getShaderInfoLog(this.handle);
+    return log10 ? parseShaderCompilerLog(log10) : [];
   }
   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 */
   async _compile(source) {
-    const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100
+    const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 300 es
 ${source2}`;
     source = addGLSLVersion(source);
     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 +2945,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,26 +2979,37 @@ ${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;
   constructor(device, props) {
+    var _a;
     super(device, props);
     this.device = device;
-    pushContextState(this.device.gl);
-    this.setParameters(this.props.parameters);
+    let viewport;
+    if (!((_a = props == null ? void 0 : props.parameters) == null ? void 0 : _a.viewport)) {
+      if (props == null ? void 0 : props.framebuffer) {
+        const { width, height } = props.framebuffer;
+        viewport = [0, 0, width, height];
+      } else {
+        const [width, height] = device.getCanvasContext().getDrawingBufferSize();
+        viewport = [0, 0, width, height];
+      }
+    }
+    this.device.pushState();
+    this.setParameters({ viewport, ...this.props.parameters });
     this.clear();
   }
   end() {
-    popContextState(this.device.gl);
+    this.device.popState();
   }
   pushDebugGroup(groupLabel) {
   }
@@ -3143,9 +3025,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 +3111,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 +3181,6 @@ var DEFAULT_ACCESSOR_VALUES = {
   normalized: false,
   integer: false
 };
-var PROP_CHECKS = {
-  deprecatedProps: {
-    instanced: "divisor",
-    isInstanced: "divisor"
-  }
-};
 var Accessor = class {
   offset;
   stride;
@@ -3324,7 +3196,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 +3224,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 +3290,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 +3583,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 +3668,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 +3696,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 +3712,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 +3723,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 +3748,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 +3777,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(`No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
         }
         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 +3796,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 +3829,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 +3870,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 +3883,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 +3962,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 +4023,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 +4054,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 +4104,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 +4158,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 +4211,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 +4235,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 +4249,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 +4288,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";
   }
@@ -4571,8 +4481,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;
     }
@@ -4598,9 +4508,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;
@@ -4663,7 +4573,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 };
@@ -4750,9 +4660,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;
@@ -4880,12 +4790,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:
@@ -4902,7 +4811,6 @@ function glFormatToComponents(format) {
     case 34836:
       return 4;
     default:
-      (0, import_core24.assert)(false);
       return 0;
   }
 }
@@ -4917,18 +4825,16 @@ function glTypeToBytes(type) {
     case 5126:
       return 4;
     default:
-      (0, import_core24.assert)(false);
       return 0;
   }
 }
 
 // dist/classic/copy-and-blit.js
 function readPixelsToArray(source, options) {
-  var _a, _b;
+  var _a, _b, _c, _d, _e, _f;
   const {
     sourceX = 0,
     sourceY = 0,
-    sourceFormat = 6408,
     sourceAttachment = 36064
     // TODO - support gl.readBuffer
   } = options || {};
@@ -4937,16 +4843,19 @@ function readPixelsToArray(source, options) {
     // following parameters are auto deduced if not provided
     sourceWidth,
     sourceHeight,
+    sourceDepth,
+    sourceFormat,
     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;
-  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
+  sourceWidth ||= framebuffer.width;
+  sourceHeight ||= framebuffer.height;
+  sourceDepth = ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.depth) || 1;
+  sourceFormat ||= ((_d = (_c = framebuffer.colorAttachments[attachment]) == null ? void 0 : _c.texture) == null ? void 0 : _d.glFormat) || 6408;
+  sourceType ||= ((_f = (_e = framebuffer.colorAttachments[attachment]) == null ? void 0 : _e.texture) == null ? void 0 : _f.glType) || 5121;
+  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
   const prevHandle = gl.bindFramebuffer(36160, handle);
   gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
@@ -4960,7 +4869,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;
@@ -4988,7 +4896,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 };
@@ -5004,7 +4912,7 @@ function toFramebuffer(texture, props) {
   });
   return framebuffer;
 }
-function getPixelArray(pixelArray, type, format, width, height) {
+function getPixelArray(pixelArray, type, format, width, height, depth) {
   if (pixelArray) {
     return pixelArray;
   }
@@ -5015,11 +4923,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 = {};
@@ -5045,7 +4951,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,8 +4958,10 @@ 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 {
+  //
+  // Public `Device` API
+  //
   /** type of this device */
   type = "webgl";
   /** The underlying WebGL context */
@@ -5065,68 +4972,22 @@ var _WebGLDevice = class extends import_core27.Device {
   canvasContext;
   lost;
   _resolveContextLost;
-  //
-  // Static methods, expected to be present by `luma.createDevice()`
-  //
-  /** Check if WebGL 2 is available */
-  static isSupported() {
-    return typeof WebGL2RenderingContext !== "undefined";
-  }
-  /**
-   * Get a device instance from a GL context
-   * Creates and instruments the device if not already created
-   * @param gl
-   * @returns
-   */
-  static attach(gl) {
-    if (gl instanceof _WebGLDevice) {
-      return gl;
-    }
-    if ((gl == null ? void 0 : gl.device) instanceof import_core27.Device) {
-      return gl.device;
-    }
-    if (!isWebGL(gl)) {
-      throw new Error("Invalid WebGL2RenderingContext");
-    }
-    return new _WebGLDevice({ gl });
-  }
-  static async create(props = {}) {
-    var _a;
-    import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
-    const promises = [];
-    if (props.debug) {
-      promises.push(loadWebGLDeveloperTools());
-    }
-    if (props.spector) {
-      promises.push(loadSpectorJS());
-    }
-    if (typeof props.canvas === "string") {
-      promises.push(import_core27.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_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
-    if ((_a = props.gl) == null ? void 0 : _a.device) {
-      import_core27.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)();
-    return device;
-  }
+  /** WebGL2 context. */
+  gl;
+  debug = false;
+  /** State used by luma.gl classes: TODO - move to canvasContext*/
+  _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 };
+  /** State used by luma.gl classes - TODO - not used? */
+  _extensions = {};
+  _polyfilled = false;
+  /** Instance of Spector.js (if initialized) */
+  spectorJS;
   //
   // Public API
   //
   constructor(props) {
     var _a, _b;
-    super({ ...props, id: props.id || (0, import_core27.uid)("webgl-device") });
+    super({ ...props, id: props.id || uid("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}`);
@@ -5136,8 +4997,7 @@ var _WebGLDevice = class extends import_core27.Device {
     this.lost = new Promise((resolve) => {
       this._resolveContextLost = resolve;
     });
-    let gl = props.gl || null;
-    gl ||= createBrowserContext(this.canvasContext.canvas, {
+    this.handle = createBrowserContext(this.canvasContext.canvas, {
       ...props,
       onContextLost: (event) => {
         var _a2;
@@ -5147,16 +5007,13 @@ var _WebGLDevice = class extends import_core27.Device {
         });
       }
     });
-    if (!gl) {
+    this.gl = this.handle;
+    if (!this.handle) {
       throw new Error("WebGL context creation failed");
     }
-    this.handle = gl;
-    this.gl = gl;
+    this.spectorJS = initializeSpectorJS({ ...this.props, gl: this.handle });
     this.gl.device = this;
     this.gl._version = 2;
-    if (props.spector) {
-      this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
-    }
     this.info = getDeviceInfo(this.gl, this._extensions);
     this.limits = new WebGLDeviceLimits(this.gl);
     this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures);
@@ -5164,17 +5021,15 @@ var _WebGLDevice = class extends import_core27.Device {
       this.features.initializeFeatures();
     }
     this.canvasContext.resize();
-    const { enable: enable2 = true, copyState = false } = props;
-    trackContextState(this.gl, {
-      enable: enable2,
-      copyState,
-      log: (...args) => import_core27.log.log(1, ...args)()
+    const glState = new WebGLStateTracker(this.gl, {
+      log: (...args) => import_core22.log.log(1, ...args)()
     });
+    glState.trackState(this.gl, { copyState: false });
     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.")();
     }
   }
   /**
@@ -5186,9 +5041,6 @@ var _WebGLDevice = class extends import_core27.Device {
   get isLost() {
     return this.gl.isContextLost();
   }
-  getSize() {
-    return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight];
-  }
   isTextureFormatSupported(format) {
     return isTextureFormatSupported(this.gl, format, this._extensions);
   }
@@ -5206,6 +5058,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);
   }
@@ -5243,7 +5096,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);
   }
   /**
@@ -5280,22 +5133,12 @@ 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);
   }
   //
   // WebGL-only API (not part of `Device` API)
   //
-  /** WebGL2 context. */
-  gl;
-  debug = false;
-  /** State used by luma.gl classes: TODO - move to canvasContext*/
-  _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 };
-  /** State used by luma.gl classes - TODO - not used? */
-  _extensions = {};
-  _polyfilled = false;
-  /** Instance of Spector.js (if initialized) */
-  spectorJS;
   /**
    * Triggers device (or WebGL context) loss.
    * @note primarily intended for testing how application reacts to device loss
@@ -5317,11 +5160,13 @@ var _WebGLDevice = class extends import_core27.Device {
   }
   /** Save current WebGL context state onto an internal stack */
   pushState() {
-    pushContextState(this.gl);
+    const webglState = WebGLStateTracker.get(this.gl);
+    webglState.push();
   }
   /** Restores previously saved context state */
   popState() {
-    popContextState(this.gl);
+    const webglState = WebGLStateTracker.get(this.gl);
+    webglState.pop();
   }
   /**
    * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
@@ -5358,7 +5203,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) {
@@ -5372,7 +5217,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 */
@@ -5381,18 +5226,6 @@ var _WebGLDevice = class extends import_core27.Device {
     return this._extensions;
   }
 };
-var WebGLDevice = _WebGLDevice;
-//
-// Public `Device` API
-//
-/** type of this device */
-__publicField(WebGLDevice, "type", "webgl");
-function isWebGL(gl) {
-  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
-    return true;
-  }
-  return Boolean(gl && Number.isFinite(gl._version));
-}
 function setConstantFloatArray(device, location, array) {
   switch (array.length) {
     case 1:
@@ -5408,7 +5241,6 @@ function setConstantFloatArray(device, location, array) {
       device.gl.vertexAttrib4fv(location, array);
       break;
     default:
-      (0, import_core27.assert)(false);
   }
 }
 function setConstantIntArray(device, location, array) {
@@ -5429,173 +5261,179 @@ 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;
+// dist/context/polyfills/polyfill-webgl1-extensions.js
+var import_constants29 = require("@luma.gl/constants");
+var WEBGL1_STATIC_EXTENSIONS = {
+  WEBGL_depth_texture: {
+    UNSIGNED_INT_24_8_WEBGL: 34042
+  },
+  OES_element_index_uint: {},
+  OES_texture_float: {},
+  OES_texture_half_float: {
+    // @ts-expect-error different numbers?
+    HALF_FLOAT_OES: 5131
+  },
+  EXT_color_buffer_float: {},
+  OES_standard_derivatives: {
+    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 35723
+  },
+  EXT_frag_depth: {},
+  EXT_blend_minmax: {
+    MIN_EXT: 32775,
+    MAX_EXT: 32776
+  },
+  EXT_shader_texture_lod: {}
+};
+var getWEBGL_draw_buffers = (gl) => ({
+  drawBuffersWEBGL(buffers) {
+    return gl.drawBuffers(buffers);
+  },
+  COLOR_ATTACHMENT0_WEBGL: 36064,
+  COLOR_ATTACHMENT1_WEBGL: 36065,
+  COLOR_ATTACHMENT2_WEBGL: 36066,
+  COLOR_ATTACHMENT3_WEBGL: 36067
+});
+var getOES_vertex_array_object = (gl) => ({
+  VERTEX_ARRAY_BINDING_OES: 34229,
+  createVertexArrayOES() {
+    return gl.createVertexArray();
+  },
+  deleteVertexArrayOES(vertexArray) {
+    return gl.deleteVertexArray(vertexArray);
+  },
+  isVertexArrayOES(vertexArray) {
+    return gl.isVertexArray(vertexArray);
+  },
+  bindVertexArrayOES(vertexArray) {
+    return gl.bindVertexArray(vertexArray);
   }
-  toString() {
-    return `${this.constructor.name}(${this.id})`;
+});
+var getANGLE_instanced_arrays = (gl) => ({
+  VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 35070,
+  drawArraysInstancedANGLE(...args) {
+    return gl.drawArraysInstanced(...args);
+  },
+  drawElementsInstancedANGLE(...args) {
+    return gl.drawElementsInstanced(...args);
+  },
+  vertexAttribDivisorANGLE(...args) {
+    return gl.vertexAttribDivisor(...args);
   }
-  get handle() {
-    return this._handle;
+});
+function enforceWebGL2(enforce = true) {
+  const prototype = HTMLCanvasElement.prototype;
+  if (!enforce && prototype.originalGetContext) {
+    prototype.getContext = prototype.originalGetContext;
+    prototype.originalGetContext = void 0;
+    return;
   }
-  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());
+  prototype.originalGetContext = prototype.getContext;
+  prototype.getContext = function(contextId, options) {
+    if (contextId === "webgl" || contextId === "experimental-webgl") {
+      const context = this.originalGetContext("webgl2", options);
+      if (context instanceof HTMLElement) {
+        polyfillWebGL1Extensions(context);
+      }
+      return context;
     }
-    return this;
-  }
-  bind(funcOrHandle = this.handle) {
-    if (typeof funcOrHandle !== "function") {
-      this._bindHandle(funcOrHandle);
-      return this;
+    return this.originalGetContext(contextId, options);
+  };
+}
+function polyfillWebGL1Extensions(gl) {
+  gl.getExtension("EXT_color_buffer_float");
+  const boundExtensions = {
+    ...WEBGL1_STATIC_EXTENSIONS,
+    WEBGL_disjoint_timer_query: gl.getExtension("EXT_disjoint_timer_query_webgl2"),
+    WEBGL_draw_buffers: getWEBGL_draw_buffers(gl),
+    OES_vertex_array_object: getOES_vertex_array_object(gl),
+    ANGLE_instanced_arrays: getANGLE_instanced_arrays(gl)
+  };
+  const originalGetExtension = gl.getExtension;
+  gl.getExtension = function(extensionName) {
+    const ext = originalGetExtension.call(gl, extensionName);
+    if (ext) {
+      return ext;
     }
-    let value;
-    if (!this._bound) {
-      this._bindHandle(this.handle);
-      this._bound = true;
-      value = funcOrHandle();
-      this._bound = false;
-      this._bindHandle(null);
-    } else {
-      value = funcOrHandle();
+    if (extensionName in boundExtensions) {
+      return boundExtensions[extensionName];
     }
-    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);
-  }
-};
+    return null;
+  };
+  const originalGetSupportedExtensions = gl.getSupportedExtensions;
+  gl.getSupportedExtensions = function() {
+    const extensions = originalGetSupportedExtensions.apply(gl) || [];
+    return extensions == null ? void 0 : extensions.concat(Object.keys(boundExtensions));
+  };
+}
 
-// 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;
+// dist/adapter/webgl-adapter.js
+var LOG_LEVEL2 = 1;
+var WebGLAdapter = class extends import_core23.Adapter {
+  /** type of device's created by this adapter */
+  type = "webgl";
+  constructor() {
+    super();
+    import_core23.Device.defaultProps = { ...import_core23.Device.defaultProps, ...DEFAULT_SPECTOR_PROPS };
+    WebGLDevice.adapter = this;
   }
-  get attachment() {
-    return;
+  /** Check if WebGL 2 is available */
+  isSupported() {
+    return typeof WebGL2RenderingContext !== "undefined";
   }
-  /** WebGL format constant */
-  glFormat;
-  static isTextureFormatSupported(device, format) {
-    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
+  /** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */
+  enforceWebGL2(enable2) {
+    enforceWebGL2(enable2);
   }
-  constructor(device, props) {
-    if (typeof props.format === "number") {
-      throw new Error("Renderbuffer");
+  /**
+   * Get a device instance from a GL context
+   * Creates and instruments the device if not already created
+   * @param gl
+   * @returns
+   */
+  async attach(gl) {
+    if (gl instanceof WebGLDevice) {
+      return gl;
     }
-    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);
+    if ((gl == null ? void 0 : gl.device) instanceof import_core23.Device) {
+      return gl.device;
     }
-  }
-  // 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);
+    if (!isWebGL(gl)) {
+      throw new Error("Invalid WebGL2RenderingContext");
     }
-    this.gl.bindRenderbuffer(36161, null);
-    this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format));
-  }
-  // RESOURCE IMPLEMENTATION
-  _createHandle() {
-    return this.gl.createRenderbuffer();
+    return new WebGLDevice({ gl });
   }
-  _deleteHandle() {
-    this.gl.deleteRenderbuffer(this.handle);
-    this.trackDeallocatedMemory();
-  }
-  _bindHandle(handle) {
-    this.gl.bindRenderbuffer(36161, handle);
+  async create(props = {}) {
+    import_core23.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+    const promises = [];
+    if (props.debug) {
+      promises.push(loadWebGLDeveloperTools());
+    }
+    if (props.debugWithSpectorJS) {
+      promises.push(loadSpectorJS(props));
+    }
+    if (typeof props.canvas === "string") {
+      promises.push(import_core23.CanvasContext.pageLoaded);
+    }
+    const results = await Promise.allSettled(promises);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        import_core23.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+      }
+    }
+    import_core23.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+    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_core23.log.probe(LOG_LEVEL2, message2)();
+    import_core23.log.table(LOG_LEVEL2, device.info)();
+    import_core23.log.groupEnd(LOG_LEVEL2)();
+    return device;
   }
 };
-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
-});
+function isWebGL(gl) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+    return true;
+  }
+  return Boolean(gl && Number.isFinite(gl._version));
+}
+var webgl2Adapter = new WebGLAdapter();
 //# sourceMappingURL=index.cjs.map