@luma.gl/webgl 9.0.0-beta.4 → 9.0.0-beta.5

package/dist/context/state-tracker/deep-array-equal.js

@@ -1,17 +1,21 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+/** deeply compare two arrays */
 export function deepArrayEqual(x, y) {
-  if (x === y) {
-    return true;
-  }
-  const isArrayX = Array.isArray(x) || ArrayBuffer.isView(x);
-  const isArrayY = Array.isArray(y) || ArrayBuffer.isView(y);
-  if (isArrayX && isArrayY && x.length === y.length) {
-    for (let i = 0; i < x.length; ++i) {
-      if (x[i] !== y[i]) {
-        return false;
-      }
+    if (x === y) {
+        return true;
     }
-    return true;
-  }
-  return false;
+    const isArrayX = Array.isArray(x) || ArrayBuffer.isView(x);
+    const isArrayY = Array.isArray(y) || ArrayBuffer.isView(y);
+    // @ts-expect-error TODO fix
+    if (isArrayX && isArrayY && x.length === y.length) {
+        // @ts-expect-error TODO fix
+        for (let i = 0; i < x.length; ++i) {
+            if (x[i] !== y[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
 }
-//# sourceMappingURL=deep-array-equal.js.map

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

@@ -6,17 +6,17 @@
  * gl.state.push() and gl.state.pop() will be available for saving,
  * temporarily modifying, and then restoring state.
  */
-export declare function trackContextState(gl: WebGLRenderingContext, options?: {
+export declare function trackContextState(gl: WebGL2RenderingContext, options?: {
     enable?: boolean;
     copyState?: boolean;
     log?: any;
-}): WebGLRenderingContext;
+}): WebGL2RenderingContext;
 /**
  * Saves current WebGL context state onto an internal per-context stack
  */
-export declare function pushContextState(gl: WebGLRenderingContext): void;
+export declare function pushContextState(gl: WebGL2RenderingContext): void;
 /**
  * Restores previously saved WebGL context state
  */
-export declare function popContextState(gl: WebGLRenderingContext): void;
+export declare function popContextState(gl: WebGL2RenderingContext): void;
 //# sourceMappingURL=track-context-state.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"track-context-state.d.ts","sourceRoot":"","sources":["../../../src/context/state-tracker/track-context-state.ts"],"names":[],"mappings":"AA6FA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,qBAAqB,EACzB,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,GAAG,CAAC,EAAE,GAAG,CAAC;CACX,GACA,qBAAqB,CAgCvB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,qBAAqB,GAAG,IAAI,CAOhE;AAGD;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,qBAAqB,GAAG,IAAI,CAI/D"}
+{"version":3,"file":"track-context-state.d.ts","sourceRoot":"","sources":["../../../src/context/state-tracker/track-context-state.ts"],"names":[],"mappings":"AA6FA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,sBAAsB,EAC1B,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,GAAG,CAAC,EAAE,GAAG,CAAC;CACX,GACA,sBAAsB,CAgCxB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,CAOjE;AAGD;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,CAIhE"}

package/dist/context/state-tracker/track-context-state.js

@@ -1,147 +1,211 @@
+// luma.gl, MIT license
+// 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 { 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";
+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
+/* eslint-disable no-shadow */
 class GLState {
-  constructor(gl) {
-    let {
-      copyState = false,
-      log = () => {}
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    this.gl = void 0;
-    this.program = null;
-    this.stateStack = [];
-    this.enable = true;
-    this.cache = void 0;
-    this.log = void 0;
-    this.gl = gl;
-    this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
-    this.log = log;
-    this._updateCache = this._updateCache.bind(this);
-    Object.seal(this);
-  }
-  push() {
-    let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.stateStack.push({});
-  }
-  pop() {
-    assert(this.stateStack.length > 0);
-    const oldValues = this.stateStack[this.stateStack.length - 1];
-    setGLParameters(this.gl, oldValues);
-    this.stateStack.pop();
-  }
-  _updateCache(values) {
-    let valueChanged = false;
-    let oldValue;
-    const oldValues = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
-    for (const key in values) {
-      assert(key !== undefined);
-      const value = values[key];
-      const cached = this.cache[key];
-      if (!deepArrayEqual(value, cached)) {
-        valueChanged = true;
-        oldValue = cached;
-        if (oldValues && !(key in oldValues)) {
-          oldValues[key] = cached;
+    gl;
+    program = null;
+    stateStack = [];
+    enable = true;
+    cache;
+    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
+     } = {}) {
+        this.gl = gl;
+        this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+        this.log = log;
+        this._updateCache = this._updateCache.bind(this);
+        Object.seal(this);
+    }
+    push(values = {}) {
+        this.stateStack.push({});
+    }
+    pop() {
+        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);
+        // Don't pop until we have reset parameters (to make sure other "stack frames" are not affected)
+        this.stateStack.pop();
+    }
+    /**
+    // interceptor for context set functions - update our cache and our stack
+    // values (Object) - the key values for this setter
+     * @param values
+     * @returns
+     */
+    _updateCache(values) {
+        let valueChanged = false;
+        let oldValue; // = undefined
+        const oldValues = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
+        for (const key in values) {
+            assert(key !== undefined);
+            const value = values[key];
+            const cached = this.cache[key];
+            // Check that value hasn't already been shadowed
+            if (!deepArrayEqual(value, cached)) {
+                valueChanged = true;
+                oldValue = cached;
+                // First, save current value being shadowed
+                // If a state stack frame is active, save the current parameter values for pop
+                // but first check that value hasn't already been shadowed and saved
+                if (oldValues && !(key in oldValues)) {
+                    oldValues[key] = cached;
+                }
+                // Save current value being shadowed
+                this.cache[key] = value;
+            }
         }
-        this.cache[key] = value;
-      }
+        return { valueChanged, oldValue };
     }
-    return {
-      valueChanged,
-      oldValue
-    };
-  }
 }
 function getContextState(gl) {
-  return gl.state;
+    // @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);
-  if (!gl.state) {
-    gl.state = new GLState(gl, {
-      copyState
-    });
-    installProgramSpy(gl);
-    for (const key in GL_HOOKED_SETTERS) {
-      const setter = GL_HOOKED_SETTERS[key];
-      installSetterSpy(gl, key, setter);
+    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');
     }
-    installGetterOverride(gl, 'getParameter');
-    installGetterOverride(gl, 'isEnabled');
-  }
-  const glState = getContextState(gl);
-  glState.enable = enable;
-  return gl;
+    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();
+    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();
+    const glState = getContextState(gl);
+    assert(glState);
+    glState.pop();
 }
+// HELPER FUNCTIONS - INSTALL GET/SET INTERCEPTORS (SPYS) ON THE CONTEXT
+/**
+// Overrides a WebGL2RenderingContext state "getter" function
+// to return values directly from cache
+ * @param gl
+ * @param functionName
+ */
 function installGetterOverride(gl, functionName) {
-  const originalGetterFunc = gl[functionName].bind(gl);
-  gl[functionName] = function get(pname) {
-    if (pname === undefined || NON_CACHE_PARAMETERS.has(pname)) {
-      return originalGetterFunc(pname);
-    }
-    const glState = getContextState(gl);
-    if (!(pname in glState.cache)) {
-      glState.cache[pname] = originalGetterFunc(pname);
-    }
-    return glState.enable ? glState.cache[pname] : originalGetterFunc(pname);
-  };
-  Object.defineProperty(gl[functionName], 'name', {
-    value: `${functionName}-from-cache`,
-    configurable: false
-  });
+    // Get the original function from the WebGL2RenderingContext
+    const originalGetterFunc = gl[functionName].bind(gl);
+    // Wrap it with a spy so that we can update our state cache when it gets called
+    gl[functionName] = function get(pname) {
+        if (pname === undefined || NON_CACHE_PARAMETERS.has(pname)) {
+            // Invalid or blacklisted parameter, do not cache
+            return originalGetterFunc(pname);
+        }
+        const glState = getContextState(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);
+        }
+        // Optionally call the original function to do a "hard" query from the WebGL2RenderingContext
+        return glState.enable
+            ? // Call the getter the params so that it can e.g. serve from a cache
+                glState.cache[pname]
+            : // Optionally call the original function to do a "hard" query from the WebGL2RenderingContext
+                originalGetterFunc(pname);
+    };
+    // Set the name of this anonymous function to help in debugging and profiling
+    Object.defineProperty(gl[functionName], 'name', {
+        value: `${functionName}-from-cache`,
+        configurable: false
+    });
 }
+/**
+// Overrides a WebGL2RenderingContext state "setter" function
+// to call a setter spy before the actual setter. Allows us to keep a cache
+// updated with a copy of the WebGL context state.
+ * @param gl
+ * @param functionName
+ * @param setter
+ * @returns
+ */
 function installSetterSpy(gl, functionName, setter) {
-  if (!gl[functionName]) {
-    return;
-  }
-  const originalSetterFunc = gl[functionName].bind(gl);
-  gl[functionName] = function set() {
-    const glState = getContextState(gl);
-    for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
-      params[_key] = arguments[_key];
-    }
-    const {
-      valueChanged,
-      oldValue
-    } = setter(glState._updateCache, ...params);
-    if (valueChanged) {
-      originalSetterFunc(...params);
+    // Get the original function from the WebGL2RenderingContext
+    if (!gl[functionName]) {
+        // TODO - remove?
+        // This could happen if we try to intercept WebGL2 method on a WebGL1 context
+        return;
     }
-    return oldValue;
-  };
-  Object.defineProperty(gl[functionName], 'name', {
-    value: `${functionName}-to-cache`,
-    configurable: false
-  });
+    const originalSetterFunc = gl[functionName].bind(gl);
+    // Wrap it with a spy so that we can update our state cache when it gets called
+    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);
+        // 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
+        if (valueChanged) {
+            originalSetterFunc(...params);
+        }
+        // Note: if the original function fails to set the value, our state cache will be bad
+        // No solution for this at the moment, but assuming that this is unlikely to be a real problem
+        // We could call the setter after the originalSetterFunc. Concern is that this would
+        // cause different behavior in debug mode, where originalSetterFunc can throw exceptions
+        return oldValue;
+    };
+    // Set the name of this anonymous function to help in debugging and profiling
+    Object.defineProperty(gl[functionName], 'name', {
+        value: `${functionName}-to-cache`,
+        configurable: false
+    });
 }
 function installProgramSpy(gl) {
-  const originalUseProgram = gl.useProgram.bind(gl);
-  gl.useProgram = function useProgramLuma(handle) {
-    const glState = getContextState(gl);
-    if (glState.program !== handle) {
-      originalUseProgram(handle);
-      glState.program = handle;
-    }
-  };
+    const originalUseProgram = gl.useProgram.bind(gl);
+    gl.useProgram = function useProgramLuma(handle) {
+        const glState = getContextState(gl);
+        if (glState.program !== handle) {
+            originalUseProgram(handle);
+            glState.program = handle;
+        }
+    };
 }
-//# sourceMappingURL=track-context-state.js.map

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

@@ -8,7 +8,7 @@ import { GLParameters } from '../parameters/unified-parameter-api';
  * - Restores parameters
  * - Returns the return value of the supplied function
  */
-export declare function withGLParameters(device: Device | WebGLRenderingContext, parameters: GLParameters & {
+export declare function withGLParameters(device: Device | WebGL2RenderingContext, parameters: GLParameters & {
     nocatch?: boolean;
 }, func: any): any;
 //# sourceMappingURL=with-parameters.d.ts.map

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":"AAGA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAC,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAGlF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,EAAE,UAAU,EAAE,YAAY,GAAG;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,CA+BvI"}
+{"version":3,"file":"with-parameters.d.ts","sourceRoot":"","sources":["../../../src/context/state-tracker/with-parameters.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAC,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAGlF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,EAAE,UAAU,EAAE,YAAY,GAAG;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,CA+BxI"}

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

@@ -1,34 +1,50 @@
-import { WebGLDevice } from "../../adapter/webgl-device.js";
-import { setGLParameters } from "../parameters/unified-parameter-api.js";
-import { pushContextState, popContextState } from "./track-context-state.js";
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+import { WebGLDevice } from '../../adapter/webgl-device';
+import { setGLParameters } from '../parameters/unified-parameter-api';
+import { pushContextState, popContextState } from './track-context-state';
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ */
 export function withGLParameters(device, parameters, func) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
-  if (isObjectEmpty(parameters)) {
-    return func(device);
-  }
-  const {
-    nocatch = true
-  } = parameters;
-  pushContextState(gl);
-  setGLParameters(gl, parameters);
-  let value;
-  if (nocatch) {
-    value = func(gl);
-    popContextState(gl);
-  } else {
-    try {
-      value = func(gl);
-    } finally {
-      popContextState(gl);
+    const webglDevice = WebGLDevice.attach(device);
+    const gl = webglDevice.gl;
+    if (isObjectEmpty(parameters)) {
+        // Avoid setting state if no parameters provided. Just call and return
+        return func(device);
     }
-  }
-  return value;
+    const { nocatch = true } = parameters;
+    pushContextState(gl);
+    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);
+    }
+    else {
+        // Wrap in a try-catch to ensure that parameters are restored on exceptions
+        try {
+            value = func(gl);
+        }
+        finally {
+            popContextState(gl);
+        }
+    }
+    return value;
 }
+// Helpers
+// Returns true if given object is empty, false otherwise.
 function isObjectEmpty(object) {
-  for (const key in object) {
-    return false;
-  }
-  return true;
+    // @ts-ignore - dummy key variable
+    for (const key in object) {
+        return false;
+    }
+    return true;
 }
-//# sourceMappingURL=with-parameters.js.map