@luma.gl/engine 9.0.0-alpha.9 → 9.0.0-beta.10

package/dist/scenegraph/group-node.js

@@ -0,0 +1,84 @@
+import { Matrix4, Vector3 } from '@math.gl/core';
+import { log } from '@luma.gl/core';
+import { ScenegraphNode } from "./scenegraph-node.js";
+export class GroupNode extends ScenegraphNode {
+    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;
+        }
+        return result;
+    }
+    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;
+    }
+    remove(child) {
+        const children = this.children;
+        const indexOf = children.indexOf(child);
+        if (indexOf > -1) {
+            children.splice(indexOf, 1);
+        }
+        return this;
+    }
+    removeAll() {
+        this.children = [];
+        return this;
+    }
+    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 });
+            }
+        }
+    }
+}

package/dist/scenegraph/model-node.d.ts

@@ -0,0 +1,18 @@
+import { RenderPass } from '@luma.gl/core';
+import { ScenegraphNode, ScenegraphNodeProps } from "./scenegraph-node.js";
+import { Model } from "../model/model.js";
+export type ModelNodeProps = ScenegraphNodeProps & {
+    model: Model;
+    managedResources?: any[];
+    bounds?: [number[], number[]];
+};
+export declare class ModelNode extends ScenegraphNode {
+    readonly model: Model;
+    bounds: [number[], number[]] | null;
+    managedResources: any[];
+    constructor(props: ModelNodeProps);
+    getBounds(): [number[], number[]] | null;
+    destroy(): void;
+    draw(renderPass?: RenderPass): boolean;
+}
+//# sourceMappingURL=model-node.d.ts.map

package/dist/scenegraph/model-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-node.d.ts","sourceRoot":"","sources":["../../src/scenegraph/model-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,6BAA0B;AACtE,OAAO,EAAC,KAAK,EAAC,0BAAuB;AAErC,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG;IACjD,KAAK,EAAE,KAAK,CAAC;IACb,gBAAgB,CAAC,EAAE,GAAG,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;CAC/B,CAAC;AAEF,qBAAa,SAAU,SAAQ,cAAc;IAC3C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAQ;IAC3C,gBAAgB,EAAE,GAAG,EAAE,CAAC;gBAOZ,KAAK,EAAE,cAAc;IAUxB,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI;IAIxC,OAAO,IAAI,IAAI;IAWxB,IAAI,CAAC,UAAU,CAAC,EAAE,UAAU;CAI7B"}

package/dist/scenegraph/model-node.js

@@ -0,0 +1,35 @@
+import { ScenegraphNode } from "./scenegraph-node.js";
+export class ModelNode extends ScenegraphNode {
+    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);
+    }
+}

package/dist/scenegraph/scenegraph-node.d.ts

@@ -0,0 +1,56 @@
+import { NumberArray } from '@luma.gl/core';
+import { Vector3, Matrix4 } from '@math.gl/core';
+/** 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;
+    update?: boolean;
+};
+export declare class ScenegraphNode {
+    readonly id: string;
+    matrix: Matrix4;
+    display: boolean;
+    position: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
+    userData: Record<string, unknown>;
+    props: ScenegraphNodeProps;
+    constructor(props?: ScenegraphNodeProps);
+    getBounds(): [number[], number[]] | null;
+    destroy(): void;
+    /** @deprecated use .destroy() */
+    delete(): void;
+    setProps(props: ScenegraphNodeProps): this;
+    toString(): string;
+    setPosition(position: any): this;
+    setRotation(rotation: any): this;
+    setScale(scale: any): this;
+    setMatrix(matrix: any, copyMatrix?: boolean): void;
+    setMatrixComponents(components: {
+        position?: any;
+        rotation?: any;
+        scale?: any;
+        update?: boolean;
+    }): this;
+    updateMatrix(): this;
+    update(options?: {
+        position?: any;
+        rotation?: any;
+        scale?: any;
+    }): this;
+    getCoordinateUniforms(viewMatrix: any, modelMatrix?: any): {
+        viewMatrix: any;
+        modelMatrix: any;
+        objectMatrix: any;
+        worldMatrix: any;
+        worldInverseMatrix: any;
+        worldInverseTransposeMatrix: any;
+    };
+    _setScenegraphNodeProps(props: ScenegraphNodeProps): void;
+}
+//# sourceMappingURL=scenegraph-node.d.ts.map

package/dist/scenegraph/scenegraph-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenegraph-node.d.ts","sourceRoot":"","sources":["../../src/scenegraph/scenegraph-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,WAAW,EAAC,MAAM,eAAe,CAAC;AACvD,OAAO,EAAC,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAE/C,+CAA+C;AAC/C,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,2CAA2C;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,qBAAa,cAAc;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAiB;IAEhC,OAAO,UAAQ;IACf,QAAQ,UAAiB;IACzB,QAAQ,UAAiB;IACzB,KAAK,UAAwB;IAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM;IAEvC,KAAK,EAAE,mBAAmB,CAAM;gBAEpB,KAAK,GAAE,mBAAwB;IAQ3C,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI;IAIxC,OAAO,IAAI,IAAI;IAEf,iCAAiC;IACjC,MAAM,IAAI,IAAI;IAGd,QAAQ,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAK1C,QAAQ,IAAI,MAAM;IAIlB,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAMhC,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAMhC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAM1B,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,GAAE,OAAc,GAAG,IAAI;IAQxD,mBAAmB,CAAC,UAAU,EAAE;QAC9B,QAAQ,CAAC,EAAE,GAAG,CAAC;QACf,QAAQ,CAAC,EAAE,GAAG,CAAC;QACf,KAAK,CAAC,EAAE,GAAG,CAAC;QACZ,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,GAAG,IAAI;IAiBR,YAAY,IAAI,IAAI;IAYpB,MAAM,CAAC,OAAO,GAAE;QAAC,QAAQ,CAAC,EAAE,GAAG,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,CAAC;QAAC,KAAK,CAAC,EAAE,GAAG,CAAA;KAAM,GAAG,IAAI;IAezE,qBAAqB,CACnB,UAAU,EAAE,GAAG,EACf,WAAW,CAAC,EAAE,GAAG,GAChB;QACD,UAAU,EAAE,GAAG,CAAC;QAChB,WAAW,EAAE,GAAG,CAAC;QACjB,YAAY,EAAE,GAAG,CAAC;QAClB,WAAW,EAAE,GAAG,CAAC;QACjB,kBAAkB,EAAE,GAAG,CAAC;QACxB,2BAA2B,EAAE,GAAG,CAAC;KAClC;IA0CD,uBAAuB,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI;CAsB1D"}

package/dist/scenegraph/scenegraph-node.js

@@ -0,0 +1,153 @@
+import { assert, uid } from '@luma.gl/core';
+import { Vector3, Matrix4 } from '@math.gl/core';
+export class ScenegraphNode {
+    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);
+    }
+    getBounds() {
+        return null;
+    }
+    destroy() { }
+    /** @deprecated use .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, copyMatrix = true) {
+        if (copyMatrix) {
+            this.matrix.copy(matrix);
+        }
+        else {
+            this.matrix = matrix;
+        }
+    }
+    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;
+    }
+    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(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;
+    }
+    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);
+    }
+}

package/dist/shader-inputs.d.ts

@@ -0,0 +1,63 @@
+import type { UniformValue, Texture, Sampler } from '@luma.gl/core';
+import { ShaderModuleInstance } from '@luma.gl/shadertools';
+/** 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, Texture | Sampler> = Record<string, Texture | Sampler>> = {
+    defaultUniforms?: UniformsT;
+    getUniforms?: (settings: Partial<PropsT>, prevUniforms?: UniformsT) => UniformsT;
+    /** 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,
+ * - 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 declare class ShaderInputs<ShaderPropsT extends Partial<Record<string, Record<string, unknown>>> = Partial<Record<string, Record<string, unknown>>>> {
+    /**
+     * The map of modules
+     * @todo should should this include the resolved dependencies?
+     */
+    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, Texture | Sampler>>;
+    /** Tracks if uniforms have changed */
+    moduleUniformsChanged: Record<keyof ShaderPropsT, false | string>;
+    /**
+     * Create a new UniformStore instance
+     * @param modules
+     */
+    constructor(modules: {
+        [P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>;
+    });
+    /** Destroy */
+    destroy(): void;
+    /**
+     * Set module props
+     */
+    setProps(props: Partial<{
+        [P in keyof ShaderPropsT]?: Partial<ShaderPropsT[P]>;
+    }>): void;
+    /** Merges all bindings for the shader (from the various modules) */
+    /**
+     * Return the map of modules
+     * @todo should should this include the resolved dependencies?
+     */
+    getModules(): ShaderModuleInstance[];
+    /** Get all uniform values for all modules */
+    getUniformValues(): Record<keyof ShaderPropsT, Record<string, UniformValue>>;
+    /** Merges all bindings for the shader (from the various modules) */
+    getBindings(): Record<string, Texture | Sampler>;
+    getDebugTable(): Record<string, Record<string, unknown>>;
+}
+//# sourceMappingURL=shader-inputs.d.ts.map

package/dist/shader-inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-inputs.d.ts","sourceRoot":"","sources":["../src/shader-inputs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAGlE,OAAO,EAAkB,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAE3E,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,CAC5B,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC7E,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IACrF;IACF,eAAe,CAAC,EAAE,SAAS,CAAC;IAC5B,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,KAAK,SAAS,CAAC;IAEjF,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,QAAQ,CAAC,EAAE,MAAM,CACf,MAAM,SAAS,EACf;QACE,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;KAC1C,CACF,CAAC;IAEF,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,YAAY,CACvB,YAAY,SAAS,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAC7E,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CACxC;IAED;;;OAGG;IACH,OAAO,EAAE,QAAQ,CAAC;SAAE,CAAC,IAAI,MAAM,YAAY,GAAG,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;KAAC,CAAC,CAAC;IAEpF,gDAAgD;IAChD,cAAc,EAAE,MAAM,CAAC,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IACzE,mDAAmD;IACnD,cAAc,EAAE,MAAM,CAAC,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAC9E,sCAAsC;IACtC,qBAAqB,EAAE,MAAM,CAAC,MAAM,YAAY,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC;IAElE;;;OAGG;gBACS,OAAO,EAAE;SAAE,CAAC,IAAI,MAAM,YAAY,GAAG,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;KAAC;IAwBrF,cAAc;IACd,OAAO,IAAI,IAAI;IAEf;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;SAAE,CAAC,IAAI,MAAM,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;KAAC,CAAC,GAAG,IAAI;IA0BtF,oEAAoE;IAKpE;;;OAGG;IACH,UAAU,IAAI,oBAAoB,EAAE;IAIpC,6CAA6C;IAC7C,gBAAgB,IAAI,MAAM,CAAC,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAI5E,oEAAoE;IACpE,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC;IAQhD,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAYzD"}

package/dist/shader-inputs.js

@@ -0,0 +1,107 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+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 {
+    /**
+     * 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 */
+    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;
+        }
+    }
+    /** 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);
+    }
+    /** 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;
+    }
+}

package/dist/transform/buffer-transform.d.ts

@@ -0,0 +1,35 @@
+import { Device, Buffer, BufferRange, TransformFeedback, RenderPassProps } from '@luma.gl/core';
+import { Model } from "../model/model.js";
+import type { ModelProps } from '..';
+/**
+ * Properties for creating a {@link BufferTransform}
+ * @deprecated
+ */
+export type BufferTransformProps = Omit<ModelProps, 'fs'> & {
+    fs?: ModelProps['fs'];
+    feedbackBuffers?: Record<string, Buffer | BufferRange>;
+};
+/**
+ * Creates a pipeline for buffer→buffer transforms.
+ * @deprecated
+ */
+export declare class BufferTransform {
+    readonly device: Device;
+    readonly model: Model;
+    readonly transformFeedback: TransformFeedback;
+    /** @deprecated Use device feature test. */
+    static isSupported(device: Device): boolean;
+    constructor(device: Device, props?: BufferTransformProps);
+    /** Destroy owned resources. */
+    destroy(): void;
+    /** @deprecated Use {@link destroy}. */
+    delete(): void;
+    /** Run one transform loop. */
+    run(options?: RenderPassProps): void;
+    /** @deprecated */
+    update(...args: any[]): void;
+    /** Returns the {@link Buffer} or {@link BufferRange} for given varying name. */
+    getBuffer(varyingName: string): Buffer | BufferRange | null;
+    readAsync(varyingName: string): Promise<Uint8Array>;
+}
+//# sourceMappingURL=buffer-transform.d.ts.map

package/dist/transform/buffer-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-transform.d.ts","sourceRoot":"","sources":["../../src/transform/buffer-transform.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,MAAM,EACN,MAAM,EACN,WAAW,EACX,iBAAiB,EAEjB,eAAe,EAChB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,KAAK,EAAC,0BAAuB;AACrC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,IAAI,CAAC;AAEnC;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG;IAC1D,EAAE,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC;CACxD,CAAC;AAEF;;;GAGG;AACH,qBAAa,eAAe;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAE9C,2CAA2C;IAC3C,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;gBAI/B,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,oBAAyC;IAsB5E,+BAA+B;IAC/B,OAAO,IAAI,IAAI;IAMf,uCAAuC;IACvC,MAAM,IAAI,IAAI;IAId,8BAA8B;IAC9B,GAAG,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI;IAMpC,kBAAkB;IAClB,MAAM,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAO5B,gFAAgF;IAChF,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,IAAI;IAI3D,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAQpD"}

package/dist/transform/buffer-transform.js

@@ -0,0 +1,70 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Buffer, assert } from '@luma.gl/core';
+import { getPassthroughFS } from '@luma.gl/shadertools';
+import { Model } from "../model/model.js";
+/**
+ * Creates a pipeline for buffer→buffer transforms.
+ * @deprecated
+ */
+export class BufferTransform {
+    device;
+    model;
+    transformFeedback;
+    /** @deprecated Use device feature test. */
+    static isSupported(device) {
+        return device?.info?.type === 'webgl';
+    }
+    constructor(device, props = Model.defaultProps) {
+        assert(BufferTransform.isSupported(device), 'BufferTransform not yet implemented on WebGPU');
+        this.device = device;
+        this.model = new Model(this.device, {
+            id: props.id || 'buffer-transform-model',
+            fs: props.fs || getPassthroughFS(),
+            topology: props.topology || 'point-list',
+            ...props
+        });
+        this.transformFeedback = this.device.createTransformFeedback({
+            layout: this.model.pipeline.shaderLayout,
+            buffers: props.feedbackBuffers
+        });
+        this.model.setTransformFeedback(this.transformFeedback);
+        Object.seal(this);
+    }
+    /** Destroy owned resources. */
+    destroy() {
+        if (this.model) {
+            this.model.destroy();
+        }
+    }
+    /** @deprecated Use {@link destroy}. */
+    delete() {
+        this.destroy();
+    }
+    /** Run one transform loop. */
+    run(options) {
+        const renderPass = this.device.beginRenderPass(options);
+        this.model.draw(renderPass);
+        renderPass.end();
+    }
+    /** @deprecated */
+    update(...args) {
+        // TODO(v9): Method should likely be removed for v9. Keeping a method stub
+        // to assist with migrating DeckGL usage.
+        // eslint-disable-next-line no-console
+        console.warn('TextureTransform#update() not implemented');
+    }
+    /** Returns the {@link Buffer} or {@link BufferRange} for given varying name. */
+    getBuffer(varyingName) {
+        return this.transformFeedback.getBuffer(varyingName);
+    }
+    readAsync(varyingName) {
+        const result = this.getBuffer(varyingName);
+        if (result instanceof Buffer) {
+            return result.readAsync();
+        }
+        const { buffer, byteOffset = 0, byteLength = buffer.byteLength } = result;
+        return buffer.readAsync(byteOffset, byteLength);
+    }
+}