@luma.gl/engine 9.0.11 → 9.1.0-alpha.2

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> = {};
@@ -202,6 +213,7 @@ export class Model {
     const moduleMap = Object.fromEntries(
       this.props.modules?.map(module => [module.name, module]) || []
     );
+    // @ts-expect-error Fix typings
     this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
 
     // Setup shader assembler
@@ -209,6 +221,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 +232,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 +250,7 @@ export class Model {
 
       this.vs = vs;
       this.fs = fs;
+      // @ts-expect-error
       this._getModuleUniforms = getUniforms;
     }
 
@@ -358,7 +373,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);
       }
@@ -512,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');
   }
@@ -625,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;
@@ -633,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);
       }
@@ -712,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
       });
@@ -787,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) {
@@ -854,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): boolean {
+  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 as UniformValue;
+    } else {
+      result.bindings[name] = uniform as Binding;
+    }
+  });
+
+  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

@@ -5,7 +5,7 @@
 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, ShaderModuleInstance} from '@luma.gl/shadertools';
+import {getShaderModuleDependencies, ShaderModule} from '@luma.gl/shadertools';
 
 /** Minimal ShaderModule subset, we don't need shader code etc */
 export type ShaderModuleInputs<
@@ -46,6 +46,7 @@ export class ShaderInputs<
    * The map of modules
    * @todo should should this include the resolved dependencies?
    */
+  // @ts-expect-error Fix typings
   modules: Readonly<{[P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>}>;
 
   /** Stores the uniform values for each module */
@@ -53,15 +54,16 @@ export class ShaderInputs<
   /** Stores the uniform bindings for each module  */
   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
    */
+  // @ts-expect-error Fix typings
   constructor(modules: {[P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>}) {
     // TODO - get all dependencies from modules
-    const allModules = _resolveModules(Object.values(modules));
+    const allModules = getShaderModuleDependencies(Object.values(modules));
     log.log(
       1,
       'Creating ShaderInputs with modules',
@@ -92,7 +94,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
@@ -105,7 +107,7 @@ export class ShaderInputs<
         module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || (moduleProps as any);
       // console.error(uniforms)
       this.moduleUniforms[moduleName] = {...oldUniforms, ...uniforms};
-      // this.moduleUniformsChanged ||= moduleName;
+      // // this.moduleUniformsChanged ||= moduleName;
 
       // console.log(`setProps(${String(moduleName)}`, moduleName, this.moduleUniforms[moduleName])
 
@@ -124,7 +126,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);
   }
 

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;
+}

package/src/utils/uid.ts

@@ -0,0 +1,16 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+const uidCounters: Record<string, number> = {};
+
+/**
+ * Returns a UID.
+ * @param id= - Identifier base name
+ * @return uid
+ **/
+export function uid(id: string = 'id'): string {
+  uidCounters[id] = uidCounters[id] || 1;
+  const count = uidCounters[id]++;
+  return `${id}-${count}`;
+}