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

package/dist/context/debug/spector.d.ts

@@ -1,17 +1,21 @@
+import { Spector } from "./spector-types.js";
 /** Spector debug initialization options */
 type SpectorProps = {
+    /** Whether spector is enabled */
+    debugWithSpectorJS?: boolean;
+    /** URL to load spector script from. Typically a CDN URL */
+    spectorUrl?: string;
     /** Canvas to monitor */
-    canvas?: HTMLCanvasElement | OffscreenCanvas;
-    /** Whether debug is enabled. Auto-detected if ommitted */
-    debug?: boolean;
-    /** Whether spector is disabled */
-    spector?: boolean | string | object;
+    gl?: WebGL2RenderingContext;
 };
 declare global {
-    var SPECTOR: any;
+    var SPECTOR: Spector;
 }
+export declare const DEFAULT_SPECTOR_PROPS: Required<SpectorProps>;
 /** Loads spector from CDN if not already installed */
-export declare function loadSpectorJS(props?: SpectorProps): Promise<void>;
-export declare function initializeSpectorJS(props?: SpectorProps): any;
+export declare function loadSpectorJS(props: {
+    spectorUrl?: string;
+}): Promise<void>;
+export declare function initializeSpectorJS(props: SpectorProps): Spector | null;
 export {};
 //# sourceMappingURL=spector.d.ts.map

package/dist/context/debug/spector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spector.d.ts","sourceRoot":"","sources":["../../../src/context/debug/spector.ts"],"names":[],"mappings":"AAOA,2CAA2C;AAC3C,KAAK,YAAY,GAAG;IAClB,wBAAwB;IACxB,MAAM,CAAC,EAAE,iBAAiB,GAAG,eAAe,CAAC;IAC7C,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kCAAkC;IAClC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;CACrC,CAAC;AAaF,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,OAAO,EAAE,GAAG,CAAC;CAClB;AAED,sDAAsD;AACtD,wBAAsB,aAAa,CAAC,KAAK,CAAC,EAAE,YAAY,iBAQvD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,EAAE,YAAY,OAsDvD"}
+{"version":3,"file":"spector.d.ts","sourceRoot":"","sources":["../../../src/context/debug/spector.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,OAAO,EAAC,2BAAwB;AAExC,2CAA2C;AAC3C,KAAK,YAAY,GAAG;IAClB,iCAAiC;IACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wBAAwB;IACxB,EAAE,CAAC,EAAE,sBAAsB,CAAC;CAC7B,CAAC;AAOF,OAAO,CAAC,MAAM,CAAC;IAGb,IAAI,OAAO,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,YAAY,CAOxD,CAAC;AAEF,sDAAsD;AACtD,wBAAsB,aAAa,CAAC,KAAK,EAAE;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ/E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,GAAG,IAAI,CAyDvE"}

package/dist/context/debug/spector.js

@@ -3,19 +3,22 @@
 // Copyright (c) vis.gl contributors
 import { log } from '@luma.gl/core';
 import { loadScript } from "../../utils/load-script.js";
-const DEFAULT_SPECTOR_PROPS = {
-    spector: log.get('spector') || log.get('inspect')
-};
-// https://github.com/BabylonJS/Spector.js#basic-usage
-const SPECTOR_CDN_URL = 'https://spectorcdn.babylonjs.com/spector.bundle.js';
 const LOG_LEVEL = 1;
 let spector = null;
 let initialized = false;
+export const DEFAULT_SPECTOR_PROPS = {
+    debugWithSpectorJS: log.get('spector') || 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: undefined
+};
 /** Loads spector from CDN if not already installed */
 export async function loadSpectorJS(props) {
     if (!globalThis.SPECTOR) {
         try {
-            await loadScript(SPECTOR_CDN_URL);
+            await loadScript(props.spectorUrl || DEFAULT_SPECTOR_PROPS.spectorUrl);
         }
         catch (error) {
             log.warn(String(error));
@@ -24,12 +27,13 @@ export async function loadSpectorJS(props) {
 }
 export function initializeSpectorJS(props) {
     props = { ...DEFAULT_SPECTOR_PROPS, ...props };
-    if (!props?.spector) {
+    if (!props.debugWithSpectorJS) {
         return null;
     }
-    if (!spector && globalThis.SPECTOR) {
-        log.probe(LOG_LEVEL, 'SPECTOR found and initialized')();
-        spector = new globalThis.SPECTOR.Spector();
+    if (!spector && globalThis.SPECTOR && !globalThis.luma?.spector) {
+        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;
         }
@@ -48,18 +52,20 @@ export function initializeSpectorJS(props) {
             // Use undocumented Spector API to open the UI with our capture
             // See https://github.com/BabylonJS/Spector.js/blob/767ad1195a25b85a85c381f400eb50a979239eca/src/spector.ts#L124
             spector?.getResultUI();
+            // @ts-expect-error private
             spector?.resultView.display();
+            // @ts-expect-error private
             spector?.resultView.addCapture(capture);
         });
     }
-    if (props?.canvas) {
-        // @ts-expect-error If spector is specified as a canvas id, only monitor that canvas
-        if (typeof props.spector === 'string' && props.spector !== props.canvas.id) {
-            return spector;
-        }
+    if (props.gl) {
         // capture startup
-        // spector?.captureCanvas(props?.canvas);
-        spector?.startCapture(props?.canvas, 500); // 500 commands
+        const gl = props.gl;
+        // @ts-expect-error
+        const device = gl.device;
+        spector?.startCapture(props.gl, 500); // 500 commands
+        // @ts-expect-error
+        gl.device = device;
         new Promise(resolve => setTimeout(resolve, 2000)).then(_ => {
             log.info('Spector capture stopped after 2 seconds')();
             spector?.stopCapture();

package/dist/context/polyfills/polyfill-webgl1-extensions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Make browser return WebGL2 contexts even if WebGL1 contexts are requested
+ * @param enforce
+ * @returns
+ */
+export declare function enforceWebGL2(enforce?: boolean): void;
+/** Install WebGL1-only extensions on WebGL2 contexts */
+export declare function polyfillWebGL1Extensions(gl: WebGL2RenderingContext): void;
+//# sourceMappingURL=polyfill-webgl1-extensions.d.ts.map

package/dist/context/polyfills/polyfill-webgl1-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfill-webgl1-extensions.d.ts","sourceRoot":"","sources":["../../../src/context/polyfills/polyfill-webgl1-extensions.ts"],"names":[],"mappings":"AA4EA;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,OAAc,GAAG,IAAI,CA0B3D;AAED,wDAAwD;AACxD,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,CAqCzE"}

package/dist/context/polyfills/polyfill-webgl1-extensions.js

@@ -0,0 +1,181 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Goal is to make WebGL2 contexts look like WebGL1
+// @note Partly inspired by with some older code from the `regl` library
+/* eslint-disable camelcase */
+import { GL } from '@luma.gl/constants';
+// webgl1 extensions natively supported by webgl2
+const 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: {}
+};
+const 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
+}); // - too many fields
+const 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);
+    }
+});
+const getANGLE_instanced_arrays = (gl) => ({
+    VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88fe,
+    drawArraysInstancedANGLE(...args) {
+        return gl.drawArraysInstanced(...args);
+    },
+    drawElementsInstancedANGLE(...args) {
+        return gl.drawElementsInstanced(...args);
+    },
+    vertexAttribDivisorANGLE(...args) {
+        return gl.vertexAttribDivisor(...args);
+    }
+});
+/**
+ * Make browser return WebGL2 contexts even if WebGL1 contexts are requested
+ * @param enforce
+ * @returns
+ */
+export function enforceWebGL2(enforce = true) {
+    const prototype = HTMLCanvasElement.prototype;
+    if (!enforce && prototype.originalGetContext) {
+        // Reset the original getContext function
+        prototype.getContext = prototype.originalGetContext;
+        prototype.originalGetContext = undefined;
+        return;
+    }
+    // Store the original getContext function
+    prototype.originalGetContext = prototype.getContext;
+    // Override the getContext function
+    prototype.getContext = function (contextId, options) {
+        // Attempt to force WebGL2 for all WebGL1 contexts
+        if (contextId === 'webgl' || contextId === 'experimental-webgl') {
+            const context = this.originalGetContext('webgl2', options);
+            // Work around test mocking
+            if (context instanceof HTMLElement) {
+                polyfillWebGL1Extensions(context);
+            }
+            return context;
+        }
+        // For any other type, return the original context
+        return this.originalGetContext(contextId, options);
+    };
+}
+/** Install WebGL1-only extensions on WebGL2 contexts */
+export function polyfillWebGL1Extensions(gl) {
+    // Enable, to support float and half-float textures
+    gl.getExtension('EXT_color_buffer_float');
+    // WebGL1 extensions implemented using WebGL2 APIs
+    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)
+    };
+    // Override gl.getExtension
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalGetExtension = gl.getExtension;
+    gl.getExtension = function (extensionName) {
+        const ext = originalGetExtension.call(gl, extensionName);
+        if (ext) {
+            return ext;
+        }
+        // Injected extensions
+        if (extensionName in boundExtensions) {
+            return boundExtensions[extensionName];
+        }
+        return null;
+    };
+    // Override gl.getSupportedExtensions
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalGetSupportedExtensions = gl.getSupportedExtensions;
+    gl.getSupportedExtensions = function () {
+        const extensions = originalGetSupportedExtensions.apply(gl) || [];
+        return extensions?.concat(Object.keys(boundExtensions));
+    };
+}
+// Update unsized WebGL1 formats to sized WebGL2 formats
+// todo move to texture format file
+// export function getInternalFormat(gl: WebGL2RenderingContext, format: GL, type: GL): GL {
+//   // webgl2 texture formats
+//   // https://webgl2fundamentals.org/webgl/lessons/webgl-data-textures.html
+//   switch (format) {
+//     case GL.DEPTH_COMPONENT:
+//       return GL.DEPTH_COMPONENT24;
+//     case GL.DEPTH_STENCIL:
+//       return GL.DEPTH24_STENCIL8;
+//     case GL.RGBA:
+//       return type === GL.HALF_FLOAT ? GL.RGBA16F : GL.RGBA32F;
+//     case GL.RGB:
+//       return type === GL.HALF_FLOAT ? GL.RGB16F : GL.RGB32F;
+//     default:
+//       return format;
+//   }
+// }
+/*
+// texture type to update on the fly
+export function getTextureType(gl: WebGL2RenderingContext, type: GL): GL {
+  if (type === HALF_FLOAT_OES) {
+    return GL.HALF_FLOAT;
+  }
+  return type;
+}
+
+  // And texImage2D to convert the internalFormat to webgl2.
+  const webgl2 = this;
+  const origTexImage = gl.texImage2D;
+  gl.texImage2D = function (target, miplevel, iformat, a, typeFor6, c, d, typeFor9, f) {
+    if (arguments.length == 6) {
+      var ifmt = webgl2.getInternalFormat(gl, iformat, typeFor6);
+      origTexImage.apply(gl, [target, miplevel, ifmt, a, webgl.getTextureType(gl, typeFor6), c]);
+    } else {
+      // arguments.length == 9
+      var ifmt = webgl2.getInternalFormat(gl, iformat, typeFor9);
+      origTexImage.apply(gl, [
+        target,
+        miplevel,
+        ifmt,
+        a,
+        typeFor6,
+        c,
+        d,
+        webgl2.getTextureType(gl, typeFor9),
+        f
+      ]);
+    }
+  };
+};
+*/

package/dist/context/state-tracker/webgl-state-tracker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Support for listening to context state changes and intercepting state queries
+ * NOTE: this system does not handle buffer bindings
+ */
+export declare class WebGLStateTracker {
+    static get(gl: WebGL2RenderingContext): WebGLStateTracker;
+    gl: WebGL2RenderingContext;
+    program: unknown;
+    stateStack: object[];
+    enable: boolean;
+    cache: Record<string, any>;
+    log: any;
+    protected initialized: boolean;
+    constructor(gl: WebGL2RenderingContext, props?: {
+        log: any;
+    });
+    push(values?: {}): void;
+    pop(): void;
+    /**
+     * 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: WebGL2RenderingContext, options?: {
+        copyState?: boolean;
+    }): void;
+    /**
+    // interceptor for context set functions - update our cache and our stack
+    // values (Object) - the key values for this setter
+     * @param values
+     * @returns
+     */
+    _updateCache(values: {
+        [key: number | string]: any;
+    }): {
+        valueChanged: boolean;
+        oldValue: any;
+    };
+}
+//# sourceMappingURL=webgl-state-tracker.d.ts.map

package/dist/context/state-tracker/webgl-state-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-state-tracker.d.ts","sourceRoot":"","sources":["../../../src/context/state-tracker/webgl-state-tracker.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,sBAAsB,GAAG,iBAAiB;IAKzD,EAAE,EAAE,sBAAsB,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAQ;IACxB,UAAU,EAAE,MAAM,EAAE,CAAM;IAC1B,MAAM,UAAQ;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAS;IACnC,GAAG,MAAC;IAEJ,SAAS,CAAC,WAAW,UAAS;gBAG5B,EAAE,EAAE,sBAAsB,EAC1B,KAAK,CAAC,EAAE;QACN,GAAG,MAAC;KACL;IASH,IAAI,CAAC,MAAM,KAAK;IAIhB,GAAG;IASH;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,CAAC,EAAE;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAC,GAAG,IAAI;IAwB7E;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,CAAA;KAAC;;;;CA8BnD"}

package/dist/context/state-tracker/{track-context-state.js → webgl-state-tracker.js}

@@ -1,26 +1,29 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-// Support for listening to context state changes and intercepting state queries
-// NOTE: this system does not handle buffer bindings
-import { GL_PARAMETER_DEFAULTS, GL_HOOKED_SETTERS, NON_CACHE_PARAMETERS } from "../parameters/webgl-parameter-tables.js";
 import { setGLParameters, getGLParameters } from "../parameters/unified-parameter-api.js";
 import { deepArrayEqual } from "./deep-array-equal.js";
-// HELPER CLASS - GLState
-/* eslint-disable no-shadow */
-class GLState {
+import { GL_PARAMETER_DEFAULTS, GL_HOOKED_SETTERS, NON_CACHE_PARAMETERS } from "../parameters/webgl-parameter-tables.js";
+// HELPER CLASS - WebGLStateTracker
+/**
+ * Support for listening to context state changes and intercepting state queries
+ * NOTE: this system does not handle buffer bindings
+ */
+export class WebGLStateTracker {
+    static get(gl) {
+        // @ts-expect-error
+        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 = () => { } // 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 = log;
+        this.log = props?.log || (() => { });
         this._updateCache = this._updateCache.bind(this);
         Object.seal(this);
     }
@@ -35,6 +38,32 @@ class GLState {
         // Don't pop until we have reset parameters (to make sure other "stack frames" are not affected)
         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;
+        // @ts-expect-error
+        this.gl.state = this;
+        installProgramSpy(gl);
+        // intercept all setter functions in the table
+        for (const key in GL_HOOKED_SETTERS) {
+            const setter = GL_HOOKED_SETTERS[key];
+            installSetterSpy(gl, key, setter);
+        }
+        // intercept all getter functions in the table
+        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
@@ -66,65 +95,6 @@ class GLState {
         return { valueChanged, oldValue };
     }
 }
-function getContextState(gl) {
-    // @ts-expect-error
-    return gl.state;
-}
-// PUBLIC API
-/**
- * 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
- * gl.state.push() and gl.state.pop() will be available for saving,
- * temporarily modifying, and then restoring state.
- */
-export function trackContextState(gl, options) {
-    const { enable = true, copyState } = options || {};
-    // assert(copyState !== undefined);
-    // @ts-expect-error
-    if (!gl.state) {
-        // @ts-ignore
-        // const {polyfillContext} = global_;
-        // if (polyfillContext) {
-        //   polyfillContext(gl);
-        // }
-        // Create a state cache
-        // @ts-expect-error
-        gl.state = new GLState(gl, { copyState });
-        installProgramSpy(gl);
-        // intercept all setter functions in the table
-        for (const key in GL_HOOKED_SETTERS) {
-            const setter = GL_HOOKED_SETTERS[key];
-            installSetterSpy(gl, key, setter);
-        }
-        // intercept all getter functions in the table
-        installGetterOverride(gl, 'getParameter');
-        installGetterOverride(gl, 'isEnabled');
-    }
-    const glState = getContextState(gl);
-    glState.enable = enable;
-    return gl;
-}
-/**
- * Saves current WebGL context state onto an internal per-context stack
- */
-export function pushContextState(gl) {
-    let glState = getContextState(gl);
-    if (!glState) {
-        trackContextState(gl, { copyState: false });
-        glState = getContextState(gl);
-    }
-    glState.push();
-}
-/**
- * Restores previously saved WebGL context state
- */
-export function popContextState(gl) {
-    const glState = getContextState(gl);
-    // assert(glState);
-    glState.pop();
-}
 // HELPER FUNCTIONS - INSTALL GET/SET INTERCEPTORS (SPYS) ON THE CONTEXT
 /**
 // Overrides a WebGL2RenderingContext state "getter" function
@@ -141,7 +111,7 @@ function installGetterOverride(gl, functionName) {
             // Invalid or blacklisted parameter, do not cache
             return originalGetterFunc(pname);
         }
-        const glState = getContextState(gl);
+        const glState = WebGLStateTracker.get(gl);
         if (!(pname in glState.cache)) {
             // WebGL limits are not prepopulated in the cache, call the original getter when first queried.
             glState.cache[pname] = originalGetterFunc(pname);
@@ -180,7 +150,7 @@ function installSetterSpy(gl, functionName, setter) {
     gl[functionName] = function set(...params) {
         // Update the value
         // Call the setter with the state cache and the params so that it can store the parameters
-        const glState = getContextState(gl);
+        const glState = WebGLStateTracker.get(gl);
         // eslint-disable-next-line @typescript-eslint/unbound-method
         const { valueChanged, oldValue } = setter(glState._updateCache, ...params);
         // Call the original WebGL2RenderingContext func to make sure the context actually gets updated
@@ -202,7 +172,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;

package/dist/context/state-tracker/with-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"with-parameters.d.ts","sourceRoot":"","sources":["../../../src/context/state-tracker/with-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAkB,+CAA4C;AAGlF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,sBAAsB,EAC1B,UAAU,EAAE,YAAY,GAAG;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,EAC9C,IAAI,EAAE,GAAG,GACR,GAAG,CA4BL"}
+{"version":3,"file":"with-parameters.d.ts","sourceRoot":"","sources":["../../../src/context/state-tracker/with-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAkB,+CAA4C;AAGlF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,sBAAsB,EAC1B,UAAU,EAAE,YAAY,GAAG;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,EAC9C,IAAI,EAAE,GAAG,GACR,GAAG,CA6BL"}

package/dist/context/state-tracker/with-parameters.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { setGLParameters } from "../parameters/unified-parameter-api.js";
-import { pushContextState, popContextState } from "./track-context-state.js";
+import { WebGLStateTracker } from "./webgl-state-tracker.js";
 /**
  * Execute a function with a set of temporary WebGL parameter overrides
  * - Saves current "global" WebGL context settings
@@ -17,14 +17,15 @@ export function withGLParameters(gl, parameters, func) {
         return func(gl);
     }
     const { nocatch = true } = parameters;
-    pushContextState(gl);
+    const webglState = WebGLStateTracker.get(gl);
+    webglState.push();
     setGLParameters(gl, parameters);
     // Setup is done, call the function
     let value;
     if (nocatch) {
         // Avoid try catch to minimize stack size impact for safe execution paths
         value = func(gl);
-        popContextState(gl);
+        webglState.pop();
     }
     else {
         // Wrap in a try-catch to ensure that parameters are restored on exceptions
@@ -32,7 +33,7 @@ export function withGLParameters(gl, parameters, func) {
             value = func(gl);
         }
         finally {
-            popContextState(gl);
+            webglState.pop();
         }
     }
     return value;