@luma.gl/webgl 9.1.9 → 9.2.0-alpha.2

package/src/adapter/resources/webgl-transform-feedback.ts

@@ -102,7 +102,7 @@ export class WEBGLTransformFeedback extends TransformFeedback {
     return location >= 0 ? this.buffers[location] : null;
   }
 
-  bind(funcOrHandle = this.handle) {
+  bind(funcOrHandle: (() => void) | WebGLTransformFeedback | null = this.handle) {
     if (typeof funcOrHandle !== 'function') {
       this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, funcOrHandle);
       return this;
@@ -148,7 +148,7 @@ export class WEBGLTransformFeedback extends TransformFeedback {
       return Number(locationOrName);
     }
 
-    for (const varying of this.layout.varyings) {
+    for (const varying of this.layout.varyings || []) {
       if (locationOrName === varying.name) {
         return varying.location;
       }

package/src/adapter/resources/webgl-vertex-array.ts

@@ -11,7 +11,7 @@ import {getBrowser} from '@probe.gl/env';
 import {WebGLDevice} from '../webgl-device';
 import {WEBGLBuffer} from '../resources/webgl-buffer';
 
-import {getGLFromVertexType} from '../converters/vertex-formats';
+import {getGLFromVertexType} from '../converters/webgl-vertex-formats';
 import {fillArray} from '../../utils/fill-array';
 
 /** VertexArrayObject wrapper */
@@ -25,7 +25,7 @@ export class WEBGLVertexArray extends VertexArray {
 
   /** Attribute 0 buffer constant */
   private buffer: WEBGLBuffer | null = null;
-  private bufferValue = null;
+  private bufferValue: TypedArray | null = null;
 
   /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
   static isConstantAttributeZeroSupported(device: Device): boolean {
@@ -233,7 +233,8 @@ export class WEBGLVertexArray extends VertexArray {
     this.buffer = this.buffer || this.device.createBuffer({byteLength});
 
     // Reallocate and update contents if needed
-    updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
+    // @ts-ignore TODO fix types
+    updateNeeded ||= !compareConstantArrayValues(constantValue, this.bufferValue);
 
     if (updateNeeded) {
       // Create a typed array that is big enough, and fill it with the required data

package/src/adapter/webgl-adapter.ts

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {WebGLDevice} from './webgl-device';
 import {Adapter, Device, DeviceProps, log} from '@luma.gl/core';
-import {WebGLDevice} from './webgl-device';
 import {enforceWebGL2} from '../context/polyfills/polyfill-webgl1-extensions';
 import {loadSpectorJS, DEFAULT_SPECTOR_PROPS} from '../context/debug/spector';
 import {loadWebGLDeveloperTools} from '../context/debug/webgl-developer-tools';
@@ -16,12 +16,13 @@ export class WebGLAdapter extends Adapter {
 
   constructor() {
     super();
-
     // Add spector default props to device default props, so that runtime settings are observed
     Device.defaultProps = {...Device.defaultProps, ...DEFAULT_SPECTOR_PROPS};
+  }
 
-    // @ts-ignore DEPRECATED For backwards compatibility luma.registerDevices
-    WebGLDevice.adapter = this;
+  /** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */
+  enforceWebGL2(enable: boolean): void {
+    enforceWebGL2(enable);
   }
 
   /** Check if WebGL 2 is available */
@@ -29,9 +30,17 @@ export class WebGLAdapter extends Adapter {
     return typeof WebGL2RenderingContext !== 'undefined';
   }
 
-  /** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */
-  enforceWebGL2(enable: boolean): void {
-    enforceWebGL2(enable);
+  override isDeviceHandle(handle: unknown): boolean {
+    // WebGL
+    if (typeof WebGL2RenderingContext !== 'undefined' && handle instanceof WebGL2RenderingContext) {
+      return true;
+    }
+
+    if (typeof WebGLRenderingContext !== 'undefined' && handle instanceof WebGLRenderingContext) {
+      log.warn('WebGL1 is not supported', handle)();
+    }
+
+    return false;
   }
 
   /**
@@ -42,11 +51,12 @@ export class WebGLAdapter extends Adapter {
    * @returns
    */
   async attach(gl: Device | WebGL2RenderingContext): Promise<WebGLDevice> {
+    const {WebGLDevice} = await import('./webgl-device');
     if (gl instanceof WebGLDevice) {
       return gl;
     }
     // @ts-expect-error
-    if (gl?.device instanceof Device) {
+    if (gl?.device instanceof WebGLDevice) {
       // @ts-expect-error
       return gl.device as WebGLDevice;
     }
@@ -63,40 +73,43 @@ export class WebGLAdapter extends Adapter {
   }
 
   async create(props: DeviceProps = {}): Promise<WebGLDevice> {
-    log.groupCollapsed(LOG_LEVEL, 'WebGLDevice created')();
+    const {WebGLDevice} = await import('./webgl-device');
 
-    const promises: Promise<unknown>[] = [];
+    log.groupCollapsed(LOG_LEVEL, 'WebGLDevice created')();
+    try {
+      const promises: Promise<unknown>[] = [];
 
-    // Load webgl and spector debug scripts from CDN if requested
-    if (props.debugWebGL || props.debug) {
-      promises.push(loadWebGLDeveloperTools());
-    }
+      // Load webgl and spector debug scripts from CDN if requested
+      if (props.debugWebGL || props.debug) {
+        promises.push(loadWebGLDeveloperTools());
+      }
 
-    if (props.debugSpectorJS) {
-      promises.push(loadSpectorJS(props));
-    }
+      if (props.debugSpectorJS) {
+        promises.push(loadSpectorJS(props));
+      }
 
-    // Wait for all the loads to settle before creating the context.
-    // The Device.create() functions are async, so in contrast to the constructor, we can `await` here.
-    const results = await Promise.allSettled(promises);
-    for (const result of results) {
-      if (result.status === 'rejected') {
-        log.error(`Failed to initialize debug libraries ${result.reason}`)();
+      // Wait for all the loads to settle before creating the context.
+      // The Device.create() functions are async, so in contrast to the constructor, we can `await` here.
+      const results = await Promise.allSettled(promises);
+      for (const result of results) {
+        if (result.status === 'rejected') {
+          log.error(`Failed to initialize debug libraries ${result.reason}`)();
+        }
       }
-    }
 
-    const device = new WebGLDevice(props);
+      const device = new WebGLDevice(props);
 
-    // Log some debug info about the newly created context
-    const message = `\
-${device._reused ? 'Reusing' : 'Created'} device with WebGL2 ${device.debug ? 'debug ' : ''}context: \
+      // Log some debug info about the newly created context
+      const message = `\
+${device._reused ? 'Reusing' : 'Created'} device with WebGL2 ${device.props.debug ? 'debug ' : ''}context: \
 ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-    log.probe(LOG_LEVEL, message)();
-    log.table(LOG_LEVEL, device.info)();
+      log.probe(LOG_LEVEL, message)();
+      log.table(LOG_LEVEL, device.info)();
 
-    log.groupEnd(LOG_LEVEL)();
-
-    return device;
+      return device;
+    } finally {
+      log.groupEnd(LOG_LEVEL)();
+    }
   }
 }
 

package/src/adapter/webgl-canvas-context.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {CanvasContextProps, TextureFormat} from '@luma.gl/core';
+import type {CanvasContextProps} from '@luma.gl/core';
 import {CanvasContext} from '@luma.gl/core';
 import {WebGLDevice} from './webgl-device';
 import {WEBGLFramebuffer} from './resources/webgl-framebuffer';
@@ -12,10 +12,8 @@ import {WEBGLFramebuffer} from './resources/webgl-framebuffer';
  */
 export class WebGLCanvasContext extends CanvasContext {
   readonly device: WebGLDevice;
-  readonly format: TextureFormat = 'rgba8unorm';
-  readonly depthStencilFormat: TextureFormat = 'depth24plus';
+  readonly handle: unknown = null;
 
-  presentationSize: [number, number];
   private _framebuffer: WEBGLFramebuffer | null = null;
 
   get [Symbol.toStringTag](): string {
@@ -26,57 +24,19 @@ export class WebGLCanvasContext extends CanvasContext {
     // Note: Base class creates / looks up the canvas (unless under Node.js)
     super(props);
     this.device = device;
-    this.presentationSize = [-1, -1];
+
+    // Base class constructor cannot access derived methods/fields, so we need to call these functions in the subclass constructor
     this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
-    this.update();
+    this._updateDevice();
   }
 
   getCurrentFramebuffer(): WEBGLFramebuffer {
-    this.update();
     // Setting handle to null returns a reference to the default framebuffer
     this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, {handle: null});
     return this._framebuffer;
   }
 
-  /** Resizes and updates render targets if necessary */
-  update() {
-    const size = this.getPixelSize();
-    const sizeChanged =
-      size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
-    if (sizeChanged) {
-      this.presentationSize = size;
-      this.resize();
-    }
-  }
-
-  /**
-   * Resize the canvas' drawing buffer.
-   *
-   * Can match the canvas CSS size, and optionally also consider devicePixelRatio
-   * Can be called every frame
-   *
-   * Regardless of size, the drawing buffer will always be scaled to the viewport, but
-   * for best visual results, usually set to either:
-   *  canvas CSS width x canvas CSS height
-   *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio
-   * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html
-   */
-  resize(options?: {width?: number; height?: number; useDevicePixels?: boolean | number}): void {
-    if (!this.device.gl) return;
+  // IMPLEMENTATION OF ABSTRACT METHODS
 
-    // Resize browser context .
-    if (this.canvas) {
-      const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels);
-      this.setDevicePixelRatio(devicePixelRatio, options);
-      return;
-    }
-  }
-
-  commit() {
-    // gl.commit was ultimately removed from the WebGL standard??
-    // if (this.offScreen && this.gl.commit) {
-    //   // @ts-expect-error gl.commit is not officially part of WebGL2RenderingContext
-    //   this.gl.commit();
-    // }
-  }
+  _updateDevice(): void {}
 }

package/src/adapter/webgl-device.ts

@@ -25,14 +25,12 @@ import type {
   RenderPipelineProps,
   ComputePipeline,
   ComputePipelineProps,
-  // RenderPass,
-  RenderPassProps,
-  ComputePass,
-  ComputePassProps,
   // CommandEncoder,
   CommandEncoderProps,
   TransformFeedbackProps,
-  QuerySetProps
+  QuerySetProps,
+  Resource,
+  VertexFormat
 } from '@luma.gl/core';
 import {Device, CanvasContext, log} from '@luma.gl/core';
 import type {GLExtensions} from '@luma.gl/constants';
@@ -53,9 +51,9 @@ import {WEBGLShader} from './resources/webgl-shader';
 import {WEBGLSampler} from './resources/webgl-sampler';
 import {WEBGLTexture} from './resources/webgl-texture';
 import {WEBGLFramebuffer} from './resources/webgl-framebuffer';
-import {WEBGLRenderPass} from './resources/webgl-render-pass';
 import {WEBGLRenderPipeline} from './resources/webgl-render-pipeline';
 import {WEBGLCommandEncoder} from './resources/webgl-command-encoder';
+import {WEBGLCommandBuffer} from './resources/webgl-command-buffer';
 import {WEBGLVertexArray} from './resources/webgl-vertex-array';
 import {WEBGLTransformFeedback} from './resources/webgl-transform-feedback';
 import {WEBGLQuerySet} from './resources/webgl-query-set';
@@ -71,9 +69,7 @@ import {getWebGLExtension} from '../context/helpers/webgl-extensions';
 
 /** WebGPU style Device API for a WebGL context */
 export class WebGLDevice extends Device {
-  //
   // Public `Device` API
-  //
 
   /** type of this device */
   readonly type = 'webgl';
@@ -83,20 +79,24 @@ export class WebGLDevice extends Device {
   readonly handle!: WebGL2RenderingContext;
   features!: WebGLDeviceFeatures;
   limits!: WebGLDeviceLimits;
-
   readonly info!: DeviceInfo;
   readonly canvasContext!: WebGLCanvasContext;
 
+  readonly preferredColorFormat = 'rgba8unorm';
+  readonly preferredDepthFormat = 'depth24plus';
+
+  commandEncoder!: WEBGLCommandEncoder;
+
   readonly lost: Promise<{reason: 'destroyed'; message: string}>;
 
   private _resolveContextLost?: (value: {reason: 'destroyed'; message: string}) => void;
 
   /** WebGL2 context. */
   readonly gl!: WebGL2RenderingContext;
-  readonly debug: boolean = false;
 
-  /** State used by luma.gl classes: TODO - move to canvasContext*/
-  readonly _canvasSizeInfo = {clientWidth: 0, clientHeight: 0, devicePixelRatio: 1};
+  /** Store constants */
+  // @ts-ignore TODO fix
+  _constants: (TypedArray | null)[];
 
   /** State used by luma.gl classes - TODO - not used? */
   readonly _extensions: GLExtensions = {};
@@ -109,10 +109,27 @@ export class WebGLDevice extends Device {
   // Public API
   //
 
+  override get [Symbol.toStringTag](): string {
+    return 'WebGLDevice';
+  }
+
+  override toString(): string {
+    return `${this[Symbol.toStringTag]}(${this.id})`;
+  }
+
+  override isVertexFormatSupported(format: VertexFormat): boolean {
+    switch (format) {
+      case 'unorm8x4-bgra':
+        return false;
+      default:
+        return true;
+    }
+  }
+
   constructor(props: DeviceProps) {
     super({...props, id: props.id || uid('webgl-device')});
 
-    const canvasContextProps = Device._getCanvasContextProps(props);
+    const canvasContextProps = Device._getCanvasContextProps(props)!;
 
     // WebGL requires a canvas to be created before creating the context
     if (!canvasContextProps) {
@@ -209,10 +226,6 @@ export class WebGLDevice extends Device {
       this.features.initializeFeatures();
     }
 
-    if (canvasContextProps.autoResize !== false) {
-      this.canvasContext.resize();
-    }
-
     // Install context state tracking
     const glState = new WebGLStateTracker(this.gl, {
       log: (...args: any[]) => log.log(1, ...args)()
@@ -229,6 +242,8 @@ export class WebGLDevice extends Device {
         log.level = Math.max(log.level, 1);
       }
     }
+
+    this.commandEncoder = new WEBGLCommandEncoder(this, {id: `${this}-command-encoder`});
   }
 
   /**
@@ -259,6 +274,10 @@ export class WebGLDevice extends Device {
 
   // IMPLEMENTATION OF ABSTRACT DEVICE
 
+  getTextureByteAlignment(): number {
+    return 4;
+  }
+
   createCanvasContext(props?: CanvasContextProps): CanvasContext {
     throw new Error('WebGL only supports a single canvas');
   }
@@ -304,20 +323,10 @@ export class WebGLDevice extends Device {
     return new WEBGLRenderPipeline(this, props);
   }
 
-  beginRenderPass(props: RenderPassProps): WEBGLRenderPass {
-    return new WEBGLRenderPass(this, props);
-  }
-
   createComputePipeline(props?: ComputePipelineProps): ComputePipeline {
     throw new Error('ComputePipeline not supported in WebGL');
   }
 
-  beginComputePass(props: ComputePassProps): ComputePass {
-    throw new Error('ComputePass not supported in WebGL');
-  }
-
-  private renderPass: WEBGLRenderPass | null = null;
-
   override createCommandEncoder(props: CommandEncoderProps = {}): WEBGLCommandEncoder {
     return new WEBGLCommandEncoder(this, props);
   }
@@ -327,10 +336,14 @@ export class WebGLDevice extends Device {
    * https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/commit
    * Chrome's offscreen canvas does not require gl.commit
    */
-  submit(): void {
-    this.renderPass?.end();
-    this.renderPass = null;
-    // this.canvasContext.commit();
+  submit(commandBuffer: WEBGLCommandBuffer): void {
+    if (!commandBuffer) {
+      commandBuffer = this.commandEncoder.finish();
+      this.commandEncoder.destroy();
+      this.commandEncoder = this.createCommandEncoder({id: `${this.id}-default-encoder`});
+    }
+
+    commandBuffer._executeCommands();
   }
 
   //
@@ -432,16 +445,6 @@ export class WebGLDevice extends Device {
     webglState.pop();
   }
 
-  /**
-   * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
-   * luma.gl ids and props can be inspected
-   */
-  setSpectorMetadata(handle: unknown, props: Record<string, unknown>) {
-    // @ts-expect-error
-    // eslint-disable-next-line camelcase
-    handle.__SPECTOR_Metadata = props;
-  }
-
   /**
    * Returns the GL.<KEY> constant that corresponds to a numeric value of a GL constant
    * Be aware that there are some duplicates especially for constants that are 0,
@@ -471,9 +474,6 @@ export class WebGLDevice extends Device {
     }, {});
   }
 
-  /** Store constants */
-  _constants: (TypedArray | null)[];
-
   /**
    * 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
@@ -512,6 +512,26 @@ export class WebGLDevice extends Device {
     getWebGLExtension(this.gl, name, this._extensions);
     return this._extensions;
   }
+
+  // INTERNAL SUPPORT METHODS FOR WEBGL RESOURCES
+
+  /**
+   * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
+   * luma.gl ids and props can be inspected
+   */
+  _setWebGLDebugMetadata(
+    handle: unknown,
+    resource: Resource<any>,
+    options: {spector: Record<string, unknown>}
+  ): void {
+    // @ts-expect-error
+    handle.luma = resource;
+
+    const spectorMetadata = {props: options.spector, id: options.spector['id']};
+    // @ts-expect-error
+    // eslint-disable-next-line camelcase
+    handle.__SPECTOR_Metadata = spectorMetadata;
+  }
 }
 
 /** Set constant float array attribute */

package/src/context/debug/spector-types.ts

@@ -1,6 +1,8 @@
 // Forked from https://github.com/BabylonJS/Spector.js/blob/master/dist/spector.d.ts
 /* eslint-disable camelcase, no-shadow */
 
+// @ts-nocheck
+
 interface IEvent<T> {
   add(callback: (element: T) => void, context?: any): number;
   remove(id: number): void;
@@ -1071,8 +1073,11 @@ export abstract class Spector {
   }
   protected static tryGetContextFromHelperField: unknown;
   protected static tryGetContextFromCanvas: unknown;
+  // @ts-ignore TODO
   readonly onCaptureStarted: IEvent<any>;
+  // @ts-ignore TODO
   readonly onCapture: IEvent<ICapture>;
+  // @ts-ignore TODO
   readonly onError: IEvent<string>;
   protected readonly logger;
   protected readonly timeSpy;

package/src/context/debug/spector.ts

@@ -19,7 +19,7 @@ type SpectorProps = {
 
 const LOG_LEVEL = 1;
 
-let spector: Spector = null;
+let spector: Spector | null = null;
 let initialized: boolean = false;
 
 declare global {

package/src/context/debug/webgl-developer-tools.ts

@@ -112,7 +112,7 @@ function getDebugContext(
 
 // DEBUG TRACING
 
-function getFunctionString(functionName: string, functionArgs): string {
+function getFunctionString(functionName: string, functionArgs: unknown[]): string {
   // Cover bug in webgl-debug-tools
   functionArgs = Array.from(functionArgs).map(arg => (arg === undefined ? 'undefined' : arg));
   let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
@@ -120,12 +120,18 @@ function getFunctionString(functionName: string, functionArgs): string {
   return `gl.${functionName}(${args})`;
 }
 
-function onGLError(props: DebugContextProps, err, functionName: string, args: any[]): void {
+function onGLError(
+  props: DebugContextProps,
+  err: number,
+  functionName: string,
+  args: unknown[]
+): void {
   // Cover bug in webgl-debug-tools
   args = Array.from(args).map(arg => (arg === undefined ? 'undefined' : arg));
   const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
   const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
   const message = `${errorMessage} in gl.${functionName}(${functionArgs})`;
+  // TODO - call device.reportError
   log.error(message)();
   debugger; // eslint-disable-line
   // throw new Error(message);
@@ -135,7 +141,7 @@ function onGLError(props: DebugContextProps, err, functionName: string, args: an
 function onValidateGLFunc(
   props: DebugContextProps,
   functionName: string,
-  functionArgs: any[]
+  functionArgs: unknown[]
 ): void {
   let functionString: string = '';
   if (log.level >= 1) {

package/src/context/helpers/webgl-extensions.ts

@@ -10,8 +10,11 @@ export function getWebGLExtension(
   name: string,
   extensions: GLExtensions
 ): unknown {
+  // @ts-ignore TODO
   if (extensions[name] === undefined) {
+    // @ts-ignore TODO
     extensions[name] = gl.getExtension(name) || null;
   }
+  // @ts-ignore TODO
   return extensions[name];
 }

package/src/context/parameters/unified-parameter-api.ts

@@ -32,16 +32,19 @@ export function setGLParameters(gl: WebGL2RenderingContext, parameters: GLParame
 
   for (const key in parameters) {
     const glConstant = Number(key);
+    // @ts-ignore TODO
     const setter = GL_PARAMETER_SETTERS[key];
     if (setter) {
       // Composite setters should only be called once, so save them
       if (typeof setter === 'string') {
+        // @ts-ignore TODO
         compositeSetters[setter] = true;
       } else {
         // if (gl[glConstant] !== undefined) {
         // TODO - added above check since this is being called on WebGL2 parameters in WebGL1...
         // TODO - deep equal on values? only call setter if value has changed?
         // NOTE - the setter will automatically update this.state
+        // @ts-ignore TODO
         setter(gl, parameters[key], glConstant);
       }
     }
@@ -59,6 +62,7 @@ export function setGLParameters(gl: WebGL2RenderingContext, parameters: GLParame
   if (cache) {
     for (const key in compositeSetters) {
       // TODO - avoid calling composite setters if values have not changed.
+      // @ts-ignore TODO
       const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
       // Note - if `trackContextState` has been called,
       // the setter will automatically update this.state.cache
@@ -92,15 +96,18 @@ export function getGLParameters(
   if (typeof parameters === 'number') {
     // single GL enum
     const key = parameters;
+    // @ts-ignore TODO
     const getter = GL_PARAMETER_GETTERS[key];
     return getter ? getter(gl, key) : gl.getParameter(key);
   }
 
   const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters);
 
-  const state = {};
+  const state: GLParameters = {};
   for (const key of parameterKeys) {
+    // @ts-ignore TODO
     const getter = GL_PARAMETER_GETTERS[key];
+    // @ts-ignore TODO
     state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key));
   }
   return state;
@@ -119,7 +126,7 @@ export function resetGLParameters(gl: WebGL2RenderingContext): void {
 // Helpers
 
 // Returns true if given object is empty, false otherwise.
-function isObjectEmpty(object) {
+function isObjectEmpty(object: Record<string, unknown>): boolean {
   // @ts-ignore dummy key variable
   for (const key in object) {
     return false;

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

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+// @ts-nocheck TODO fix
+
 // Tables describing WebGL parameters
 import {GL, GLParameters} from '@luma.gl/constants';
 

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

@@ -132,6 +132,7 @@ export function polyfillWebGL1Extensions(gl: WebGL2RenderingContext): void {
 
     // Injected extensions
     if (extensionName in boundExtensions) {
+      // @ts-ignore TODO string index
       return boundExtensions[extensionName];
     }
 

package/src/context/state-tracker/deep-array-equal.ts

@@ -2,16 +2,17 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {TypedArray} from '@luma.gl/core';
+
 /** deeply compare two arrays */
-export function deepArrayEqual(x: any, y: any): boolean {
+export function deepArrayEqual(
+  x: unknown | unknown[] | TypedArray,
+  y: unknown | unknown[] | TypedArray
+): boolean {
   if (x === y) {
     return true;
   }
-  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
+  if (isArray(x) && isArray(y) && x.length === y.length) {
     for (let i = 0; i < x.length; ++i) {
       if (x[i] !== y[i]) {
         return false;
@@ -21,3 +22,7 @@ export function deepArrayEqual(x: any, y: any): boolean {
   }
   return false;
 }
+
+function isArray(x: unknown): x is unknown[] {
+  return Array.isArray(x) || ArrayBuffer.isView(x);
+}