@luma.gl/webgl 9.0.0-alpha.46 → 9.0.0-alpha.48

package/dist/index.cjs

@@ -1,24 +1,8 @@
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -32,25 +16,9 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
 };
 
 // src/index.ts
@@ -116,7 +84,7 @@ function isHeadlessGLRegistered() {
   return headlessGL !== null;
 }
 function createHeadlessContext(options) {
-  options = __spreadValues(__spreadValues({}, CONTEXT_DEFAULTS), options);
+  options = { ...CONTEXT_DEFAULTS, ...options };
   const { width, height, webgl1, webgl2 } = options;
   if (webgl2 && !webgl1) {
     throw new Error("headless-gl does not support WebGL2");
@@ -1354,6 +1322,12 @@ function deepArrayEqual(x, y) {
 
 // src/context/state-tracker/track-context-state.ts
 var GLState = class {
+  gl;
+  program = null;
+  stateStack = [];
+  enable = true;
+  cache;
+  log;
   constructor(gl, {
     copyState = false,
     // Copy cache from params (slow) or initialize from WebGL defaults (fast)
@@ -1361,9 +1335,6 @@ var GLState = class {
     }
     // Logging function, called when gl parameter change calls are actually issued
   } = {}) {
-    this.program = null;
-    this.stateStack = [];
-    this.enable = true;
     this.gl = gl;
     this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
     this.log = log10;
@@ -1504,16 +1475,16 @@ var DEFAULT_CONTEXT_PROPS = {
   onContextRestored: () => console.info("WebGL context restored")
 };
 function createBrowserContext(canvas, props) {
-  props = __spreadValues(__spreadValues({}, DEFAULT_CONTEXT_PROPS), props);
+  props = { ...DEFAULT_CONTEXT_PROPS, ...props };
   let errorMessage = null;
   const onCreateError = (error2) => errorMessage = error2.statusMessage || errorMessage;
   canvas.addEventListener("webglcontextcreationerror", onCreateError, false);
   let gl = null;
   if (props.type === "webgl2") {
-    props = __spreadProps(__spreadValues({}, props), { webgl1: false });
+    props = { ...props, webgl1: false };
   }
   if (props.type === "webgl1") {
-    props = __spreadProps(__spreadValues({}, props), { webgl2: false });
+    props = { ...props, webgl2: false };
   }
   if (!gl && props.webgl2) {
     gl = canvas.getContext("webgl2", props);
@@ -1552,17 +1523,20 @@ function getDeviceInfo(gl) {
   const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants4.GL.RENDERER);
   const vendor = vendorUnmasked || vendorMasked;
   const renderer = rendererUnmasked || rendererMasked;
+  const version = gl.getParameter(import_constants4.GL.VERSION);
   const gpu = identifyGPUVendor(vendor, renderer);
+  const gpuBackend = identifyGPUBackend(vendor, renderer);
+  const shadingLanguage = "glsl";
+  const shadingLanguageVersion = isWebGL2(gl) ? 300 : 100;
   return {
     type: isWebGL2(gl) ? "webgl2" : "webgl",
     gpu,
-    vendor: vendorUnmasked || vendorMasked,
-    renderer: rendererUnmasked || rendererMasked,
-    version: gl.getParameter(import_constants4.GL.VERSION),
-    shadingLanguages: ["glsl"],
-    shadingLanguageVersions: {
-      "glsl": gl.getParameter(import_constants4.GL.SHADING_LANGUAGE_VERSION)
-    }
+    gpuBackend,
+    vendor,
+    renderer,
+    version,
+    shadingLanguage,
+    shadingLanguageVersion
   };
 }
 function identifyGPUVendor(vendor, renderer) {
@@ -1583,6 +1557,15 @@ function identifyGPUVendor(vendor, renderer) {
   }
   return "unknown";
 }
+function identifyGPUBackend(vendor, renderer) {
+  if (/ANGLE/i.exec(vendor) || /ANGLE/i.exec(renderer)) {
+    return "angle";
+  }
+  if (/Metal/i.exec(vendor) || /Metal/i.exec(renderer)) {
+    return "metal";
+  }
+  return "unknown";
+}
 
 // src/adapter/device-helpers/is-old-ie.ts
 function isOldIE(opts = {}) {
@@ -1938,7 +1921,7 @@ function isTextureFormatFilterable(gl, formatOrGL) {
     if (decoded.signed) {
       return false;
     }
-  } catch (e) {
+  } catch {
     return false;
   }
   if (format.endsWith("32float")) {
@@ -2418,6 +2401,17 @@ function setDeviceParameters(device, parameters) {
     gl.stencilOpSeparate(import_constants8.GL.FRONT, sfail, dpfail, dppass);
     gl.stencilOpSeparate(import_constants8.GL.BACK, sfail, dpfail, dppass);
   }
+  if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
+    gl.enable(import_constants8.GL.BLEND);
+    const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add");
+    const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add");
+    gl.blendEquationSeparate(colorEquation, alphaEquation);
+    const colorSrcFactor = convertBlendFactorToFunction("blendColorSrcFactor", parameters.blendColorSrcFactor || "one");
+    const colorDstFactor = convertBlendFactorToFunction("blendColorDstFactor", parameters.blendColorDstFactor || "zero");
+    const alphaSrcFactor = convertBlendFactorToFunction("blendAlphaSrcFactor", parameters.blendAlphaSrcFactor || "one");
+    const alphaDstFactor = convertBlendFactorToFunction("blendAlphaDstFactor", parameters.blendAlphaDstFactor || "zero");
+    gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
+  }
 }
 function convertCompareFunction(parameter, value) {
   return map(parameter, value, {
@@ -2443,6 +2437,30 @@ function convertStencilOperation(parameter, value) {
     "decrement-wrap": import_constants8.GL.DECR_WRAP
   });
 }
+function convertBlendOperationToEquation(parameter, value) {
+  return map(parameter, value, {
+    "add": import_constants8.GL.FUNC_ADD,
+    "subtract": import_constants8.GL.FUNC_SUBTRACT,
+    "reverse-subtract": import_constants8.GL.FUNC_REVERSE_SUBTRACT,
+    // When using a WebGL 2 context, the following values are available additionally:
+    "min": import_constants8.GL.MIN,
+    "max": import_constants8.GL.MAX
+  });
+}
+function convertBlendFactorToFunction(parameter, value) {
+  return map(parameter, value, {
+    "one": import_constants8.GL.ONE,
+    "zero": import_constants8.GL.ZERO,
+    "src-color": import_constants8.GL.SRC_COLOR,
+    "one-minus-src-color": import_constants8.GL.ONE_MINUS_SRC_COLOR,
+    "dst-color": import_constants8.GL.DST_COLOR,
+    "one-minus-dst-color": import_constants8.GL.ONE_MINUS_DST_COLOR,
+    "src-alpha": import_constants8.GL.SRC_ALPHA,
+    "one-minus-src-alpha": import_constants8.GL.ONE_MINUS_SRC_ALPHA,
+    "dst-alpha": import_constants8.GL.DST_ALPHA,
+    "one-minus-dst-alpha": import_constants8.GL.ONE_MINUS_DST_ALPHA
+  });
+}
 function message(parameter, value) {
   return `Illegal parameter ${value} for ${parameter}`;
 }
@@ -2521,7 +2539,7 @@ function convertMinFilterMode(minFilter, mipmapFilter) {
   }
 }
 function updateSamplerParametersForNPOT(parameters) {
-  const newParameters = __spreadValues({}, parameters);
+  const newParameters = { ...parameters };
   if (parameters[import_constants9.GL.TEXTURE_MIN_FILTER] !== import_constants9.GL.NEAREST) {
     newParameters[import_constants9.GL.TEXTURE_MIN_FILTER] = import_constants9.GL.LINEAR;
   }
@@ -2535,18 +2553,30 @@ var import_core7 = require("@luma.gl/core");
 var import_constants10 = require("@luma.gl/constants");
 var DEBUG_DATA_LENGTH = 10;
 var WEBGLBuffer = class extends import_core7.Buffer {
+  device;
+  gl;
+  gl2;
+  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 = import_constants10.GL.UNSIGNED_SHORT;
+  /** Number of bytes allocated on the GPU for this buffer */
+  byteLength;
+  /** Number of bytes used */
+  bytesUsed;
+  /** A partial CPU-side copy of the data in this buffer, for debugging purposes */
+  debugData = null;
   constructor(device, props = {}) {
     super(device, props);
-    /** Index type is needed when issuing draw calls, so we pre-compute it */
-    this.glIndexType = import_constants10.GL.UNSIGNED_SHORT;
-    /** A partial CPU-side copy of the data in this buffer, for debugging purposes */
-    this.debugData = null;
     this.device = device;
     this.gl = this.device.gl;
     this.gl2 = this.device.gl2;
     const handle = typeof props === "object" ? props.handle : void 0;
     this.handle = handle || this.gl.createBuffer();
-    device.setSpectorMetadata(this.handle, __spreadProps(__spreadValues({}, this.props), { data: typeof this.props.data }));
+    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" ? import_constants10.GL.UNSIGNED_INT : import_constants10.GL.UNSIGNED_SHORT;
@@ -2611,17 +2641,15 @@ var WEBGLBuffer = class extends import_core7.Buffer {
     this.gl.bindBuffer(glTarget, null);
   }
   /** Read data from the buffer */
-  readAsync(byteOffset = 0, byteLength) {
-    return __async(this, null, function* () {
-      this.device.assertWebGL2();
-      byteLength = byteLength != null ? byteLength : this.byteLength;
-      const data = new Uint8Array(byteLength);
-      const dstOffset = 0;
-      this.gl.bindBuffer(import_constants10.GL.COPY_READ_BUFFER, this.handle);
-      this.gl2.getBufferSubData(import_constants10.GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
-      this.gl.bindBuffer(import_constants10.GL.COPY_READ_BUFFER, null);
-      return data;
-    });
+  async readAsync(byteOffset = 0, byteLength) {
+    this.device.assertWebGL2();
+    byteLength = byteLength ?? this.byteLength;
+    const data = new Uint8Array(byteLength);
+    const dstOffset = 0;
+    this.gl.bindBuffer(import_constants10.GL.COPY_READ_BUFFER, this.handle);
+    this.gl2.getBufferSubData(import_constants10.GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
+    this.gl.bindBuffer(import_constants10.GL.COPY_READ_BUFFER, null);
+    return data;
   }
   // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
   _invalidateDebugData() {
@@ -2663,6 +2691,9 @@ function getWebGLUsage(usage) {
 var import_core8 = require("@luma.gl/core");
 var import_constants11 = require("@luma.gl/constants");
 var WEBGLSampler = class extends import_core8.Sampler {
+  device;
+  handle;
+  parameters;
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -2710,28 +2741,44 @@ var DEFAULT_WEBGL_TEXTURE_PROPS = {
   target: void 0
 };
 var _WEBGLTexture = class extends import_core10.Texture {
+  MAX_ATTRIBUTES;
+  device;
+  gl;
+  gl2;
+  handle;
+  /** Sampler object (currently unused) */
+  sampler = 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, __spreadValues(__spreadProps(__spreadValues({}, DEFAULT_WEBGL_TEXTURE_PROPS), { format: "rgba8unorm" }), props));
-    /** Sampler object (currently unused) */
-    this.sampler = void 0;
-    // data;
-    this.glFormat = void 0;
-    this.type = void 0;
-    this.dataFormat = void 0;
-    this.mipmaps = void 0;
-    this.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
-     */
-    this.loaded = false;
+    super(device, { ...DEFAULT_WEBGL_TEXTURE_PROPS, format: "rgba8unorm", ...props });
     this.device = (0, import_core10.cast)(device);
     this.gl = this.device.gl;
     this.gl2 = this.device.gl2;
     this.handle = this.props.handle || this.gl.createTexture();
-    this.device.setSpectorMetadata(this.handle, __spreadProps(__spreadValues({}, this.props), { data: typeof this.props.data }));
+    this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
     this.glFormat = import_constants12.GL.RGBA;
     this.target = getWebGLTextureTarget(this.props);
     this.loaded = false;
@@ -3212,32 +3259,30 @@ var _WEBGLTexture = class extends import_core10.Texture {
   }
   // CUBE MAP METHODS
   /* eslint-disable max-statements, max-len */
-  setCubeMapImageData(options) {
-    return __async(this, null, function* () {
-      const { gl } = this;
-      const { width, height, pixels, data, format = import_constants12.GL.RGBA, type = import_constants12.GL.UNSIGNED_BYTE } = options;
-      const imageDataMap = pixels || data;
-      const resolvedFaces = yield 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_core10.log.warn(`${this.id} has mipmap and multiple LODs.`)();
+  async setCubeMapImageData(options) {
+    const { gl } = this;
+    const { width, height, pixels, data, format = import_constants12.GL.RGBA, type = import_constants12.GL.UNSIGNED_BYTE } = 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_core10.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);
         }
-        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();
     });
+    this.unbind();
   }
   /** @todo update this method to accept LODs */
   setImageDataForFace(options) {
@@ -3382,14 +3427,14 @@ var _WEBGLTexture = class extends import_core10.Texture {
 };
 var WEBGLTexture = _WEBGLTexture;
 // TODO - remove?
-WEBGLTexture.FACES = [
+__publicField(WEBGLTexture, "FACES", [
   import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X,
   import_constants12.GL.TEXTURE_CUBE_MAP_NEGATIVE_X,
   import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_Y,
   import_constants12.GL.TEXTURE_CUBE_MAP_NEGATIVE_Y,
   import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_Z,
   import_constants12.GL.TEXTURE_CUBE_MAP_NEGATIVE_Z
-];
+]);
 function getWebGLTextureTarget(props) {
   switch (props.dimension) {
     case "2d":
@@ -3442,11 +3487,15 @@ function getKeyValue(gl, name) {
 // src/adapter/objects/webgl-resource.ts
 var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
 var WebGLResource = class extends import_core12.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._bound = false;
-    // Only meaningful for resources that allocate GPU memory
-    this.byteLength = 0;
     this.device = WebGLDevice.attach(device);
     const gl = this.device.gl;
     assertWebGLContext(gl);
@@ -3643,14 +3692,6 @@ var WebGLResource = class extends import_core12.Resource {
 
 // src/adapter/objects/webgl-renderbuffer.ts
 var _WEBGLRenderbuffer = class extends WebGLResource {
-  constructor(device, props) {
-    if (typeof props.format === "number") {
-      throw new Error("Renderbuffer");
-    }
-    super(device, props, _WEBGLRenderbuffer.defaultProps);
-    this.glFormat = convertTextureFormatToGL(this.props.format, device.isWebGL2);
-    this._initialize(this.props);
-  }
   get [Symbol.toStringTag]() {
     return "Renderbuffer";
   }
@@ -3669,12 +3710,22 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
   get attachment() {
     return;
   }
+  /** WebGL format constant */
+  glFormat;
   static isTextureFormatSupported(device, format) {
     return isRenderbufferFormatSupported(device.gl, format);
   }
+  constructor(device, props) {
+    if (typeof props.format === "number") {
+      throw new Error("Renderbuffer");
+    }
+    super(device, props, _WEBGLRenderbuffer.defaultProps);
+    this.glFormat = convertTextureFormatToGL(this.props.format, device.isWebGL2);
+    this._initialize(this.props);
+  }
   resize(size) {
     if (size.width !== this.width || size.height !== this.height) {
-      Object.assign(this.props, __spreadProps(__spreadValues({}, size), { format: this.format, samples: this.samples }));
+      Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
       this._initialize(this.props);
     }
   }
@@ -3708,7 +3759,7 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
   }
 };
 var WEBGLRenderbuffer = _WEBGLRenderbuffer;
-WEBGLRenderbuffer.defaultProps = {
+__publicField(WEBGLRenderbuffer, "defaultProps", {
   id: void 0,
   handle: void 0,
   userData: void 0,
@@ -3717,10 +3768,16 @@ WEBGLRenderbuffer.defaultProps = {
   width: 1,
   height: 1,
   samples: 0
-};
+});
 
 // src/adapter/resources/webgl-framebuffer.ts
 var WEBGLFramebuffer = class extends import_core14.Framebuffer {
+  device;
+  gl;
+  handle;
+  get texture() {
+    return this.colorAttachments[0];
+  }
   constructor(device, props) {
     super(device, props);
     const isDefaultFramebuffer = props.handle === null;
@@ -3750,9 +3807,6 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
       this._checkStatus();
     }
   }
-  get texture() {
-    return this.colorAttachments[0];
-  }
   /** destroys any auto created resources etc. */
   destroy() {
     super.destroy();
@@ -3881,9 +3935,11 @@ function _getFrameBufferStatus(status) {
 
 // src/adapter/webgl-canvas-context.ts
 var WebGLCanvasContext = class extends import_core15.CanvasContext {
+  device;
+  presentationSize;
+  _framebuffer = null;
   constructor(device, props) {
     super(props);
-    this._framebuffer = null;
     this.device = device;
     this.presentationSize = [-1, -1];
     this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
@@ -3938,19 +3994,17 @@ var SPECTOR_CDN_URL = "https://spectorcdn.babylonjs.com/spector.bundle.js";
 var LOG_LEVEL = 1;
 var spector = null;
 var initialized = false;
-function loadSpectorJS(props) {
-  return __async(this, null, function* () {
-    if (!globalThis.SPECTOR) {
-      try {
-        yield (0, import_core16.loadScript)(SPECTOR_CDN_URL);
-      } catch (error2) {
-        import_core16.log.warn(String(error2));
-      }
+async function loadSpectorJS(props) {
+  if (!globalThis.SPECTOR) {
+    try {
+      await (0, import_core16.loadScript)(SPECTOR_CDN_URL);
+    } catch (error2) {
+      import_core16.log.warn(String(error2));
     }
-  });
+  }
 }
 function initializeSpectorJS(props) {
-  props = __spreadValues(__spreadValues({}, DEFAULT_SPECTOR_PROPS), props);
+  props = { ...DEFAULT_SPECTOR_PROPS, ...props };
   if (!(props == null ? void 0 : props.spector)) {
     return null;
   }
@@ -3997,14 +4051,12 @@ function getContextData2(gl) {
   gl.luma = gl.luma || {};
   return gl.luma;
 }
-function loadWebGLDeveloperTools() {
-  return __async(this, null, function* () {
-    if ((0, import_env.isBrowser)() && !globalThis.WebGLDebugUtils) {
-      globalThis.global = globalThis.global || globalThis;
-      globalThis.global.module = {};
-      yield (0, import_core17.loadScript)(WEBGL_DEBUG_CDN_URL);
-    }
-  });
+async function loadWebGLDeveloperTools() {
+  if ((0, import_env.isBrowser)() && !globalThis.WebGLDebugUtils) {
+    globalThis.global = globalThis.global || globalThis;
+    globalThis.global.module = {};
+    await (0, import_core17.loadScript)(WEBGL_DEBUG_CDN_URL);
+  }
 }
 function makeDebugContext(gl, props = {}) {
   if (!gl) {
@@ -4025,7 +4077,7 @@ function getDebugContext(gl, props) {
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants15.GL), gl));
+  globalThis.WebGLDebugUtils.init({ ...import_constants15.GL, ...gl });
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
     gl,
     onGLError.bind(null, props),
@@ -4120,7 +4172,6 @@ function getShaderVersion(source) {
 }
 
 // src/adapter/helpers/parse-shader-compiler-log.ts
-var MESSAGE_TYPES = ["warning", "error", "info"];
 function parseShaderCompilerLog(errLog) {
   const lines = errLog.split(/\r?\n/);
   const messages = [];
@@ -4129,6 +4180,16 @@ function parseShaderCompilerLog(errLog) {
       continue;
     }
     const segments = line.split(":");
+    if (segments.length === 2) {
+      const [messageType2, message2] = segments;
+      messages.push({
+        message: message2.trim(),
+        type: getMessageType(messageType2),
+        lineNum: 0,
+        linePos: 0
+      });
+      continue;
+    }
     const [messageType, linePosition, lineNumber, ...rest] = segments;
     let lineNum = parseInt(lineNumber, 10);
     if (isNaN(lineNum)) {
@@ -4138,11 +4199,9 @@ function parseShaderCompilerLog(errLog) {
     if (isNaN(linePos)) {
       linePos = 0;
     }
-    const lowerCaseType = messageType.toLowerCase();
-    const type = MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : "info";
     messages.push({
       message: rest.join(":").trim(),
-      type,
+      type: getMessageType(messageType),
       lineNum,
       linePos
       // TODO
@@ -4150,11 +4209,18 @@ function parseShaderCompilerLog(errLog) {
   }
   return messages;
 }
+function getMessageType(messageType) {
+  const MESSAGE_TYPES = ["warning", "error", "info"];
+  const lowerCaseType = messageType.toLowerCase();
+  return MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : "info";
+}
 
 // src/adapter/resources/webgl-shader.ts
 var WEBGLShader = class extends import_core18.Shader {
+  device;
+  handle;
   constructor(device, props) {
-    super(device, __spreadValues({ id: getShaderIdFromProps(props) }, props));
+    super(device, { id: getShaderIdFromProps(props), ...props });
     this.device = device;
     switch (this.props.stage) {
       case "vertex":
@@ -4175,11 +4241,9 @@ var WEBGLShader = class extends import_core18.Shader {
       this.destroyed = true;
     }
   }
-  compilationInfo() {
-    return __async(this, null, function* () {
-      const log10 = this.device.gl.getShaderInfoLog(this.handle);
-      return log10 ? parseShaderCompilerLog(log10) : [];
-    });
+  async compilationInfo() {
+    const log10 = this.device.gl.getShaderInfoLog(this.handle);
+    return log10 ? parseShaderCompilerLog(log10) : [];
   }
   // PRIVATE METHODS
   _compile(source) {
@@ -4215,6 +4279,9 @@ var GL_STENCIL_BUFFER_BIT = 1024;
 var GL_COLOR_BUFFER_BIT = 16384;
 var GL_COLOR = 6144;
 var WEBGLRenderPass = class extends import_core19.RenderPass {
+  device;
+  /** Parameters that should be applied before each draw call */
+  glParameters;
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -4278,7 +4345,7 @@ var WEBGLRenderPass = class extends import_core19.RenderPass {
    * Optionally clears depth, color and stencil buffers based on parameters
    */
   clear() {
-    const glParameters = __spreadValues({}, this.glParameters);
+    const glParameters = { ...this.glParameters };
     let clearMask = 0;
     if (this.props.clearColor !== false) {
       clearMask |= GL_COLOR_BUFFER_BIT;
@@ -4417,6 +4484,15 @@ var PROP_CHECKS = {
   }
 };
 var Accessor = class {
+  offset;
+  stride;
+  type;
+  size;
+  divisor;
+  normalized;
+  integer;
+  buffer;
+  index;
   static getBytesPerElement(accessor) {
     const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants19.GL.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT;
@@ -4718,10 +4794,11 @@ function readUniformBindings(gl, program) {
       for (let j = 0; j < uniformInfo.size; j++) {
         const elementName = `${name}[${j}]`;
         webglLocation = gl.getUniformLocation(program, elementName);
-        const arrayElementUniformInfo = __spreadProps(__spreadValues({}, uniformInfo), {
+        const arrayElementUniformInfo = {
+          ...uniformInfo,
           name: elementName,
           location: webglLocation
-        });
+        };
         uniforms.push(arrayElementUniformInfo);
       }
     }
@@ -4949,18 +5026,28 @@ function getGLPrimitive(topology) {
 // src/adapter/resources/webgl-render-pipeline.ts
 var LOG_PROGRAM_PERF_PRIORITY = 4;
 var WEBGLRenderPipeline = class extends import_core21.RenderPipeline {
+  /** The WebGL device that created this render pipeline */
+  device;
+  /** Handle to underlying WebGL program */
+  handle;
+  /** vertex shader */
+  vs;
+  /** fragment shader */
+  fs;
+  /** The layout extracted from shader by WebGL introspection APIs */
+  introspectedLayout;
+  /** Uniforms set on this model */
+  uniforms = {};
+  /** Bindings set on this model */
+  bindings = {};
+  /** WebGL varyings */
+  varyings = null;
+  _uniformCount = 0;
+  _uniformSetters = {};
   // TODO are these used?
   constructor(device, props) {
     var _a;
     super(device, props);
-    /** Uniforms set on this model */
-    this.uniforms = {};
-    /** Bindings set on this model */
-    this.bindings = {};
-    /** WebGL varyings */
-    this.varyings = null;
-    this._uniformCount = 0;
-    this._uniformSetters = {};
     this.device = device;
     this.handle = this.props.handle || this.device.gl.createProgram();
     this.device.setSpectorMetadata(this.handle, { id: this.props.id });
@@ -5255,10 +5342,9 @@ var WEBGLRenderPipeline = class extends import_core21.RenderPipeline {
    * (though caching will avoid redundant WebGL calls)
    */
   _applyUniforms() {
-    var _a;
     for (const uniformLayout of this.shaderLayout.uniforms || []) {
       const { name, location, type, textureUnit } = uniformLayout;
-      const value = (_a = this.uniforms[name]) != null ? _a : textureUnit;
+      const value = this.uniforms[name] ?? textureUnit;
       if (value !== void 0) {
         setUniform(this.device.gl, location, type, value);
       }
@@ -5276,9 +5362,10 @@ function cast3(value) {
   return value;
 }
 var WEBGLCommandBuffer = class extends import_core23.CommandBuffer {
+  device;
+  commands = [];
   constructor(device) {
     super(device, {});
-    this.commands = [];
     this.device = device;
   }
   submitCommands(commands = this.commands) {
@@ -5301,7 +5388,6 @@ var WEBGLCommandBuffer = class extends import_core23.CommandBuffer {
   }
 };
 function _copyBufferToBuffer(device, options) {
-  var _a, _b;
   const source = cast3(options.source);
   const destination = cast3(options.destination);
   const gl2 = device.assertWebGL2();
@@ -5311,8 +5397,8 @@ function _copyBufferToBuffer(device, options) {
     gl2.copyBufferSubData(
       import_constants25.GL.COPY_READ_BUFFER,
       import_constants25.GL.COPY_WRITE_BUFFER,
-      (_a = options.sourceOffset) != null ? _a : 0,
-      (_b = options.destinationOffset) != null ? _b : 0,
+      options.sourceOffset ?? 0,
+      options.destinationOffset ?? 0,
       options.size
     );
     gl2.bindBuffer(import_constants25.GL.COPY_READ_BUFFER, null);
@@ -5468,6 +5554,8 @@ function getFramebuffer(source) {
 
 // src/adapter/resources/webgl-command-encoder.ts
 var WEBGLCommandEncoder = class extends import_core24.CommandEncoder {
+  device;
+  commandBuffer;
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -5514,23 +5602,24 @@ var import_core25 = require("@luma.gl/core");
 var import_constants26 = require("@luma.gl/constants");
 var import_env2 = require("@probe.gl/env");
 var WEBGLVertexArray = class extends import_core25.VertexArray {
-  // Create a VertexArray
-  constructor(device, props) {
-    super(device, props);
-    /** Attribute 0 buffer constant */
-    this.buffer = null;
-    this.bufferValue = null;
-    this.init = false;
-    this.device = device;
-    this.handle = this.device.gl2.createVertexArray();
-  }
   get [Symbol.toStringTag]() {
     return "VertexArray";
   }
+  device;
+  handle;
+  /** Attribute 0 buffer constant */
+  buffer = null;
+  bufferValue = null;
   /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
   static isConstantAttributeZeroSupported(device) {
     return device.info.type === "webgl2" || (0, import_env2.getBrowser)() === "Chrome";
   }
+  // Create a VertexArray
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+    this.handle = this.device.gl2.createVertexArray();
+  }
   destroy() {
     var _a;
     super.destroy();
@@ -5543,14 +5632,14 @@ var WEBGLVertexArray = class extends import_core25.VertexArray {
     }
   }
   /**
-  // Set (bind) an elements buffer, for indexed rendering.
-  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
+  // Set (bind/unbind) an elements buffer, for indexed rendering.
+  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER or null. Constants not supported
    * 
    * @param elementBuffer 
    */
   setIndexBuffer(indexBuffer) {
     const buffer = indexBuffer;
-    if ((buffer == null ? void 0 : buffer.glTarget) !== import_constants26.GL.ELEMENT_ARRAY_BUFFER) {
+    if (buffer && buffer.glTarget !== import_constants26.GL.ELEMENT_ARRAY_BUFFER) {
       throw new Error("Use .setBuffer()");
     }
     this.device.gl2.bindVertexArray(this.handle);
@@ -5581,6 +5670,7 @@ var WEBGLVertexArray = class extends import_core25.VertexArray {
     this._enable(location, false);
     this.attributes[location] = value;
   }
+  init = false;
   bindBeforeRender() {
     this.device.gl2.bindVertexArray(this.handle);
     if (!this.init) {
@@ -5715,17 +5805,26 @@ function compareConstantArrayValues(v1, v2) {
 var import_core26 = require("@luma.gl/core");
 var import_constants27 = require("@luma.gl/constants");
 var WEBGLTransformFeedback = class extends import_core26.TransformFeedback {
+  device;
+  gl2;
+  handle;
+  /**
+   * NOTE: The Model already has this information while drawing, but
+   * TransformFeedback currently needs it internally, to look up
+   * varying information outside of a draw() call.
+   */
+  layout;
+  buffers = {};
+  unusedBuffers = {};
+  /**
+   * Allows us to avoid a Chrome bug where a buffer that is already bound to a
+   * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+   * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
+   */
+  bindOnUse = true;
+  _bound = false;
   constructor(device, props) {
     super(device, props);
-    this.buffers = {};
-    this.unusedBuffers = {};
-    /**
-     * Allows us to avoid a Chrome bug where a buffer that is already bound to a
-     * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
-     * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
-     */
-    this.bindOnUse = true;
-    this._bound = false;
     device.assertWebGL2();
     this.device = device;
     this.gl2 = device.gl2;
@@ -5763,7 +5862,6 @@ var WEBGLTransformFeedback = class extends import_core26.TransformFeedback {
         this.setBuffer(bufferName, buffers[bufferName]);
       }
     });
-    return this;
   }
   setBuffer(locationOrName, bufferOrRange) {
     const location = this._getVaryingIndex(locationOrName);
@@ -5771,13 +5869,19 @@ var WEBGLTransformFeedback = class extends import_core26.TransformFeedback {
     if (location < 0) {
       this.unusedBuffers[locationOrName] = buffer;
       import_core26.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
-      return this;
+      return;
     }
     this.buffers[location] = { buffer, byteLength, byteOffset };
     if (!this.bindOnUse) {
       this._bindBuffer(location, buffer, byteOffset, byteLength);
     }
-    return this;
+  }
+  getBuffer(locationOrName) {
+    if (isIndex(locationOrName)) {
+      return this.buffers[locationOrName] || null;
+    }
+    const location = this._getVaryingIndex(locationOrName);
+    return location >= 0 ? this.buffers[location] : null;
   }
   bind(funcOrHandle = this.handle) {
     if (typeof funcOrHandle !== "function") {
@@ -5841,7 +5945,6 @@ var WEBGLTransformFeedback = class extends import_core26.TransformFeedback {
     } else {
       this.gl2.bindBufferRange(import_constants27.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
     }
-    return this;
   }
 };
 function isIndex(value) {
@@ -5854,21 +5957,69 @@ function isIndex(value) {
 // src/adapter/webgl-device.ts
 var LOG_LEVEL2 = 1;
 var _WebGLDevice = class extends import_core27.Device {
+  static isSupported() {
+    return typeof WebGLRenderingContext !== "undefined" || isHeadlessGLRegistered();
+  }
+  info;
+  canvasContext;
+  handle;
+  get features() {
+    this._features = this._features || getDeviceFeatures(this.gl);
+    return this._features;
+  }
+  get limits() {
+    this._limits = this._limits || getDeviceLimits(this.gl);
+    return this._limits;
+  }
+  lost;
+  _resolveContextLost;
+  _features;
+  _limits;
+  //
+  // Static methods, expected to be present by `luma.createDevice()`
+  //
+  /**
+   * 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 (!isWebGL3(gl)) {
+      throw new Error("Invalid WebGLRenderingContext");
+    }
+    return new _WebGLDevice({ gl });
+  }
+  static async create(props = {}) {
+    import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created");
+    if (typeof props.canvas === "string") {
+      await import_core27.CanvasContext.pageLoaded;
+    }
+    if (import_core27.log.get("debug") || props.debug) {
+      await loadWebGLDeveloperTools();
+    }
+    const { spector: spector2 } = props;
+    if (import_core27.log.get("spector") || spector2) {
+      await loadSpectorJS();
+    }
+    import_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+    if (props.gl && props.gl.device) {
+      return _WebGLDevice.attach(props.gl);
+    }
+    return new _WebGLDevice(props);
+  }
   //
   // Public API
   //
   constructor(props) {
     var _a;
-    super(__spreadProps(__spreadValues({}, props), { id: props.id || (0, import_core27.uid)("webgl-device") }));
-    this.renderPass = null;
-    /** WebGL2 typed context. Need to check isWebGL2 or isWebGL1 before using. */
-    this.gl2 = null;
-    this.debug = false;
-    /** State used by luma.gl classes: TODO - move to canvasContext*/
-    this._canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 };
-    /** State used by luma.gl classes - TODO - not used? */
-    this._extensions = {};
-    this._polyfilled = false;
+    super({ ...props, id: props.id || (0, import_core27.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}`);
@@ -5885,8 +6036,8 @@ var _WebGLDevice = class extends import_core27.Device {
       });
     };
     let gl = props.gl || null;
-    gl = gl || ((0, import_env3.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, __spreadProps(__spreadValues({}, props), { onContextLost })) : null);
-    gl = gl || (!(0, import_env3.isBrowser)() ? createHeadlessContext(__spreadProps(__spreadValues({}, props), { onContextLost })) : null);
+    gl = gl || ((0, import_env3.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, { ...props, onContextLost }) : null);
+    gl = gl || (!(0, import_env3.isBrowser)() ? createHeadlessContext({ ...props, onContextLost }) : null);
     if (!gl) {
       throw new Error("WebGL context creation failed");
     }
@@ -5906,7 +6057,7 @@ var _WebGLDevice = class extends import_core27.Device {
       log: (...args) => import_core27.log.log(1, ...args)()
     });
     if ((0, import_env3.isBrowser)() && props.debug) {
-      this.gl = makeDebugContext(this.gl, __spreadProps(__spreadValues({}, props), { webgl2: this.isWebGL2, throwOnError: true }));
+      this.gl = makeDebugContext(this.gl, { ...props, webgl2: this.isWebGL2, throwOnError: true });
       this.gl2 = this.gl;
       this.debug = true;
       import_core27.log.level = Math.max(import_core27.log.level, 1);
@@ -5914,64 +6065,12 @@ var _WebGLDevice = class extends import_core27.Device {
     }
     if ((0, import_env3.isBrowser)() && props.spector) {
       const canvas = this.handle.canvas || props.canvas;
-      this.spector = initializeSpectorJS(__spreadProps(__spreadValues({}, this.props), { canvas }));
+      this.spector = initializeSpectorJS({ ...this.props, canvas });
     }
     const message2 = `Created ${this.info.type}${this.debug ? " debug" : ""} context: ${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`;
     import_core27.log.probe(LOG_LEVEL2, message2)();
     import_core27.log.groupEnd(LOG_LEVEL2)();
   }
-  static isSupported() {
-    return typeof WebGLRenderingContext !== "undefined" || isHeadlessGLRegistered();
-  }
-  get features() {
-    this._features = this._features || getDeviceFeatures(this.gl);
-    return this._features;
-  }
-  get limits() {
-    this._limits = this._limits || getDeviceLimits(this.gl);
-    return this._limits;
-  }
-  //
-  // Static methods, expected to be present by `luma.createDevice()`
-  //
-  /**
-   * 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 (!isWebGL3(gl)) {
-      throw new Error("Invalid WebGLRenderingContext");
-    }
-    return new _WebGLDevice({ gl });
-  }
-  static create() {
-    return __async(this, arguments, function* (props = {}) {
-      import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created");
-      if (typeof props.canvas === "string") {
-        yield import_core27.CanvasContext.pageLoaded;
-      }
-      if (import_core27.log.get("debug") || props.debug) {
-        yield loadWebGLDeveloperTools();
-      }
-      const { spector: spector2 } = props;
-      if (import_core27.log.get("spector") || spector2) {
-        yield loadSpectorJS();
-      }
-      import_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
-      if (props.gl && props.gl.device) {
-        return _WebGLDevice.attach(props.gl);
-      }
-      return new _WebGLDevice(props);
-    });
-  }
   /**
    * Destroys the context
    * @note Has no effect for browser contexts, there is no browser API for destroying contexts
@@ -6046,6 +6145,7 @@ var _WebGLDevice = class extends import_core27.Device {
   createTransformFeedback(props) {
     return new WEBGLTransformFeedback(this, props);
   }
+  renderPass = null;
   getDefaultRenderPass() {
     this.renderPass = this.renderPass || this.beginRenderPass({
       framebuffer: this.canvasContext.getCurrentFramebuffer()
@@ -6065,6 +6165,26 @@ var _WebGLDevice = class extends import_core27.Device {
     (_a = this.renderPass) == null ? void 0 : _a.end();
     this.renderPass = null;
   }
+  //
+  // WebGL-only API (not part of `Device` API)
+  //
+  /** WebGL1 typed context. Can always be used. */
+  gl;
+  /** WebGL2 typed context. Need to check isWebGL2 or isWebGL1 before using. */
+  gl2 = null;
+  debug = false;
+  /** `true` if this is a WebGL1 context. @note `false` if WebGL2 */
+  isWebGL1;
+  /** `true` if this is a WebGL2 context. @note `false` if WebGL1 */
+  isWebGL2;
+  /** 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) */
+  spector;
+  _webglLimits;
   /** Return WebGL specific limits */
   get webglLimits() {
     this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);
@@ -6118,6 +6238,8 @@ var _WebGLDevice = class extends import_core27.Device {
     }
     return String(value);
   }
+  /** Store constants */
+  _constants;
   /**
    * Set a constant value for a location. Disabled attributes at that location will read from this value
    * @note WebGL constants are stored globally on the WebGL context, not the VertexArray
@@ -6150,7 +6272,7 @@ var WebGLDevice = _WebGLDevice;
 //
 // Public `Device` API
 //
-WebGLDevice.type = "webgl";
+__publicField(WebGLDevice, "type", "webgl");
 function isWebGL3(gl) {
   if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
     return true;
@@ -6451,12 +6573,13 @@ function getFramebuffer2(source) {
 }
 function toFramebuffer(texture, props) {
   const { device, width, height, id } = texture;
-  const framebuffer = device.createFramebuffer(__spreadProps(__spreadValues({}, props), {
+  const framebuffer = device.createFramebuffer({
+    ...props,
     id: `framebuffer-for-${id}`,
     width,
     height,
     colorAttachments: [texture]
-  }));
+  });
   return framebuffer;
 }
 function getPixelArray(pixelArray, type, format, width, height) {