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

package/dist/scenegraph/group-node.js

@@ -1,94 +1,79 @@
 import { Matrix4, Vector3 } from '@math.gl/core';
 import { log } from '@luma.gl/core';
-import { ScenegraphNode } from "./scenegraph-node.js";
+import { ScenegraphNode } from './scenegraph-node';
 export class GroupNode extends ScenegraphNode {
-  constructor() {
-    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    props = Array.isArray(props) ? {
-      children: props
-    } : props;
-    const {
-      children = []
-    } = props;
-    log.assert(children.every(child => child instanceof ScenegraphNode), 'every child must an instance of ScenegraphNode');
-    super(props);
-    this.children = void 0;
-    this.children = children;
-  }
-  getBounds() {
-    const result = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
-    this.traverse((node, _ref) => {
-      let {
-        worldMatrix
-      } = _ref;
-      const bounds = node.getBounds();
-      if (!bounds) {
-        return;
-      }
-      const [min, max] = bounds;
-      const center = new Vector3(min).add(max).divide([2, 2, 2]);
-      worldMatrix.transformAsPoint(center, center);
-      const halfSize = new Vector3(max).subtract(min).divide([2, 2, 2]);
-      worldMatrix.transformAsVector(halfSize, halfSize);
-      for (let v = 0; v < 8; v++) {
-        const position = new Vector3(v & 0b001 ? -1 : 1, v & 0b010 ? -1 : 1, v & 0b100 ? -1 : 1).multiply(halfSize).add(center);
-        for (let i = 0; i < 3; i++) {
-          result[0][i] = Math.min(result[0][i], position[i]);
-          result[1][i] = Math.max(result[1][i], position[i]);
+    children;
+    constructor(props = {}) {
+        props = Array.isArray(props) ? { children: props } : props;
+        const { children = [] } = props;
+        log.assert(children.every((child) => child instanceof ScenegraphNode), 'every child must an instance of ScenegraphNode');
+        super(props);
+        this.children = children;
+    }
+    getBounds() {
+        const result = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+        this.traverse((node, { worldMatrix }) => {
+            const bounds = node.getBounds();
+            if (!bounds) {
+                return;
+            }
+            const [min, max] = bounds;
+            const center = new Vector3(min).add(max).divide([2, 2, 2]);
+            worldMatrix.transformAsPoint(center, center);
+            const halfSize = new Vector3(max).subtract(min).divide([2, 2, 2]);
+            worldMatrix.transformAsVector(halfSize, halfSize);
+            for (let v = 0; v < 8; v++) {
+                // Test all 8 corners of the box
+                const position = new Vector3(v & 0b001 ? -1 : 1, v & 0b010 ? -1 : 1, v & 0b100 ? -1 : 1).multiply(halfSize).add(center);
+                for (let i = 0; i < 3; i++) {
+                    result[0][i] = Math.min(result[0][i], position[i]);
+                    result[1][i] = Math.max(result[1][i], position[i]);
+                }
+            }
+        });
+        if (!Number.isFinite(result[0][0])) {
+            return null;
         }
-      }
-    });
-    if (!Number.isFinite(result[0][0])) {
-      return null;
+        return result;
     }
-    return result;
-  }
-  destroy() {
-    this.children.forEach(child => child.destroy());
-    this.removeAll();
-    super.destroy();
-  }
-  add() {
-    for (var _len = arguments.length, children = new Array(_len), _key = 0; _key < _len; _key++) {
-      children[_key] = arguments[_key];
+    destroy() {
+        this.children.forEach((child) => child.destroy());
+        this.removeAll();
+        super.destroy();
+    }
+    // Unpacks arrays and nested arrays of children
+    add(...children) {
+        for (const child of children) {
+            if (Array.isArray(child)) {
+                this.add(...child);
+            }
+            else {
+                this.children.push(child);
+            }
+        }
+        return this;
     }
-    for (const child of children) {
-      if (Array.isArray(child)) {
-        this.add(...child);
-      } else {
-        this.children.push(child);
-      }
+    remove(child) {
+        const children = this.children;
+        const indexOf = children.indexOf(child);
+        if (indexOf > -1) {
+            children.splice(indexOf, 1);
+        }
+        return this;
     }
-    return this;
-  }
-  remove(child) {
-    const children = this.children;
-    const indexOf = children.indexOf(child);
-    if (indexOf > -1) {
-      children.splice(indexOf, 1);
+    removeAll() {
+        this.children = [];
+        return this;
     }
-    return this;
-  }
-  removeAll() {
-    this.children = [];
-    return this;
-  }
-  traverse(visitor) {
-    let {
-      worldMatrix = new Matrix4()
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const modelMatrix = new Matrix4(worldMatrix).multiplyRight(this.matrix);
-    for (const child of this.children) {
-      if (child instanceof GroupNode) {
-        child.traverse(visitor, {
-          worldMatrix: modelMatrix
-        });
-      } else {
-        visitor(child, {
-          worldMatrix: modelMatrix
-        });
-      }
+    traverse(visitor, { worldMatrix = new Matrix4() } = {}) {
+        const modelMatrix = new Matrix4(worldMatrix).multiplyRight(this.matrix);
+        for (const child of this.children) {
+            if (child instanceof GroupNode) {
+                child.traverse(visitor, { worldMatrix: modelMatrix });
+            }
+            else {
+                visitor(child, { worldMatrix: modelMatrix });
+            }
+        }
     }
-  }
 }
-//# sourceMappingURL=group-node.js.map

package/dist/scenegraph/model-node.js

@@ -1,28 +1,35 @@
-import { ScenegraphNode } from "./scenegraph-node.js";
+import { ScenegraphNode } from './scenegraph-node';
 export class ModelNode extends ScenegraphNode {
-  constructor(props) {
-    super(props);
-    this.model = void 0;
-    this.bounds = null;
-    this.managedResources = void 0;
-    this.model = props.model;
-    this.managedResources = props.managedResources || [];
-    this.bounds = props.bounds || null;
-    this.setProps(props);
-  }
-  getBounds() {
-    return this.bounds;
-  }
-  destroy() {
-    if (this.model) {
-      this.model.destroy();
-      this.model = null;
+    model;
+    bounds = null;
+    managedResources;
+    // TODO - is this used? override callbacks to make sure we call them with this
+    // onBeforeRender = null;
+    // onAfterRender = null;
+    // AfterRender = null;
+    constructor(props) {
+        super(props);
+        // Create new Model or used supplied Model
+        this.model = props.model;
+        this.managedResources = props.managedResources || [];
+        this.bounds = props.bounds || null;
+        this.setProps(props);
+    }
+    getBounds() {
+        return this.bounds;
+    }
+    destroy() {
+        if (this.model) {
+            this.model.destroy();
+            // @ts-expect-error
+            this.model = null;
+        }
+        this.managedResources.forEach((resource) => resource.destroy());
+        this.managedResources = [];
+    }
+    // Expose model methods
+    draw(renderPass) {
+        // Return value indicates if something was actually drawn
+        return this.model.draw(renderPass);
     }
-    this.managedResources.forEach(resource => resource.destroy());
-    this.managedResources = [];
-  }
-  draw(renderPass) {
-    return this.model.draw(renderPass);
-  }
 }
-//# sourceMappingURL=model-node.js.map

package/dist/scenegraph/scenegraph-node.js

@@ -1,141 +1,153 @@
 import { assert, uid } from '@luma.gl/core';
 import { Vector3, Matrix4 } from '@math.gl/core';
 export class ScenegraphNode {
-  constructor() {
-    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.id = void 0;
-    this.matrix = new Matrix4();
-    this.display = true;
-    this.position = new Vector3();
-    this.rotation = new Vector3();
-    this.scale = new Vector3(1, 1, 1);
-    this.userData = {};
-    this.props = {};
-    const {
-      id
-    } = props;
-    this.id = id || uid(this.constructor.name);
-    this._setScenegraphNodeProps(props);
-  }
-  getBounds() {
-    return null;
-  }
-  destroy() {}
-  delete() {
-    this.destroy();
-  }
-  setProps(props) {
-    this._setScenegraphNodeProps(props);
-    return this;
-  }
-  toString() {
-    return `{type: ScenegraphNode, id: ${this.id})}`;
-  }
-  setPosition(position) {
-    assert(position.length === 3, 'setPosition requires vector argument');
-    this.position = position;
-    return this;
-  }
-  setRotation(rotation) {
-    assert(rotation.length === 3, 'setRotation requires vector argument');
-    this.rotation = rotation;
-    return this;
-  }
-  setScale(scale) {
-    assert(scale.length === 3, 'setScale requires vector argument');
-    this.scale = scale;
-    return this;
-  }
-  setMatrix(matrix) {
-    let copyMatrix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    if (copyMatrix) {
-      this.matrix.copy(matrix);
-    } else {
-      this.matrix = matrix;
+    id;
+    matrix = new Matrix4();
+    display = true;
+    position = new Vector3();
+    rotation = new Vector3();
+    scale = new Vector3(1, 1, 1);
+    userData = {};
+    props = {};
+    constructor(props = {}) {
+        const { id } = props;
+        this.id = id || uid(this.constructor.name);
+        this._setScenegraphNodeProps(props);
     }
-  }
-  setMatrixComponents(components) {
-    const {
-      position,
-      rotation,
-      scale,
-      update = true
-    } = components;
-    if (position) {
-      this.setPosition(position);
+    getBounds() {
+        return null;
     }
-    if (rotation) {
-      this.setRotation(rotation);
+    destroy() { }
+    /** @deprecated use .destroy() */
+    delete() {
+        this.destroy();
     }
-    if (scale) {
-      this.setScale(scale);
+    setProps(props) {
+        this._setScenegraphNodeProps(props);
+        return this;
     }
-    if (update) {
-      this.updateMatrix();
+    toString() {
+        return `{type: ScenegraphNode, id: ${this.id})}`;
     }
-    return this;
-  }
-  updateMatrix() {
-    const pos = this.position;
-    const rot = this.rotation;
-    const scale = this.scale;
-    this.matrix.identity();
-    this.matrix.translate(pos);
-    this.matrix.rotateXYZ(rot);
-    this.matrix.scale(scale);
-    return this;
-  }
-  update() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const {
-      position,
-      rotation,
-      scale
-    } = options;
-    if (position) {
-      this.setPosition(position);
+    setPosition(position) {
+        assert(position.length === 3, 'setPosition requires vector argument');
+        this.position = position;
+        return this;
     }
-    if (rotation) {
-      this.setRotation(rotation);
+    setRotation(rotation) {
+        assert(rotation.length === 3, 'setRotation requires vector argument');
+        this.rotation = rotation;
+        return this;
     }
-    if (scale) {
-      this.setScale(scale);
+    setScale(scale) {
+        assert(scale.length === 3, 'setScale requires vector argument');
+        this.scale = scale;
+        return this;
     }
-    this.updateMatrix();
-    return this;
-  }
-  getCoordinateUniforms(viewMatrix, modelMatrix) {
-    assert(viewMatrix);
-    modelMatrix = modelMatrix || this.matrix;
-    const worldMatrix = new Matrix4(viewMatrix).multiplyRight(modelMatrix);
-    const worldInverse = worldMatrix.invert();
-    const worldInverseTranspose = worldInverse.transpose();
-    return {
-      viewMatrix,
-      modelMatrix,
-      objectMatrix: modelMatrix,
-      worldMatrix,
-      worldInverseMatrix: worldInverse,
-      worldInverseTransposeMatrix: worldInverseTranspose
-    };
-  }
-  _setScenegraphNodeProps(props) {
-    if ('display' in props) {
-      this.display = props.display;
+    setMatrix(matrix, copyMatrix = true) {
+        if (copyMatrix) {
+            this.matrix.copy(matrix);
+        }
+        else {
+            this.matrix = matrix;
+        }
     }
-    if ('position' in props) {
-      this.setPosition(props.position);
+    setMatrixComponents(components) {
+        const { position, rotation, scale, update = true } = components;
+        if (position) {
+            this.setPosition(position);
+        }
+        if (rotation) {
+            this.setRotation(rotation);
+        }
+        if (scale) {
+            this.setScale(scale);
+        }
+        if (update) {
+            this.updateMatrix();
+        }
+        return this;
     }
-    if ('rotation' in props) {
-      this.setRotation(props.rotation);
+    updateMatrix() {
+        const pos = this.position;
+        const rot = this.rotation;
+        const scale = this.scale;
+        this.matrix.identity();
+        this.matrix.translate(pos);
+        this.matrix.rotateXYZ(rot);
+        this.matrix.scale(scale);
+        return this;
     }
-    if ('scale' in props) {
-      this.setScale(props.scale);
+    update(options = {}) {
+        const { position, rotation, scale } = options;
+        if (position) {
+            this.setPosition(position);
+        }
+        if (rotation) {
+            this.setRotation(rotation);
+        }
+        if (scale) {
+            this.setScale(scale);
+        }
+        this.updateMatrix();
+        return this;
     }
-    if ('matrix' in props) {
-      this.setMatrix(props.matrix);
+    getCoordinateUniforms(viewMatrix, modelMatrix) {
+        // TODO - solve multiple class problem
+        // assert(viewMatrix instanceof Matrix4);
+        assert(viewMatrix);
+        modelMatrix = modelMatrix || this.matrix;
+        const worldMatrix = new Matrix4(viewMatrix).multiplyRight(modelMatrix);
+        const worldInverse = worldMatrix.invert();
+        const worldInverseTranspose = worldInverse.transpose();
+        return {
+            viewMatrix,
+            modelMatrix,
+            objectMatrix: modelMatrix,
+            worldMatrix,
+            worldInverseMatrix: worldInverse,
+            worldInverseTransposeMatrix: worldInverseTranspose
+        };
+    }
+    // TODO - copied code, not yet vetted
+    /*
+    transform() {
+      if (!this.parent) {
+        this.endPosition.set(this.position);
+        this.endRotation.set(this.rotation);
+        this.endScale.set(this.scale);
+      } else {
+        const parent = this.parent;
+        this.endPosition.set(this.position.add(parent.endPosition));
+        this.endRotation.set(this.rotation.add(parent.endRotation));
+        this.endScale.set(this.scale.add(parent.endScale));
+      }
+  
+      const ch = this.children;
+      for (let i = 0; i < ch.length; ++i) {
+        ch[i].transform();
+      }
+  
+      return this;
+    }
+    */
+    _setScenegraphNodeProps(props) {
+        if ('display' in props) {
+            this.display = props.display;
+        }
+        if ('position' in props) {
+            this.setPosition(props.position);
+        }
+        if ('rotation' in props) {
+            this.setRotation(props.rotation);
+        }
+        if ('scale' in props) {
+            this.setScale(props.scale);
+        }
+        // Matrix overwrites other props
+        if ('matrix' in props) {
+            this.setMatrix(props.matrix);
+        }
+        Object.assign(this.props, props);
     }
-    Object.assign(this.props, props);
-  }
 }
-//# sourceMappingURL=scenegraph-node.js.map

package/dist/shader-inputs.js

@@ -1,66 +1,104 @@
 import { log } from '@luma.gl/core';
+// import type {ShaderUniformType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
 import { _resolveModules } from '@luma.gl/shadertools';
+/**
+ * ShaderInputs holds uniform and binding values for one or more shader modules,
+ * - It can generate binary data for any uniform buffer
+ * - It can manage a uniform buffer for each block
+ * - It can update managed uniform buffers with a single call
+ * - It performs some book keeping on what has changed to minimize unnecessary writes to uniform buffers.
+ */
 export class ShaderInputs {
-  constructor(modules) {
-    this.modules = void 0;
-    this.moduleUniforms = void 0;
-    this.moduleBindings = void 0;
-    this.moduleUniformsChanged = void 0;
-    const allModules = _resolveModules(Object.values(modules));
-    log.log(1, 'Creating ShaderInputs with modules', allModules.map(m => m.name))();
-    this.modules = modules;
-    this.moduleUniforms = {};
-    this.moduleBindings = {};
-    for (const [name, module] of Object.entries(modules)) {
-      const moduleName = name;
-      this.moduleUniforms[moduleName] = module.defaultUniforms || {};
-      this.moduleBindings[moduleName] = {};
+    /**
+     * The map of modules
+     * @todo should should this include the resolved dependencies?
+     */
+    modules;
+    /** Stores the uniform values for each module */
+    moduleUniforms;
+    /** Stores the uniform bindings for each module  */
+    moduleBindings;
+    /** Tracks if uniforms have changed */
+    moduleUniformsChanged;
+    /**
+     * Create a new UniformStore instance
+     * @param modules
+     */
+    constructor(modules) {
+        // TODO - get all dependencies from modules
+        const allModules = _resolveModules(Object.values(modules));
+        log.log(1, 'Creating ShaderInputs with modules', allModules.map(m => m.name))();
+        // Store the module definitions and create storage for uniform values and binding values, per module
+        this.modules = modules;
+        this.moduleUniforms = {};
+        this.moduleBindings = {};
+        // Initialize the modules
+        for (const [name, module] of Object.entries(modules)) {
+            const moduleName = name;
+            // Get default uniforms from module
+            this.moduleUniforms[moduleName] = module.defaultUniforms || {};
+            this.moduleBindings[moduleName] = {};
+        }
     }
-  }
-  destroy() {}
-  setProps(props) {
-    for (const name of Object.keys(props)) {
-      var _module$getUniforms;
-      const moduleName = name;
-      const moduleProps = props[moduleName];
-      const module = this.modules[moduleName];
-      if (!module) {
-        log.warn(`Module ${name} not found`)();
-        continue;
-      }
-      const oldUniforms = this.moduleUniforms[moduleName];
-      const uniforms = ((_module$getUniforms = module.getUniforms) === null || _module$getUniforms === void 0 ? void 0 : _module$getUniforms.call(module, moduleProps, this.moduleUniforms[moduleName])) || moduleProps;
-      this.moduleUniforms[moduleName] = {
-        ...oldUniforms,
-        ...uniforms
-      };
+    /** Destroy */
+    destroy() { }
+    /**
+     * Set module props
+     */
+    setProps(props) {
+        for (const name of Object.keys(props)) {
+            const moduleName = name;
+            const moduleProps = props[moduleName];
+            const module = this.modules[moduleName];
+            if (!module) {
+                // Ignore props for unregistered modules
+                log.warn(`Module ${name} not found`)();
+                continue; // eslint-disable-line no-continue
+            }
+            const oldUniforms = this.moduleUniforms[moduleName];
+            const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps;
+            // console.error(uniforms)
+            this.moduleUniforms[moduleName] = { ...oldUniforms, ...uniforms };
+            // this.moduleUniformsChanged ||= moduleName;
+            // console.log(`setProps(${String(moduleName)}`, moduleName, this.moduleUniforms[moduleName])
+            // TODO - Get Module bindings
+            // const bindings = module.getBindings?.(moduleProps);
+            // this.moduleUniforms[moduleName] = bindings;
+        }
     }
-  }
-  getModules() {
-    return Object.values(this.modules);
-  }
-  getUniformValues() {
-    return this.moduleUniforms;
-  }
-  getBindings() {
-    const bindings = {};
-    for (const moduleBindings of Object.values(this.moduleBindings)) {
-      Object.assign(bindings, moduleBindings);
+    /** Merges all bindings for the shader (from the various modules) */
+    // getUniformBlocks(): Record<string, Texture | Sampler> {
+    //   return this.moduleUniforms;
+    // }
+    /**
+     * Return the map of modules
+     * @todo should should this include the resolved dependencies?
+     */
+    getModules() {
+        return Object.values(this.modules);
     }
-    return bindings;
-  }
-  getDebugTable() {
-    const table = {};
-    for (const [moduleName, module] of Object.entries(this.moduleUniforms)) {
-      for (const [key, value] of Object.entries(module)) {
-        var _this$modules$moduleN;
-        table[`${moduleName}.${key}`] = {
-          type: (_this$modules$moduleN = this.modules[moduleName].uniformTypes) === null || _this$modules$moduleN === void 0 ? void 0 : _this$modules$moduleN[key],
-          value: String(value)
-        };
-      }
+    /** Get all uniform values for all modules */
+    getUniformValues() {
+        return this.moduleUniforms;
+    }
+    /** Merges all bindings for the shader (from the various modules) */
+    getBindings() {
+        const bindings = {};
+        for (const moduleBindings of Object.values(this.moduleBindings)) {
+            Object.assign(bindings, moduleBindings);
+        }
+        return bindings;
+    }
+    getDebugTable() {
+        const table = {};
+        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],
+                    value: String(value)
+                };
+            }
+        }
+        return table;
     }
-    return table;
-  }
 }
-//# sourceMappingURL=shader-inputs.js.map