@woosh/meep-engine 3.33.0 → 3.34.0

package/src/engine/graphics/particles/particular/group/optimizeCommandQueue.js

@@ -1,162 +0,0 @@
-import { OperationType } from "./OperationType.js";
-
-/**
- *
- * @param {Operation[]} queue
- */
-export function optimizeCommandQueue(queue) {
-
-    /**
-     * TODO this is pretty slow and should be optimized
-     * @param {Array.<Operation>} queue
-     */
-    function cutRedundantOperations(queue) {
-        const queueLength = queue.length;
-        loop_Main: for (let i = queueLength - 1; i >= 0; i--) {
-            const opA = queue[i];
-            if (opA.operator === OperationType.Add) {
-                //nothing to do
-                continue;
-            }
-            const operandsA = opA.operands;
-            if (opA.operator === OperationType.Remove) {
-                //hunt and delete operations before this remove that affect deleted references
-                for (let k = 0, kl = operandsA.length; k < kl; k++) {
-                    const refA = operandsA[k];
-
-                    //walk the queue back and remove all previous operations on these references
-                    loop_B: for (let j = i - 1; j >= 0; j--) {
-                        const opB = queue[j];
-                        const operandsB = opB.operands;
-                        const operatorB = opB.operator;
-                        if (operatorB === OperationType.WriteAttribute) {
-                            const refB = operandsB[0];
-                            if (refA === refB) {
-                                //cut operation
-                                queue.splice(j, 1);
-                                i--;
-                            }
-                        } else if (operatorB === OperationType.Add) {
-                            for (let m = 0, ml = operandsB.length; m < ml; m++) {
-                                const refB = operandsB[m];
-                                if (refA === refB) {
-                                    let jump = 0;
-                                    //delete operation and add operation cancel each other out
-                                    if (kl > 1) {
-                                        operandsA.splice(k, 1);
-                                        kl--;
-                                        k--;
-                                    } else {
-                                        queue.splice(i, 1);
-                                        i--;
-                                        jump |= 2;
-                                    }
-
-                                    if (ml > 1) {
-                                        operandsB.splice(m, 1);
-                                        m--;
-                                        ml--;
-                                    } else {
-                                        //cut operation from the queue
-                                        queue.splice(j, 1);
-                                        i--;
-                                        jump |= 1;
-                                    }
-
-                                    if ((jump & 2) !== 0) {
-                                        continue loop_Main;
-                                    } else if (jump !== 0) {
-                                        continue loop_B;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            } else if (opA.operator === OperationType.WriteAttribute) {
-                //find other operations that modify the same attribute, any previous operations are redundant at this point
-                const refA = operandsA[0];
-                const attributeIndexA = operandsA[1];
-                //walk the queue back and remove all previous operations on these references
-                for (let j = i - 1; j >= 0; j--) {
-                    const opB = queue[j];
-                    if (opB.operator !== OperationType.WriteAttribute) {
-                        //ignore
-                        continue;
-                    }
-
-                    const operandsB = opB.operands;
-                    if (operandsB[0] === refA && operandsB[1] === attributeIndexA) {
-                        //operation will be overwritten anyway, cut it
-                        queue.splice(j, 1);
-                        i--;
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {Array.<Operation>} queue
-     */
-    function groupOperations(queue) {
-        let l = queue.length;
-        for (let i = 0; i < l; i++) {
-            const opA = queue[i];
-            const operatorA = opA.operator;
-            const operandsA = opA.operands;
-            if (operatorA === OperationType.Add || operatorA === OperationType.Remove) {
-                for (let j = i + 1; j < l; j++) {
-                    const opB = queue[j];
-                    if (opB.operator === operatorA) {
-                        const operandsB = opB.operands;
-                        const numOperands = operandsB.length;
-
-                        for (let k = 0; k < numOperands; k++) {
-                            const refB = operandsB[k];
-                            if (operandsA.indexOf(refB) === -1) {
-                                operandsA.push(refB);
-                            }
-                        }
-
-                        queue.splice(j, 1);
-                        j--;
-                        l--;
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * @param {Array.<Operation>} queue
-     */
-    function sortOperations(queue) {
-        queue.sort(function (a, b) {
-            const operatorA = a.operator;
-            const operatorB = b.operator;
-
-            //it's important that Add and Remove operations are sorted to the front of the queue, before Write operations
-            if (operatorA < operatorB) {
-                return -1;
-            } else if (operatorA > operatorB) {
-                return 1;
-            }
-
-            if (operatorA !== OperationType.WriteAttribute) {
-                return 0;
-            }
-
-            const attributeIndexA = a.operands[1];
-            const attributeIndexB = b.operands[1];
-
-            //sort write operations by buffer index
-            return attributeIndexB - attributeIndexA;
-        });
-    }
-
-    cutRedundantOperations(queue);
-    groupOperations(queue);
-    sortOperations(queue);
-}

package/src/engine/graphics/particles/particular/group/typedArrayConstructorFromDataType.d.ts

@@ -1,8 +0,0 @@
-/**
- *
- * @param {ParticleDataType} type
- * @returns {*}
- */
-export function typedArrayConstructorFromDataType(type: ParticleDataType): any;
-import { ParticleDataType } from "./ParticleDataType.js";
-//# sourceMappingURL=typedArrayConstructorFromDataType.d.ts.map

package/src/engine/graphics/particles/particular/group/typedArrayConstructorFromDataType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typedArrayConstructorFromDataType.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/particles/particular/group/typedArrayConstructorFromDataType.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wDAHW,gBAAgB,OAc1B;iCAlBgC,uBAAuB"}

package/src/engine/graphics/particles/particular/group/typedArrayConstructorFromDataType.js

@@ -1,19 +0,0 @@
-import { ParticleDataType } from "./ParticleDataType.js";
-
-/**
- *
- * @param {ParticleDataType} type
- * @returns {*}
- */
-export function typedArrayConstructorFromDataType(type) {
-    switch (type) {
-        case ParticleDataType.Float32:
-            return Float32Array;
-        case ParticleDataType.Float64:
-            return Float64Array;
-        case ParticleDataType.Uint8:
-            return Uint8Array;
-        default:
-            throw new Error(`Unsupported type: ${type}`);
-    }
-}

package/src/engine/graphics3/ParticleEmitterSystem.d.ts

@@ -1,77 +0,0 @@
-/**
- * Draws the game's particle effects under Shade.
- *
- * **The simulation does not move.** `particular` emits, ages, integrates and colours particles on
- * the CPU, and that is where it stays: the plan makes Shade's GPU particle system a later, opt-in
- * upgrade rather than this port. What changes is only what happens to the state it produces each
- * frame — instead of a three `Points` object per emitter, it is packed into the layout Shade's own
- * billboard renderer reads.
- *
- * **No visibility layer comes across.** The legacy system drives a render layer backed by a BVH and
- * puts emitters to sleep when they leave the visible set; §4.5 retires CPU render culling, so every
- * linked emitter simulates and the GPU decides what is on screen. An emitter that should not
- * simulate says so itself, through {@link ParticleEmitterFlag.Emitting}.
- * @deprecated use {@link GPUParticleSystem} instead, it can do everything this can and more.
- */
-export class ParticleEmitterSystem extends System<any> {
-    /**
-     * @param {GraphicsEngine} graphics
-     * @param {AssetManager} assets
-     */
-    constructor(graphics: GraphicsEngine, assets: AssetManager);
-    dependencies: (typeof Transform64 | typeof ParticleEmitter)[];
-    /**
-     * What the pass draws. Read-only — the emitters follow the entities.
-     *
-     * @returns {ParticleEmitter[]}
-     */
-    get emitters(): ParticleEmitter[];
-    startup(entityManager: any): Promise<void>;
-    shutdown(entityManager: any): Promise<void>;
-    /**
-     * @param {ParticleEmitter} emitter
-     * @param {Transform64} transform
-     * @param {number} entity
-     */
-    link(emitter: ParticleEmitter, transform: Transform64, entity: number): void;
-    /**
-     * Rebuild an emitter that has been edited structurally — layers added or removed, a sprite
-     * changed, a parameter curve redrawn.
-     *
-     * The pool, the parameter tracks and the atlas references are all built from the emitter's
-     * description, so an edit to that description is only visible once they are built again. Sleep
-     * state is preserved because it is the editor's, not the emitter's.
-     *
-     * @param {ParticleEmitter} emitter one this system has linked
-     */
-    rebuild(emitter: ParticleEmitter): void;
-    /**
-     * @param {ParticleEmitter} emitter
-     * @param {Transform64} transform
-     * @param {number} entity
-     */
-    unlink(emitter: ParticleEmitter, transform: Transform64, entity: number): void;
-    update(timeDelta: any): void;
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame: FrameContext): void;
-    #private;
-}
-/**
- * Emitters draw into the scene, so they are subject to the fog of war that conceals it — which is
- * a declaration on the fog rather than a placement here.
- */
-export class ParticleExtension extends RenderExtension {
-    /**
-     * @param {ParticleEmitterSystem} system
-     */
-    constructor(system: ParticleEmitterSystem);
-    record(frame: any): void;
-    #private;
-}
-import { System } from "../ecs/System.js";
-import { Transform64 } from "../ecs/transform/Transform64.js";
-import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-//# sourceMappingURL=ParticleEmitterSystem.d.ts.map

package/src/engine/graphics3/ParticleEmitterSystem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticleEmitterSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AACH;IAiDI;;;OAGG;IACH,4DAUC;IA9DD,8DAA8C;IAuC9C;;;;OAIG;IACH,kCAEC;IAkBD,2CAUC;IAED,4CAeC;IAED;;;;OAIG;IACH,cAJW,eAAe,aACf,WAAW,UACX,MAAM,QAsChB;IAED;;;;;;;;;OASG;IACH,iBAFW,eAAe,QAqBzB;IAED;;;;OAIG;IACH,gBAJW,eAAe,aACf,WAAW,UACX,MAAM,QA0BhB;IAED,6BAaC;IAED;;OAEG;IACH,kCA+BC;;CACJ;AAED;;;GAGG;AACH;IAUI;;OAEG;IACH,oBAFW,qBAAqB,EAM/B;IAED,yBAEC;;CACJ;uBA5SsB,kBAAkB;4BACb,iCAAiC;gCAC7B,oEAAoE;gCANpE,mDAAmD"}

package/src/engine/graphics3/ParticleEmitterSystem.js

@@ -1,307 +0,0 @@
-import { assert } from "../../core/assert.js";
-import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-import { SceneColor } from "../../shade/renderer/extension/SceneColor.js";
-import { ViewTextures } from "../../shade/renderer/extension/ViewTextures.js";
-import { ImageRGBADataLoader } from "../asset/loaders/image/ImageRGBADataLoader.js";
-import { System } from "../ecs/System.js";
-import { Transform64 } from "../ecs/transform/Transform64.js";
-import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
-import { ParticleEmitterFlag } from "../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
-import { ParticularEngine } from "../graphics/particles/particular/engine/ParticularEngine.js";
-import { GPUParticularRenderer } from "./particles/GPUParticularRenderer.js";
-import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
-
-/**
- * Draws the game's particle effects under Shade.
- *
- * **The simulation does not move.** `particular` emits, ages, integrates and colours particles on
- * the CPU, and that is where it stays: the plan makes Shade's GPU particle system a later, opt-in
- * upgrade rather than this port. What changes is only what happens to the state it produces each
- * frame — instead of a three `Points` object per emitter, it is packed into the layout Shade's own
- * billboard renderer reads.
- *
- * **No visibility layer comes across.** The legacy system drives a render layer backed by a BVH and
- * puts emitters to sleep when they leave the visible set; §4.5 retires CPU render culling, so every
- * linked emitter simulates and the GPU decides what is on screen. An emitter that should not
- * simulate says so itself, through {@link ParticleEmitterFlag.Emitting}.
- * @deprecated use {@link GPUParticleSystem} instead, it can do everything this can and more.
- */
-export class ParticleEmitterSystem extends System {
-    dependencies = [ParticleEmitter, Transform64];
-
-    /**
-     * @type {GraphicsEngine}
-     */
-    #graphics;
-
-    /**
-     * @type {AssetManager}
-     */
-    #assets;
-
-    /**
-     * @type {ParticularEngine}
-     */
-    #engine;
-
-    /**
-     * @type {GPUParticularRenderer}
-     */
-    #renderer = new GPUParticularRenderer();
-
-    /**
-     * The emitters to simulate and draw, in link order.
-     *
-     * @type {ParticleEmitter[]}
-     */
-    #emitters = [];
-
-    /**
-     * @type {Map<number, {emitter: ParticleEmitter, position: Function, rotation: Function, scale: Function}>}
-     */
-    #entries = new Map();
-
-    /**
-     * @type {RenderExtension|null}
-     */
-    #extension = null;
-
-    /**
-     * What the pass draws. Read-only — the emitters follow the entities.
-     *
-     * @returns {ParticleEmitter[]}
-     */
-    get emitters() {
-        return this.#emitters;
-    }
-
-    /**
-     * @param {GraphicsEngine} graphics
-     * @param {AssetManager} assets
-     */
-    constructor(graphics, assets) {
-        super();
-
-        assert.defined(graphics, 'graphics');
-        assert.defined(assets, 'assets');
-
-        this.#graphics = graphics;
-        this.#assets = assets;
-
-        this.#engine = new ParticularEngine(assets);
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-
-        this.#extension = this.#graphics.add_extension(new ParticleExtension(this));
-
-        const assets = this.#assets;
-
-        if (!assets.hasLoaderForType('image')) {
-            await assets.registerLoader('image', new ImageRGBADataLoader());
-        }
-    }
-
-    async shutdown(entityManager) {
-        if (this.#extension !== null) {
-            this.#graphics.remove_extension(this.#extension);
-
-            this.#extension = null;
-        }
-
-        this.#renderer.destroy();
-
-        // every emitter has been unlinked by this point — both teardown paths detach the dataset or
-        // remove the system observer first — so what is left is the shared sprite atlas
-        this.#engine.dispose();
-
-        this.#emitters.length = 0;
-        this.#entries.clear();
-    }
-
-    /**
-     * @param {ParticleEmitter} emitter
-     * @param {Transform64} transform
-     * @param {number} entity
-     */
-    link(emitter, transform, entity) {
-        const position = (x, y, z) => emitter.position.set(x, y, z);
-        const rotation = (x, y, z, w) => emitter.rotation.set(x, y, z, w);
-        const scale = (x, y, z) => emitter.scale.set(x, y, z);
-
-        // `process` was Vector3's "call me with the components" helper; the transform hands
-        // them over directly
-        position(transform.translation_x, transform.translation_y, transform.translation_z);
-        rotation(transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w);
-        scale(transform.scale_x, transform.scale_y, transform.scale_z);
-
-        // Vector3.process called the callback AND subscribed. The transform has no signals, so
-        // the subscription half becomes one dataset listener that re-pushes the whole pose.
-        const on_transform_changed = () => {
-            position(transform.translation_x, transform.translation_y, transform.translation_z);
-            rotation(transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w);
-            scale(transform.scale_x, transform.scale_y, transform.scale_z);
-        };
-
-        this.entityManager.dataset.addEntityEventListener(
-            entity, TRANSFORM64_EVENT_CHANGE, on_transform_changed
-        );
-
-        this.#entries.set(entity, { emitter, position, rotation, scale, on_transform_changed });
-
-        emitter.id = entity;
-
-        /*
-         Awake from the start. The legacy system links emitters asleep and lets its visibility layer
-         wake them; there is no such layer here, and an emitter that never wakes never emits.
-        */
-        emitter.clearFlag(ParticleEmitterFlag.Sleeping);
-
-        this.#engine.add(emitter);
-
-        this.#emitters.push(emitter);
-    }
-
-    /**
-     * Rebuild an emitter that has been edited structurally — layers added or removed, a sprite
-     * changed, a parameter curve redrawn.
-     *
-     * The pool, the parameter tracks and the atlas references are all built from the emitter's
-     * description, so an edit to that description is only visible once they are built again. Sleep
-     * state is preserved because it is the editor's, not the emitter's.
-     *
-     * @param {ParticleEmitter} emitter one this system has linked
-     */
-    rebuild(emitter) {
-        assert.ok(this.#emitters.includes(emitter), 'emitter is not linked to this system');
-
-        const engine = this.#engine;
-
-        const sleeping = emitter.getFlag(ParticleEmitterFlag.Sleeping);
-
-        engine.remove(emitter);
-
-        emitter.clearFlag(ParticleEmitterFlag.Built | ParticleEmitterFlag.Initialized);
-
-        emitter.registerLayerParameters();
-        emitter.build();
-        emitter.initialize();
-        emitter.computeBoundingBox();
-
-        engine.add(emitter);
-
-        emitter.writeFlag(ParticleEmitterFlag.Sleeping, sleeping);
-    }
-
-    /**
-     * @param {ParticleEmitter} emitter
-     * @param {Transform64} transform
-     * @param {number} entity
-     */
-    unlink(emitter, transform, entity) {
-        const entry = this.#entries.get(entity);
-
-        if (entry === undefined) {
-            return;
-        }
-
-        if (entry.on_transform_changed !== undefined) {
-            this.entityManager.dataset.removeEntityEventListener(
-                entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
-            );
-        }
-
-        this.#entries.delete(entity);
-
-        const index = this.#emitters.indexOf(emitter);
-
-        if (index !== -1) {
-            this.#emitters.splice(index, 1);
-        }
-
-        this.#engine.remove(emitter);
-
-        emitter.dispose();
-    }
-
-    update(timeDelta) {
-        this.#engine.advance(timeDelta);
-
-        const emitters = this.#emitters;
-
-        for (let i = 0; i < emitters.length; i++) {
-            // retires dead particles and compacts the pool, which is what makes the live ones a
-            // contiguous run for the packer
-            emitters[i].update();
-        }
-
-        // repacks the sprite atlas when an effect has brought a new sprite in
-        this.#engine.shaderManager.spriteAtlas.atlas.update();
-    }
-
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame) {
-        const emitters = this.#emitters;
-
-        if (emitters.length === 0) {
-            return;
-        }
-
-        const camera_context = frame.view.camera;
-
-        // the camera's world transform, whose first two columns are the axes a billboard is built on
-        const m = camera_context.camera.transform;
-
-        /*
-         The particles are packed and uploaded inside the pass rather than here: that needs a
-         `GraphicsContext`, which the frame graph hands out at execution time and the frame does not
-         carry. So the pass is recorded whether or not anything is alive, and draws nothing when
-         nothing is — which leaves the frame's colour exactly as it was either way.
-        */
-        const scene = frame.get(SceneColor);
-
-        scene.color = this.#renderer.graph_draw({
-            graph: frame.graph,
-            color: scene.color,
-            depth: frame.get(ViewTextures).depth,
-            camera: camera_context.buffer,
-            emitters,
-            atlas: this.#engine.shaderManager.spriteAtlas.atlas.sampler,
-            camera_position: [m[12], m[13], m[14]],
-            camera_right: [m[0], m[1], m[2]],
-            camera_up: [m[4], m[5], m[6]]
-        });
-    }
-}
-
-/**
- * Emitters draw into the scene, so they are subject to the fog of war that conceals it — which is
- * a declaration on the fog rather than a placement here.
- */
-export class ParticleExtension extends RenderExtension {
-    name = "particles";
-
-    phase = FramePhase.AfterTransparency;
-
-    /**
-     * @type {ParticleEmitterSystem}
-     */
-    #system;
-
-    /**
-     * @param {ParticleEmitterSystem} system
-     */
-    constructor(system) {
-        super();
-
-        this.#system = system;
-    }
-
-    record(frame) {
-        this.#system.record(frame);
-    }
-}

package/src/engine/graphics3/ParticleEmitterSystem3.d.ts

@@ -1,10 +0,0 @@
-/**
- * @deprecated Renamed to {@link ParticleEmitterSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
- * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
- *
- * Kept as a re-export rather than removed: this is a library, and an import path is as much a
- * published interface as a class name.
- */
-export const ParticleEmitterSystem3: typeof ParticleEmitterSystem;
-import { ParticleEmitterSystem } from "./ParticleEmitterSystem.js";
-//# sourceMappingURL=ParticleEmitterSystem3.d.ts.map

package/src/engine/graphics3/ParticleEmitterSystem3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParticleEmitterSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticleEmitterSystem3.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,kEAA4D;sCATtB,4BAA4B"}

package/src/engine/graphics3/ParticleEmitterSystem3.js

@@ -1,10 +0,0 @@
-import { ParticleEmitterSystem } from "./ParticleEmitterSystem.js";
-
-/**
- * @deprecated Renamed to {@link ParticleEmitterSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
- * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
- *
- * Kept as a re-export rather than removed: this is a library, and an import path is as much a
- * published interface as a class name.
- */
-export const ParticleEmitterSystem3 = ParticleEmitterSystem;

package/src/engine/graphics3/particles/GPUParticularRenderer.d.ts

@@ -1,61 +0,0 @@
-/**
- * Draws `particular`'s CPU-simulated particles with **Shade's own billboard renderer**.
- *
- * The simulation stays where it is — emission, ageing, parameter tracks, sorting and bounds are
- * meep's and are unchanged — and what crosses to the GPU each frame is the state it produced, in
- * the layout that renderer already reads: a pool of particle records, a list of the slots to draw,
- * and one emitter record per particle *layer* saying where that layer's sprite is in the atlas and
- * how it blends.
- *
- * Nothing here is a shader. The billboard expansion, the atlas lookup, the soft-depth fade and the
- * premultiplied blend that expresses both alpha and additive in one pipeline are Shade's, already
- * written and already tested; this is the packer and the residency that lets them draw somebody
- * else's particles.
- */
-export class GPUParticularRenderer {
-    /**
-     * How many particles are waiting to be drawn. Read-only, and zero until {@link update} has run.
-     *
-     * @returns {number}
-     */
-    get count(): number;
-    /**
-     * How many layer records the last pack wrote — the occupied rows of the emitter table.
-     *
-     * @returns {number}
-     */
-    get record_count(): number;
-    /**
-     * Record the billboard draw into `graph`, over the colour it is given.
-     *
-     * @param {object} args
-     * @param {FrameGraph} args.graph
-     * @param {number} args.color colour resource handle to draw over
-     * @param {number} args.depth scene depth — tested against, and sampled for the soft fade
-     * @param {GPUBuffer|GPUTypedBuffer} args.camera
-     * @param {ParticleEmitter[]} args.emitters
-     * @param {Sampler2D} args.atlas
-     * @param {number[]|Float32Array} args.camera_position world space
-     * @param {number[]|Float32Array} args.camera_right world space
-     * @param {number[]|Float32Array} args.camera_up world space
-     * @returns {number} the colour handle after the draw
-     */
-    graph_draw({ graph, color, depth, camera, emitters, atlas, camera_position, camera_right, camera_up }: {
-        graph: FrameGraph;
-        color: number;
-        depth: number;
-        camera: GPUBuffer | GPUTypedBuffer;
-        emitters: ParticleEmitter[];
-        atlas: Sampler2D;
-        camera_position: number[] | Float32Array;
-        camera_right: number[] | Float32Array;
-        camera_up: number[] | Float32Array;
-    }): number;
-    /**
-     * Give back everything held on the device. The renderer lives as long as the system that owns
-     * it, and a scene reload builds both again.
-     */
-    destroy(): void;
-    #private;
-}
-//# sourceMappingURL=GPUParticularRenderer.d.ts.map

package/src/engine/graphics3/particles/GPUParticularRenderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GPUParticularRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/particles/GPUParticularRenderer.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;GAaG;AACH;IAwGI;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,2BAEC;IAkTD;;;;;;;;;;;;;;OAcG;IACH;QAX4B,KAAK;QACT,KAAK,EAAlB,MAAM;QACO,KAAK,EAAlB,MAAM;QACyB,MAAM,EAArC,0BAAwB;QACA,QAAQ,EAAhC,iBAAiB;QACD,KAAK;QACO,eAAe,EAA3C,MAAM,EAAE,GAAC,YAAY;QACO,YAAY,EAAxC,MAAM,EAAE,GAAC,YAAY;QACO,SAAS,EAArC,MAAM,EAAE,GAAC,YAAY;QACnB,MAAM,CAiBlB;IAqFD;;;OAGG;IACH,gBA2BC;;CACJ"}