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

package/src/lib/shader-factory.ts

@@ -1,22 +1,27 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Device, Shader, ShaderProps} from '@luma.gl/core';
 
 /** Manages a cached pool of Shaders for reuse. */
 export class ShaderFactory {
   static readonly defaultProps: Required<ShaderProps> = {...Shader.defaultProps};
 
-  public readonly device: Device;
-
-  private readonly _cache: Record<string, {shader: Shader; useCount: number}> = {};
-
   /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */
   static getDefaultShaderFactory(device: Device): ShaderFactory {
     device._lumaData.defaultShaderFactory ||= new ShaderFactory(device);
     return device._lumaData.defaultShaderFactory as ShaderFactory;
   }
 
+  public readonly device: Device;
+  readonly destroyPolicy: 'unused' | 'never';
+  private readonly _cache: Record<string, {shader: Shader; useCount: number}> = {};
+
   /** @internal */
   constructor(device: Device) {
     this.device = device;
+    this.destroyPolicy = device.props._factoryDestroyPolicy;
   }
 
   /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
@@ -43,8 +48,10 @@ export class ShaderFactory {
     if (cacheEntry) {
       cacheEntry.useCount--;
       if (cacheEntry.useCount === 0) {
-        delete this._cache[key];
-        cacheEntry.shader.destroy();
+        if (this.destroyPolicy === 'unused') {
+          delete this._cache[key];
+          cacheEntry.shader.destroy();
+        }
       }
     }
   }

package/src/model/model.ts

@@ -3,12 +3,13 @@
 // Copyright (c) vis.gl contributors
 
 // A lot of imports, but then Model is where it all comes together...
-import type {TypedArray, RenderPipelineProps, RenderPipelineParameters} from '@luma.gl/core';
+import type {TypedArray} from '@math.gl/types';
+import type {RenderPipelineProps, RenderPipelineParameters} from '@luma.gl/core';
 import type {BufferLayout, Shader, VertexArray, TransformFeedback} from '@luma.gl/core';
 import type {AttributeInfo, Binding, UniformValue, PrimitiveTopology} from '@luma.gl/core';
 import {Device, DeviceFeature, Buffer, Texture, TextureView, Sampler} from '@luma.gl/core';
 import {RenderPipeline, RenderPass, UniformStore} from '@luma.gl/core';
-import {log, uid, deepEqual, isObjectEmpty, splitUniformsAndBindings} from '@luma.gl/core';
+import {log} from '@luma.gl/core';
 import {getTypedArrayFromDataType, getAttributeInfosFromLayouts} from '@luma.gl/core';
 
 import type {ShaderModule, PlatformInfo} from '@luma.gl/shadertools';
@@ -16,16 +17,22 @@ import {ShaderAssembler, getShaderLayoutFromWGSL} from '@luma.gl/shadertools';
 
 import type {Geometry} from '../geometry/geometry';
 import {GPUGeometry, makeGPUGeometry} from '../geometry/gpu-geometry';
-import {ShaderInputs} from '../shader-inputs';
 import {PipelineFactory} from '../lib/pipeline-factory';
 import {ShaderFactory} from '../lib/shader-factory';
 import {getDebugTableForShaderLayout} from '../debug/debug-shader-layout';
 import {debugFramebuffer} from '../debug/debug-framebuffer';
+import {deepEqual} from '../utils/deep-equal';
+import {uid} from '../utils/uid';
+import {splitUniformsAndBindings} from './split-uniforms-and-bindings';
+
+import {ShaderInputs} from '../shader-inputs';
+// import type {AsyncTextureProps} from '../async-texture/async-texture';
+import {AsyncTexture} from '../async-texture/async-texture';
 
 const LOG_DRAW_PRIORITY = 2;
 const LOG_DRAW_TIMEOUT = 10000;
 
-export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
+export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs' | 'bindings'> & {
   source?: string;
   vs: string | null;
   fs: string | null;
@@ -39,7 +46,7 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
   /** Shader inputs, used to generated uniform buffers and bindings */
   shaderInputs?: ShaderInputs;
   /** Bindings */
-  bindings?: Record<string, Binding>;
+  bindings?: Record<string, Binding | AsyncTexture>;
   /** Parameters that are built into the pipeline */
   parameters?: RenderPipelineParameters;
 
@@ -92,7 +99,7 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
 export class Model {
   static defaultProps: Required<ModelProps> = {
     ...RenderPipeline.defaultProps,
-    source: null,
+    source: undefined!,
     vs: null,
     fs: null,
     id: 'unnamed',
@@ -114,7 +121,7 @@ export class Model {
     shaderInputs: undefined!,
     pipelineFactory: undefined!,
     shaderFactory: undefined!,
-    transformFeedback: undefined,
+    transformFeedback: undefined!,
     shaderAssembler: ShaderAssembler.getDefaultShaderAssembler(),
 
     debugShaders: undefined!,
@@ -123,8 +130,11 @@ export class Model {
 
   readonly device: Device;
   readonly id: string;
+  // @ts-expect-error assigned in function called from constructor
   readonly source: string;
+  // @ts-expect-error assigned in function called from constructor
   readonly vs: string;
+  // @ts-expect-error assigned in function called from constructor
   readonly fs: string;
   readonly pipelineFactory: PipelineFactory;
   readonly shaderFactory: ShaderFactory;
@@ -156,7 +166,7 @@ export class Model {
   /** Constant-valued attributes */
   constantAttributes: Record<string, TypedArray> = {};
   /** Bindings (textures, samplers, uniform buffers) */
-  bindings: Record<string, Binding> = {};
+  bindings: Record<string, Binding | AsyncTexture> = {};
   /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/
   uniforms: Record<string, UniformValue> = {};
 
@@ -174,8 +184,9 @@ export class Model {
   pipeline: RenderPipeline;
 
   /** ShaderInputs instance */
+  // @ts-expect-error Assigned in function called by constructor
   shaderInputs: ShaderInputs;
-
+  // @ts-expect-error Assigned in function called by constructor
   _uniformStore: UniformStore;
 
   _attributeInfos: Record<string, AttributeInfo> = {};
@@ -209,6 +220,7 @@ export class Model {
 
     // Extract modules from shader inputs if not supplied
     const modules =
+      // @ts-expect-error shaderInputs is assigned in setShaderInputs above.
       (this.props.modules?.length > 0 ? this.props.modules : this.shaderInputs?.getModules()) || [];
 
     const isWebGPU = this.device.type === 'webgpu';
@@ -219,16 +231,17 @@ export class Model {
     if (isWebGPU && this.props.source) {
       // WGSL
       this.props.shaderLayout ||= getShaderLayoutFromWGSL(this.props.source);
-      const {source, getUniforms} = this.props.shaderAssembler.assembleShader({
+      const {source, getUniforms} = this.props.shaderAssembler.assembleWGSLShader({
         platformInfo,
         ...this.props,
         modules
       });
       this.source = source;
+      // @ts-expect-error
       this._getModuleUniforms = getUniforms;
     } else {
       // GLSL
-      const {vs, fs, getUniforms} = this.props.shaderAssembler.assembleShaderPair({
+      const {vs, fs, getUniforms} = this.props.shaderAssembler.assembleGLSLShaderPair({
         platformInfo,
         ...this.props,
         modules
@@ -236,6 +249,7 @@ export class Model {
 
       this.vs = vs;
       this.fs = fs;
+      // @ts-expect-error
       this._getModuleUniforms = getUniforms;
     }
 
@@ -358,7 +372,11 @@ export class Model {
 
       // Set pipeline state, we may be sharing a pipeline so we need to set all state on every draw
       // Any caching needs to be done inside the pipeline functions
-      this.pipeline.setBindings(this.bindings, {disableWarnings: this.props.disableWarnings});
+      // TODO this is a busy initialized check for all bindings every frame
+      const syncBindings = this._getBindings();
+      this.pipeline.setBindings(syncBindings, {
+        disableWarnings: this.props.disableWarnings
+      });
       if (!isObjectEmpty(this.uniforms)) {
         this.pipeline.setUniformsWebGL(this.uniforms);
       }
@@ -513,7 +531,7 @@ export class Model {
   /**
    * Sets bindings (textures, samplers, uniform buffers)
    */
-  setBindings(bindings: Record<string, Binding>): void {
+  setBindings(bindings: Record<string, Binding | AsyncTexture>): void {
     Object.assign(this.bindings, bindings);
     this.setNeedsRedraw('bindings');
   }
@@ -626,6 +644,21 @@ export class Model {
 
   // Internal methods
 
+  /** Get texture / texture view from any async textures */
+  _getBindings(): Record<string, Binding> {
+    // Extract actual textures from async textures. If not loaded, null
+    return Object.entries(this.bindings).reduce<Record<string, Binding>>((acc, [name, binding]) => {
+      if (binding instanceof AsyncTexture) {
+        if (binding.isReady) {
+          acc[name] = binding.texture;
+        }
+      } else {
+        acc[name] = binding;
+      }
+      return acc;
+    }, {});
+  }
+
   /** Get the timestamp of the latest updated bound GPU memory resource (buffer/texture). */
   _getBindingsUpdateTimestamp(): number {
     let timestamp = 0;
@@ -634,6 +667,11 @@ export class Model {
         timestamp = Math.max(timestamp, binding.texture.updateTimestamp);
       } else if (binding instanceof Buffer || binding instanceof Texture) {
         timestamp = Math.max(timestamp, binding.updateTimestamp);
+      } else if (binding instanceof AsyncTexture) {
+        timestamp = binding.texture
+          ? Math.max(timestamp, binding.texture.updateTimestamp)
+          : // The texture will become available in the future
+            Infinity;
       } else if (!(binding instanceof Sampler)) {
         timestamp = Math.max(timestamp, binding.buffer.updateTimestamp);
       }
@@ -713,6 +751,9 @@ export class Model {
         bufferLayout: this.bufferLayout,
         topology: this.topology,
         parameters: this.parameters,
+        // TODO - why set bindings here when we reset them every frame?
+        // Should we expose a BindGroup abstraction?
+        bindings: this._getBindings(),
         vs,
         fs
       });
@@ -788,13 +829,13 @@ export class Model {
   _getAttributeDebugTable(): Record<string, Record<string, unknown>> {
     const table: Record<string, Record<string, unknown>> = {};
     for (const [name, attributeInfo] of Object.entries(this._attributeInfos)) {
+      const values = this.vertexArray.attributes[attributeInfo.location];
       table[attributeInfo.location] = {
         name,
         type: attributeInfo.shaderType,
-        values: this._getBufferOrConstantValues(
-          this.vertexArray.attributes[attributeInfo.location],
-          attributeInfo.bufferDataType
-        )
+        values: values
+          ? this._getBufferOrConstantValues(values, attributeInfo.bufferDataType)
+          : 'null'
       };
     }
     if (this.vertexArray.indexBuffer) {
@@ -855,3 +896,15 @@ function getAttributeNames(bufferLayout: BufferLayout): string[] {
     ? bufferLayout.attributes?.map(layout => layout.attribute)
     : [bufferLayout.name];
 }
+
+/** Returns true if given object is empty, false otherwise. */
+function isObjectEmpty(obj: object): boolean {
+  let isEmpty = true;
+  // @ts-ignore key is unused
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  for (const key in obj) {
+    isEmpty = false;
+    break;
+  }
+  return isEmpty;
+}

package/src/model/split-uniforms-and-bindings.ts

@@ -0,0 +1,31 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {UniformValue, Binding} from '@luma.gl/core';
+import {isNumericArray} from '@math.gl/types';
+
+export function isUniformValue(value: unknown): value is UniformValue {
+  return isNumericArray(value) !== null || typeof value === 'number' || typeof value === 'boolean';
+}
+
+type UniformsAndBindings = {
+  bindings: Record<string, Binding>;
+  uniforms: Record<string, UniformValue>;
+};
+
+export function splitUniformsAndBindings(
+  uniforms: Record<string, Binding | UniformValue>
+): UniformsAndBindings {
+  const result: UniformsAndBindings = {bindings: {}, uniforms: {}};
+  Object.keys(uniforms).forEach(name => {
+    const uniform = uniforms[name];
+    if (isUniformValue(uniform)) {
+      result.uniforms[name] = uniform;
+    } else {
+      result.bindings[name] = uniform;
+    }
+  });
+
+  return result;
+}

package/src/scenegraph/group-node.ts

@@ -1,3 +1,7 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Matrix4, Vector3} from '@math.gl/core';
 import {log} from '@luma.gl/core';
 import {ScenegraphNode, ScenegraphNodeProps} from './scenegraph-node';

package/src/scenegraph/model-node.ts

@@ -1,3 +1,7 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {RenderPass} from '@luma.gl/core';
 import {ScenegraphNode, ScenegraphNodeProps} from './scenegraph-node';
 import {Model} from '../model/model';
@@ -28,10 +32,6 @@ export class ModelNode extends ScenegraphNode {
     this.setProps(props);
   }
 
-  override getBounds(): [number[], number[]] | null {
-    return this.bounds;
-  }
-
   override destroy(): void {
     if (this.model) {
       this.model.destroy();
@@ -42,8 +42,12 @@ export class ModelNode extends ScenegraphNode {
     this.managedResources = [];
   }
 
+  override getBounds(): [number[], number[]] | null {
+    return this.bounds;
+  }
+
   // Expose model methods
-  draw(renderPass?: RenderPass) {
+  draw(renderPass: RenderPass) {
     // Return value indicates if something was actually drawn
     return this.model.draw(renderPass);
   }

package/src/scenegraph/scenegraph-node.ts

@@ -1,15 +1,19 @@
-import {assert, uid, NumberArray} from '@luma.gl/core';
-import {Vector3, Matrix4} from '@math.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Vector3, Matrix4, NumericArray} from '@math.gl/core';
+import {uid} from '../utils/uid';
 
 /** Properties for creating a new Scenegraph */
 export type ScenegraphNodeProps = {
   id?: string;
   /** whether to display the object at all */
   display?: boolean;
-  matrix?: NumberArray;
-  position?: NumberArray;
-  rotation?: NumberArray;
-  scale?: NumberArray;
+  matrix?: NumericArray;
+  position?: NumericArray;
+  rotation?: NumericArray;
+  scale?: NumericArray;
   update?: boolean;
 };
 
@@ -53,19 +57,19 @@ export class ScenegraphNode {
   }
 
   setPosition(position: any): this {
-    assert(position.length === 3, 'setPosition requires vector argument');
+    // assert(position.length === 3, 'setPosition requires vector argument');
     this.position = position;
     return this;
   }
 
   setRotation(rotation: any): this {
-    assert(rotation.length === 3, 'setRotation requires vector argument');
+    // assert(rotation.length === 3, 'setRotation requires vector argument');
     this.rotation = rotation;
     return this;
   }
 
   setScale(scale: any): this {
-    assert(scale.length === 3, 'setScale requires vector argument');
+    // assert(scale.length === 3, 'setScale requires vector argument');
     this.scale = scale;
     return this;
   }
@@ -140,7 +144,7 @@ export class ScenegraphNode {
   } {
     // TODO - solve multiple class problem
     // assert(viewMatrix instanceof Matrix4);
-    assert(viewMatrix);
+    // assert(viewMatrix);
     modelMatrix = modelMatrix || this.matrix;
     const worldMatrix = new Matrix4(viewMatrix).multiplyRight(modelMatrix);
     const worldInverse = worldMatrix.invert();
@@ -180,9 +184,9 @@ export class ScenegraphNode {
   */
 
   _setScenegraphNodeProps(props: ScenegraphNodeProps): void {
-    if ('display' in props) {
-      this.display = props.display;
-    }
+    // if ('display' in props) {
+    //   this.display = props.display;
+    // }
 
     if ('position' in props) {
       this.setPosition(props.position);

package/src/shader-inputs.ts

@@ -2,10 +2,36 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Binding, UniformValue} from '@luma.gl/core';
-import {log, splitUniformsAndBindings} from '@luma.gl/core';
+import type {UniformValue, Texture, Sampler} from '@luma.gl/core';
+import {log} from '@luma.gl/core';
 // import type {ShaderUniformType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
-import {_resolveModules, ShaderModule, ShaderModuleInstance} from '@luma.gl/shadertools';
+import {getShaderModuleDependencies, ShaderModule} from '@luma.gl/shadertools';
+import {splitUniformsAndBindings} from './model/split-uniforms-and-bindings';
+
+type BindingValue = Buffer | Texture | Sampler;
+
+/** Minimal ShaderModule subset, we don't need shader code etc */
+export type ShaderModuleInputs<
+  PropsT extends Record<string, unknown> = Record<string, unknown>,
+  UniformsT extends Record<string, UniformValue> = Record<string, UniformValue>,
+  BindingsT extends Record<string, BindingValue> = Record<string, BindingValue>
+> = {
+  defaultUniforms?: UniformsT;
+  getUniforms?: (props?: any, oldProps?: any) => Record<string, BindingValue | UniformValue>;
+
+  /** Not used. Used to access props type */
+  props?: PropsT;
+
+  bindings?: Record<
+    keyof BindingsT,
+    {
+      location: number;
+      type: 'texture' | 'sampler' | 'uniforms';
+    }
+  >;
+
+  uniformTypes?: any;
+};
 
 /**
  * ShaderInputs holds uniform and binding values for one or more shader modules,
@@ -23,22 +49,24 @@ export class ShaderInputs<
    * The map of modules
    * @todo should should this include the resolved dependencies?
    */
-  modules: Readonly<{[P in keyof ShaderPropsT]: ShaderModule<ShaderPropsT[P]>}>;
+  // @ts-expect-error Fix typings
+  modules: Readonly<{[P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>}>;
 
   /** Stores the uniform values for each module */
   moduleUniforms: Record<keyof ShaderPropsT, Record<string, UniformValue>>;
   /** Stores the uniform bindings for each module  */
-  moduleBindings: Record<keyof ShaderPropsT, Record<string, Binding>>;
+  moduleBindings: Record<keyof ShaderPropsT, Record<string, Texture | Sampler>>;
   /** Tracks if uniforms have changed */
-  moduleUniformsChanged: Record<keyof ShaderPropsT, false | string>;
+  // moduleUniformsChanged: Record<keyof ShaderPropsT, false | string>;
 
   /**
    * Create a new UniformStore instance
    * @param modules
    */
-  constructor(modules: {[P in keyof ShaderPropsT]?: ShaderModule<ShaderPropsT[P], any>}) {
+  // @ts-expect-error Fix typings
+  constructor(modules: {[P in keyof ShaderPropsT]?: ShaderModuleInputs<ShaderPropsT[P]>}) {
     // Extract modules with dependencies
-    const resolvedModules = _resolveModules(
+    const resolvedModules = getShaderModuleDependencies(
       Object.values(modules).filter(module => module.dependencies)
     );
     for (const resolvedModule of resolvedModules) {
@@ -49,9 +77,10 @@ export class ShaderInputs<
     log.log(1, 'Creating ShaderInputs with modules', Object.keys(modules))();
 
     // Store the module definitions and create storage for uniform values and binding values, per module
-    this.modules = modules as {[P in keyof ShaderPropsT]: ShaderModule<ShaderPropsT[P]>};
+    // @ts-expect-error Fix typings
+    this.modules = modules;
     this.moduleUniforms = {} as Record<keyof ShaderPropsT, Record<string, UniformValue>>;
-    this.moduleBindings = {} as Record<keyof ShaderPropsT, Record<string, Binding>>;
+    this.moduleBindings = {} as Record<keyof ShaderPropsT, Record<string, Texture | Sampler>>;
 
     // Initialize the modules
     for (const [name, module] of Object.entries(modules)) {
@@ -72,7 +101,7 @@ export class ShaderInputs<
   setProps(props: Partial<{[P in keyof ShaderPropsT]?: Partial<ShaderPropsT[P]>}>): void {
     for (const name of Object.keys(props)) {
       const moduleName = name as keyof ShaderPropsT;
-      const moduleProps = props[moduleName];
+      const moduleProps = props[moduleName] || {};
       const module = this.modules[moduleName];
       if (!module) {
         // Ignore props for unregistered modules
@@ -80,10 +109,10 @@ export class ShaderInputs<
         continue; // eslint-disable-line no-continue
       }
 
-      const oldUniforms = this.moduleUniforms[moduleName] as (typeof module)['uniforms'];
+      const oldUniforms = this.moduleUniforms[moduleName];
       const oldBindings = this.moduleBindings[moduleName];
-      const uniformsAndBindings =
-        module.getUniforms?.(moduleProps, oldUniforms) || (moduleProps as any);
+      let uniformsAndBindings = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]);
+      uniformsAndBindings ||= {...this.moduleUniforms[moduleName], ...moduleProps};
 
       const {uniforms, bindings} = splitUniformsAndBindings(uniformsAndBindings);
       this.moduleUniforms[moduleName] = {...oldUniforms, ...uniforms};
@@ -103,7 +132,7 @@ export class ShaderInputs<
    * Return the map of modules
    * @todo should should this include the resolved dependencies?
    */
-  getModules(): ShaderModuleInstance[] {
+  getModules(): ShaderModule[] {
     return Object.values(this.modules);
   }
 
@@ -113,8 +142,8 @@ export class ShaderInputs<
   }
 
   /** Merges all bindings for the shader (from the various modules) */
-  getBindings(): Record<string, Binding> {
-    const bindings = {} as Record<string, Binding>;
+  getBindings(): Record<string, Texture | Sampler> {
+    const bindings = {} as Record<string, Texture | Sampler>;
     for (const moduleBindings of Object.values(this.moduleBindings)) {
       Object.assign(bindings, moduleBindings);
     }
@@ -126,7 +155,7 @@ export class ShaderInputs<
     for (const [moduleName, module] of Object.entries(this.moduleUniforms)) {
       for (const [key, value] of Object.entries(module)) {
         table[`${moduleName}.${key}`] = {
-          type: this.modules[moduleName].uniformTypes?.[key as keyof ShaderPropsT],
+          type: this.modules[moduleName].uniformTypes?.[key],
           value: String(value)
         };
       }

package/src/transform/buffer-transform.ts

@@ -2,14 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {
-  Device,
-  Buffer,
-  BufferRange,
-  TransformFeedback,
-  assert,
-  RenderPassProps
-} from '@luma.gl/core';
+import {Device, Buffer, BufferRange, TransformFeedback, RenderPassProps} from '@luma.gl/core';
 import {getPassthroughFS} from '@luma.gl/shadertools';
 import {Model} from '../model/model';
 import type {ModelProps} from '../model/model';
@@ -38,7 +31,9 @@ export class BufferTransform {
   }
 
   constructor(device: Device, props: BufferTransformProps = Model.defaultProps) {
-    assert(BufferTransform.isSupported(device), 'BufferTransform not yet implemented on WebGPU');
+    if (!BufferTransform.isSupported(device)) {
+      throw new Error('BufferTransform not yet implemented on WebGPU');
+    }
 
     this.device = device;
 
@@ -51,6 +46,7 @@ export class BufferTransform {
 
     this.transformFeedback = this.device.createTransformFeedback({
       layout: this.model.pipeline.shaderLayout,
+      // @ts-expect-error TODO
       buffers: props.feedbackBuffers
     });
 
@@ -93,6 +89,9 @@ export class BufferTransform {
 
   readAsync(varyingName: string): Promise<Uint8Array> {
     const result = this.getBuffer(varyingName);
+    if (!result) {
+      throw new Error('BufferTransform#getBuffer');
+    }
     if (result instanceof Buffer) {
       return result.readAsync();
     }

package/src/transform/texture-transform.ts

@@ -111,7 +111,7 @@ export class TextureTransform {
     return targetTexture;
   }
 
-  getFramebuffer(): Framebuffer {
+  getFramebuffer(): Framebuffer | undefined {
     const currentResources = this.bindings[this.currentIndex];
     return currentResources.framebuffer;
   }
@@ -134,6 +134,7 @@ export class TextureTransform {
       binding = {
         sourceBuffers: {},
         sourceTextures: {},
+        // @ts-expect-error
         targetTexture: null
       };
     }

package/src/utils/deep-equal.ts

@@ -0,0 +1,51 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/**
+ * Fast partial deep equal for prop.
+ *
+ * @param a Prop
+ * @param b Prop to compare against `a`
+ * @param depth Depth to which to recurse in nested Objects/Arrays. Use 0 (default) for shallow comparison, -1 for infinite depth
+ */
+/* eslint-disable complexity */
+export function deepEqual(a: any, b: any, depth: number): boolean {
+  if (a === b) {
+    return true;
+  }
+  if (!depth || !a || !b) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(b)) {
+    return false;
+  }
+  if (typeof a === 'object' && typeof b === 'object') {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (const key of aKeys) {
+      if (!b.hasOwnProperty(key)) {
+        return false;
+      }
+      if (!deepEqual(a[key], b[key], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}