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

package/src/context/debug/spector.ts

@@ -2,56 +2,64 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {log, loadScript} from '@luma.gl/core';
+import {log} from '@luma.gl/core';
+import {loadScript} from '../../utils/load-script';
+
+import {Spector} from './spector-types';
 
 /** 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;
-};
-
-const DEFAULT_SPECTOR_PROPS: SpectorProps = {
-  spector: log.get('spector') || log.get('spectorjs')
+  gl?: WebGL2RenderingContext;
 };
 
-// https://github.com/BabylonJS/Spector.js#basic-usage
-const SPECTOR_CDN_URL = 'https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js';
 const LOG_LEVEL = 1;
 
-let spector: any = null;
+let spector: Spector = null;
 let initialized: boolean = false;
 
 declare global {
+  // @ts-ignore
   // eslint-disable-next-line no-var
-  var SPECTOR: any;
+  var SPECTOR: Spector;
 }
 
+export const DEFAULT_SPECTOR_PROPS: Required<SpectorProps> = {
+  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?: SpectorProps) {
+export async function loadSpectorJS(props: {spectorUrl?: string}): Promise<void> {
   if (!globalThis.SPECTOR) {
     try {
-      await loadScript(SPECTOR_CDN_URL);
+      await loadScript(props.spectorUrl || DEFAULT_SPECTOR_PROPS.spectorUrl);
     } catch (error) {
       log.warn(String(error));
     }
   }
 }
 
-export function initializeSpectorJS(props?: SpectorProps) {
+export function initializeSpectorJS(props: SpectorProps): Spector | null {
   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 as any;
+    spector = new Spector();
     if (globalThis.luma) {
-      globalThis.luma.spector = spector;
+      (globalThis.luma as any).spector = spector;
     }
   }
 
@@ -73,20 +81,22 @@ export function initializeSpectorJS(props?: SpectorProps) {
       // 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/src/context/debug/webgl-developer-tools.ts

@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {log, loadScript} from '@luma.gl/core';
+import {log} from '@luma.gl/core';
 // Rename constant to prevent inlining. We need the full set of constants for generating debug strings.
 import {GL as GLEnum} from '@luma.gl/constants';
 import {isBrowser} from '@probe.gl/env';
+import {loadScript} from '../../utils/load-script';
 
 const WEBGL_DEBUG_CDN_URL = 'https://unpkg.com/webgl-debug@2.0.1/index.js';
 
@@ -58,12 +59,7 @@ export async function loadWebGLDeveloperTools(): Promise<void> {
 export function makeDebugContext(
   gl: WebGL2RenderingContext,
   props: DebugContextProps = {}
-): WebGL2RenderingContext | null {
-  // Return null to ensure we don't try to create a context in this case (TODO what case is that?)
-  if (!gl) {
-    return null;
-  }
-
+): WebGL2RenderingContext {
   return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
 }
 

package/src/context/parameters/webgl-parameter-tables.ts

@@ -100,7 +100,7 @@ const pixelStorei = (gl: WebGL2RenderingContext, value: number | boolean, key: G
 
 const bindFramebuffer = (gl: WebGL2RenderingContext, value: unknown, key: GL) => {
   const target = key === GL.FRAMEBUFFER_BINDING ? GL.DRAW_FRAMEBUFFER : GL.READ_FRAMEBUFFER;
-  return gl.bindFramebuffer(target, value);
+  return gl.bindFramebuffer(target, value as WebGLFramebuffer);
 };
 
 const bindBuffer = (gl: WebGL2RenderingContext, value: unknown, key: GL) => {
@@ -113,7 +113,7 @@ const bindBuffer = (gl: WebGL2RenderingContext, value: unknown, key: GL) => {
   };
   const glTarget = bindingMap[key];
 
-  gl.bindBuffer(glTarget, value);
+  gl.bindBuffer(glTarget as number, value as WebGLBuffer | null);
 };
 
 // Utility
@@ -304,7 +304,7 @@ export const GL_PARAMETER_SETTERS = {
     gl.polygonOffset(...value),
 
   sampleCoverage: (gl: WebGL2RenderingContext, value: [number, boolean?]) =>
-    gl.sampleCoverage(...value),
+    gl.sampleCoverage(value[0], value[1] || false),
 
   scissorTest: (gl: WebGL2RenderingContext, value) =>
     value ? gl.enable(GL.SCISSOR_TEST) : gl.disable(GL.SCISSOR_TEST),

package/src/context/polyfills/polyfill-webgl1-extensions.ts

@@ -0,0 +1,202 @@
+// 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: GL.UNSIGNED_INT_24_8
+  } as const satisfies WEBGL_depth_texture,
+  OES_element_index_uint: {} as const satisfies OES_element_index_uint,
+  OES_texture_float: {} as const satisfies OES_texture_float,
+  OES_texture_half_float: {
+    // @ts-expect-error different numbers?
+    HALF_FLOAT_OES: GL.HALF_FLOAT
+  } as const satisfies OES_texture_half_float,
+  EXT_color_buffer_float: {} as const satisfies EXT_color_buffer_float,
+  OES_standard_derivatives: {
+    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: GL.FRAGMENT_SHADER_DERIVATIVE_HINT
+  } as const satisfies OES_standard_derivatives,
+  EXT_frag_depth: {} as const satisfies EXT_frag_depth,
+  EXT_blend_minmax: {
+    MIN_EXT: GL.MIN,
+    MAX_EXT: GL.MAX
+  } as const satisfies EXT_blend_minmax,
+  EXT_shader_texture_lod: {} as const satisfies EXT_shader_texture_lod
+};
+
+const getWEBGL_draw_buffers = (gl: WebGL2RenderingContext) =>
+  ({
+    drawBuffersWEBGL(buffers: number[]) {
+      return gl.drawBuffers(buffers);
+    },
+    COLOR_ATTACHMENT0_WEBGL: GL.COLOR_ATTACHMENT0,
+    COLOR_ATTACHMENT1_WEBGL: GL.COLOR_ATTACHMENT1,
+    COLOR_ATTACHMENT2_WEBGL: GL.COLOR_ATTACHMENT2,
+    COLOR_ATTACHMENT3_WEBGL: GL.COLOR_ATTACHMENT3
+  }) as const satisfies Partial<WEBGL_draw_buffers>; // - too many fields
+
+const getOES_vertex_array_object = (gl: WebGL2RenderingContext) =>
+  ({
+    VERTEX_ARRAY_BINDING_OES: GL.VERTEX_ARRAY_BINDING,
+    createVertexArrayOES() {
+      return gl.createVertexArray();
+    },
+    deleteVertexArrayOES(vertexArray: WebGLVertexArrayObject): void {
+      return gl.deleteVertexArray(vertexArray);
+    },
+    isVertexArrayOES(vertexArray: WebGLVertexArrayObject): boolean {
+      return gl.isVertexArray(vertexArray);
+    },
+    bindVertexArrayOES(vertexArray: WebGLVertexArrayObject): void {
+      return gl.bindVertexArray(vertexArray);
+    }
+  }) as const satisfies OES_vertex_array_object;
+
+const getANGLE_instanced_arrays = (gl: WebGL2RenderingContext) =>
+  ({
+    VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88fe,
+    drawArraysInstancedANGLE(...args) {
+      return gl.drawArraysInstanced(...args);
+    },
+    drawElementsInstancedANGLE(...args) {
+      return gl.drawElementsInstanced(...args);
+    },
+    vertexAttribDivisorANGLE(...args) {
+      return gl.vertexAttribDivisor(...args);
+    }
+  }) as const satisfies ANGLE_instanced_arrays;
+
+/**
+ * Make browser return WebGL2 contexts even if WebGL1 contexts are requested
+ * @param enforce
+ * @returns
+ */
+export function enforceWebGL2(enforce: boolean = true): void {
+  const prototype = HTMLCanvasElement.prototype as any;
+  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: string, options?: WebGLContextAttributes) {
+    // Attempt to force WebGL2 for all WebGL1 contexts
+    if (contextId === 'webgl' || contextId === 'experimental-webgl') {
+      const context = this.originalGetContext('webgl2', options) as WebGL2RenderingContext;
+      // 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: WebGL2RenderingContext): void {
+  // 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: string) {
+    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 (): string[] | null {
+    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/src/context/state-tracker/{track-context-state.ts → webgl-state-tracker.ts}

@@ -2,38 +2,43 @@
 // 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 {assert} from '@luma.gl/core';
+import {setGLParameters, getGLParameters} from '../parameters/unified-parameter-api';
+import {deepArrayEqual} from './deep-array-equal';
 import {
   GL_PARAMETER_DEFAULTS,
   GL_HOOKED_SETTERS,
   NON_CACHE_PARAMETERS
 } from '../parameters/webgl-parameter-tables';
-import {setGLParameters, getGLParameters} from '../parameters/unified-parameter-api';
-import {deepArrayEqual} from './deep-array-equal';
 
-// HELPER CLASS - GLState
+// 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: WebGL2RenderingContext): WebGLStateTracker {
+    // @ts-expect-error
+    return gl.state as WebGLStateTracker;
+  }
 
-/* eslint-disable no-shadow */
-class GLState {
   gl: WebGL2RenderingContext;
   program: unknown = null;
   stateStack: object[] = [];
   enable = true;
-  cache: Record<string, any>;
+  cache: Record<string, any> = null!;
   log;
 
+  protected initialized = false;
+
   constructor(
     gl: WebGL2RenderingContext,
-    {
-      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
-    } = {}
+    props?: {
+      log; // Logging function, called when gl parameter change calls are actually issued
+    }
   ) {
     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);
@@ -44,7 +49,7 @@ class GLState {
   }
 
   pop() {
-    assert(this.stateStack.length > 0);
+    // assert(this.stateStack.length > 0);
     // Use the saved values in the state stack to restore parameters
     const oldValues = this.stateStack[this.stateStack.length - 1];
     setGLParameters(this.gl, oldValues);
@@ -52,6 +57,38 @@ class GLState {
     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: WebGL2RenderingContext, options?: {copyState?: boolean}): void {
+    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,7 +103,7 @@ class GLState {
       this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
 
     for (const key in values) {
-      assert(key !== undefined);
+      // assert(key !== undefined);
       const value = values[key];
       const cached = this.cache[key];
       // Check that value hasn't already been shadowed
@@ -90,83 +127,6 @@ class GLState {
   }
 }
 
-function getContextState(gl: WebGL2RenderingContext): GLState {
-  // @ts-expect-error
-  return gl.state as GLState;
-}
-
-// 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: WebGL2RenderingContext,
-  options?: {
-    enable?: boolean;
-    copyState?: boolean;
-    log?: any;
-  }
-): WebGL2RenderingContext {
-  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: WebGL2RenderingContext): void {
-  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: WebGL2RenderingContext): void {
-  const glState = getContextState(gl);
-  assert(glState);
-  glState.pop();
-}
-
 // HELPER FUNCTIONS - INSTALL GET/SET INTERCEPTORS (SPYS) ON THE CONTEXT
 
 /**
@@ -186,7 +146,7 @@ function installGetterOverride(gl: WebGL2RenderingContext, functionName: string)
       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);
@@ -230,7 +190,7 @@ function installSetterSpy(gl: WebGL2RenderingContext, functionName: string, sett
   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);
 
@@ -258,7 +218,7 @@ function installProgramSpy(gl: WebGL2RenderingContext): void {
   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/src/context/state-tracker/with-parameters.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {GLParameters, setGLParameters} from '../parameters/unified-parameter-api';
-import {pushContextState, popContextState} from './track-context-state';
+import {WebGLStateTracker} from './webgl-state-tracker';
 
 /**
  * Execute a function with a set of temporary WebGL parameter overrides
@@ -25,7 +25,8 @@ export function withGLParameters(
 
   const {nocatch = true} = parameters;
 
-  pushContextState(gl);
+  const webglState = WebGLStateTracker.get(gl);
+  webglState.push();
   setGLParameters(gl, parameters);
 
   // Setup is done, call the function
@@ -34,13 +35,13 @@ export function withGLParameters(
   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
     try {
       value = func(gl);
     } finally {
-      popContextState(gl);
+      webglState.pop();
     }
   }
 

package/src/index.ts

@@ -12,11 +12,14 @@
 export type {WebGLDeviceLimits} from './adapter/device-helpers/webgl-device-limits';
 
 // WebGL adapter classes
+export {webgl2Adapter} from './adapter/webgl-adapter';
+export type {WebGLAdapter} from './adapter/webgl-adapter';
+
+// WebGL Device classes
 export {WebGLDevice} from './adapter/webgl-device';
 export {WebGLCanvasContext} from './adapter/webgl-canvas-context';
 
 // WebGL Resource classes
-export {WebGLResource, WebGLResource as WEBGLResource} from './adapter/objects/webgl-resource';
 export {WEBGLBuffer} from './adapter/resources/webgl-buffer';
 export {WEBGLTexture} from './adapter/resources/webgl-texture';
 // export {WEBGLExternalTexture} from './adapter/resources/webgl-external-texture';
@@ -44,23 +47,12 @@ export {setDeviceParameters, withDeviceParameters} from './adapter/converters/de
 
 // HELPERS - EXPERIMENTAL
 export {getShaderLayout} from './adapter/helpers/get-shader-layout';
-export {convertGLToTextureFormat} from './adapter/converters/texture-formats';
-
-// Internal WebGL classes
-export type {RenderbufferProps as _RenderbufferProps} from './adapter/objects/webgl-renderbuffer';
-export {WEBGLRenderbuffer as _WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
+export {WebGLStateTracker} from './context/state-tracker/webgl-state-tracker';
 
 // TEST EXPORTS
 export {TEXTURE_FORMATS as _TEXTURE_FORMATS} from './adapter/converters/texture-formats';
 
 // DEPRECATED TEST EXPORTS
-// State tracking
-export {
-  trackContextState,
-  pushContextState,
-  popContextState
-} from './context/state-tracker/track-context-state';
-
 export {
   resetGLParameters,
   setGLParameters,