@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/renderer/particles/runtime/ProgramHeap.js

@@ -0,0 +1,595 @@
+import { assert } from "../../../../core/assert.js";
+import { Allocation, ALLOCATOR_NO_SPACE, OffsetAllocator } from "../../../../core/binary/allocator/OffsetAllocator.js";
+import { HashMap } from "../../../../core/collection/map/HashMap.js";
+import {
+    PARTICLE_PROGRAM_CODE_BASE_WORD,
+    PARTICLE_PROGRAM_HEADER_WORDS,
+    PARTICLE_VM_INSTRUCTION_WORDS,
+} from "../ParticleConstants.js";
+import { ProgramPlacement } from "./ProgramPlacement.js";
+
+/**
+ * Instructions the code section starts out able to hold. It doubles from here as programs are
+ * registered; a handful of typical effects fit without ever growing.
+ * @type {number}
+ */
+const INITIAL_CODE_CAPACITY = 128;
+
+/**
+ * Words the constant section starts out able to hold.
+ * @type {number}
+ */
+const INITIAL_CONSTANT_CAPACITY = 128;
+
+/**
+ * Ranges an allocator can describe at once, to begin with. Each live program costs one, plus one for
+ * the free remainder, and this grows with the set — it is a floor, not a ceiling.
+ * @type {number}
+ */
+const INITIAL_ALLOCATION_CAPACITY = 32;
+
+/**
+ * @type {Uint32Array}
+ */
+const EMPTY_WORDS = new Uint32Array(0);
+
+/**
+ * What a zero-length request gets: offset zero, and a metadata handle the allocator will refuse, so
+ * {@link ProgramRegion#free} can tell it from a range that has to be given back.
+ *
+ * A program with no INIT section, or with no constants at all, is ordinary — it reads nothing from
+ * the range it does not have — and asking the allocator for zero elements is not.
+ *
+ * @type {Allocation}
+ */
+const EMPTY_ALLOCATION = Object.freeze(Allocation.from(0, ALLOCATOR_NO_SPACE));
+
+/**
+ * One of the two sections of the packed buffer: a flat word array, and the
+ * {@link ../../../../core/binary/allocator/OffsetAllocator.js OffsetAllocator} that says which parts
+ * of it are in use.
+ *
+ * The unit is the ELEMENT, not the word — instructions for the code section, words for the constant
+ * pool — because that is the unit the emitter record's offsets are in. `stride` is what converts.
+ */
+class ProgramRegion {
+
+    /**
+     * Words per element: {@link PARTICLE_VM_INSTRUCTION_WORDS} for code, 1 for constants.
+     * @type {number}
+     */
+    stride;
+
+    /**
+     * @type {OffsetAllocator|null}
+     */
+    allocator = null;
+
+    /**
+     * The section's words, `capacity * stride` of them. Words outside a live allocation hold
+     * whatever the program that used to be there left — nothing addresses them.
+     * @type {Uint32Array}
+     */
+    words = EMPTY_WORDS;
+
+    /**
+     * Elements this section can hold.
+     * @type {number}
+     */
+    capacity = 0;
+
+    /**
+     * @param {number} stride words per element
+     */
+    constructor(stride) {
+        assert.isNonNegativeInteger(stride, 'stride');
+
+        this.stride = stride;
+    }
+
+    /**
+     * Throw away every allocation and start again at `capacity` elements. The words go with them —
+     * the caller is expected to write each surviving program back into its new range.
+     *
+     * @param {number} capacity elements
+     * @param {number} max_allocations ranges the allocator can describe at once
+     */
+    reset(capacity, max_allocations) {
+        assert.greaterThan(capacity, 0, 'capacity');
+        assert.greaterThan(max_allocations, 0, 'max_allocations');
+
+        this.capacity = capacity;
+        this.allocator = new OffsetAllocator(capacity, max_allocations);
+        this.words = new Uint32Array(capacity * this.stride);
+    }
+
+    /**
+     * @param {number} count elements
+     * @returns {Allocation|null} `null` when the section has no contiguous run that long, or no node
+     *          left to describe one with — both of which a repack fixes
+     */
+    allocate(count) {
+        assert.isNonNegativeInteger(count, 'count');
+
+        if (count === 0) {
+            return EMPTY_ALLOCATION;
+        }
+
+        const allocation = this.allocator.allocate(count);
+
+        if (allocation.offset === ALLOCATOR_NO_SPACE) {
+            return null;
+        }
+
+        return allocation;
+    }
+
+    /**
+     * @param {Allocation|null} allocation
+     */
+    free(allocation) {
+        if (allocation === null || allocation.metadata === ALLOCATOR_NO_SPACE) {
+            // never held a range of its own
+            return;
+        }
+
+        this.allocator.free(allocation);
+    }
+
+    /**
+     * @param {number} offset in elements
+     * @param {Uint32Array} words
+     */
+    write(offset, words) {
+        this.words.set(words, offset * this.stride);
+    }
+}
+
+/**
+ * Holds every distinct compiled {@link ../isa/ParticleProgram.js ParticleProgram} the emitter set
+ * runs, packs them into one buffer — a header, every constant pool, then every instruction stream —
+ * and hands back the {@link ./ProgramPlacement.js placement} each emitter records.
+ *
+ * Data before code, behind a four-word header whose first word says where the code starts: the VM
+ * reads both sections through one binding (a storage buffer per stage is not free, and code and
+ * constants are read together), and an emitter's constant pool sits next to the pools of the
+ * programs it shares a wave with.
+ *
+ * **Programs are placed, not appended.** Each section is a range allocator
+ * ({@link ../../../../core/binary/allocator/OffsetAllocator.js}) over a flat word array, so a
+ * program that is no longer wanted gives its space back and the next one takes it. This is what the
+ * emitter table has always been able to do, and what the packed buffer could not: an authoring
+ * session that adds, edits and drops effects for an hour no longer grows the buffer for an hour.
+ *
+ * Because VM instructions carry no absolute code addresses (control flow is branchless) and constant
+ * references are program-local (the VM adds the emitter's `constant_offset`), a program is
+ * relocatable — it can be placed at any offset, and moved to another one by copying its words and
+ * rewriting the placement. INIT and UPDATE are one allocation, laid out back-to-back, because they
+ * are always wanted together.
+ *
+ * **Deduplication is by CONTENT, not object identity**, and it is the {@link HashMap} that does it:
+ * two emitters that authored the same graph separately compile to distinct `ParticleProgram` objects
+ * holding the same bytecode, and `ParticleProgram` already answers `equals`/`hash` over exactly
+ * that. They land on one placement, one bucket, and one copy of the code. Keying on the emitter
+ * instead would be simpler and strictly worse: N emitters running one shared effect would become N
+ * buckets, each padded out to a whole workgroup, which both wastes lanes and splits a run that was
+ * already program-coherent.
+ *
+ * **Sharing is what makes {@link ProgramHeap#release} a reference count** rather than a delete: the
+ * last emitter of an effect frees it, and the ones before it do not.
+ */
+export class ProgramHeap {
+
+    /**
+     * Bumped whenever the packed buffer would come out different from the last one
+     * {@link ProgramHeap#build_buffer} produced — a program was placed, or the sections were
+     * repacked. A holder that uploads the buffer re-uploads when this moves.
+     *
+     * Releasing a program does NOT move it. The words it occupied are dead rather than changed, and
+     * re-uploading the buffer to remove bytes nothing addresses would be a rebuild for nothing; the
+     * next program placed there is what makes the buffer differ, and that bumps this.
+     *
+     * @type {number}
+     */
+    version = 0;
+
+    /**
+     * Bumped when a repack moved programs that were already placed — every existing placement now
+     * holds different offsets, so every emitter record built from one is out of date.
+     *
+     * Separate from {@link ProgramHeap#version} because the two ask for different work: that one
+     * says "upload the buffer again", this one says "restage every row". A repack moves both; an
+     * ordinary placement moves only the first.
+     *
+     * @type {number}
+     */
+    placement_version = 0;
+
+    /**
+     * The set, keyed by the bytecode itself. The default key functions are `equals`/`hash` on the
+     * key object, which is exactly what {@link ../isa/ParticleProgram.js} implements.
+     *
+     * @type {HashMap<import("../isa/ParticleProgram.js").ParticleProgram, ProgramPlacement>}
+     */
+    #programs = new HashMap();
+
+    /**
+     * @type {ProgramRegion}
+     */
+    #code = new ProgramRegion(PARTICLE_VM_INSTRUCTION_WORDS);
+
+    /**
+     * @type {ProgramRegion}
+     */
+    #constants = new ProgramRegion(1);
+
+    /**
+     * Id the next program gets when {@link ProgramHeap##free_program_ids} is empty. Also the number
+     * of id slots that have ever been in use at once, which is what
+     * {@link ProgramHeap#program_id_capacity} reports.
+     *
+     * @type {number}
+     */
+    #next_program_id = 0;
+
+    /**
+     * Ids of released programs, waiting to be handed out again. Keeping ids dense is not cosmetic:
+     * the id indexes a histogram bin in the simulation-order pass, so a set that churned through a
+     * thousand effects would otherwise histogram into a thousand bins to serve three.
+     *
+     * @type {number[]}
+     */
+    #free_program_ids = [];
+
+    /**
+     * @type {number}
+     */
+    #max_register_count = 0;
+
+    constructor() {
+        this.#code.reset(INITIAL_CODE_CAPACITY, INITIAL_ALLOCATION_CAPACITY);
+        this.#constants.reset(INITIAL_CONSTANT_CAPACITY, INITIAL_ALLOCATION_CAPACITY);
+    }
+
+    /**
+     * Distinct programs currently held — and therefore effects, not emitters.
+     * @returns {number}
+     */
+    get program_count() {
+        return this.#programs.size;
+    }
+
+    /**
+     * How many program ids the heap has had in play at once, which is the number of bins the
+     * simulation-order pass has to histogram into: live ids are all below it.
+     *
+     * It rises to the set's peak and stays there, because released ids are reused rather than
+     * renumbered. That costs an empty bin per id the set is currently below its peak by, and an
+     * empty bin is free — it rounds up to zero workgroups and shifts nothing after it — whereas
+     * renumbering would mean rewriting every emitter record that carries an id, and resizing the
+     * coherence buffers every time an effect came or went.
+     *
+     * @returns {number}
+     */
+    get program_id_capacity() {
+        return this.#next_program_id;
+    }
+
+    /**
+     * Register slots the hungriest program currently held needs — the maximum of every live
+     * program's `register_count`, and `0` for an empty heap.
+     *
+     * The heap has no opinion about what that number means; it is the caller that compares it
+     * against {@link ../ParticleConstants.js PARTICLE_VM_FAST_REGISTER_SLOTS} and picks an
+     * interpreter, because which register backing a pass is compiled against is the VM's business
+     * and not the store's. What matters here is that the number is a property of the SET: there is
+     * one pipeline per pass and it is chosen once, so one hungry effect decides for every emitter in
+     * the system, including the ones whose programs would have fit.
+     *
+     * It falls again when that effect is released. The heap knows exactly what it holds, so there is
+     * no reason for the answer to be a high-water mark that only a full rebuild could bring down.
+     *
+     * @returns {number}
+     */
+    get max_register_count() {
+        return this.#max_register_count;
+    }
+
+    /**
+     * Take a reference on `program`, placing it if the heap does not already hold an identical one.
+     *
+     * The placement it returns is what the emitter record carries and what the coherence pass
+     * buckets on. It is SHARED with every other holder of the same bytecode, and the heap mutates it
+     * in place when it repacks, so a caller keeps the object rather than copying its fields —
+     * copies go stale, the object does not.
+     *
+     * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
+     * @returns {ProgramPlacement}
+     */
+    acquire(program) {
+        assert.defined(program, 'program');
+
+        const existing = this.#programs.get(program);
+
+        if (existing !== undefined) {
+            existing.references++;
+
+            return existing;
+        }
+
+        // The heap keeps its own copy, because this is about to become a hash table key and hash
+        // table keys have to be immutable. A compiled program is treated as immutable everywhere,
+        // but nothing enforces it — the optimizer's passes rewrite these arrays in place — and a
+        // caller that rewrote one it had handed over would leave its own entry unfindable.
+        const owned = program.clone();
+
+        const placement = new ProgramPlacement();
+
+        placement.program = owned;
+        placement.program_id = this.#claim_program_id();
+        placement.references = 1;
+        placement.init_count = owned.init_instruction_count;
+        placement.update_count = owned.update_instruction_count;
+
+        // before the map: a repack walks what is already placed, and this is not yet one of them
+        this.#place(placement);
+
+        this.#programs.set(owned, placement);
+
+        if (owned.register_count > this.#max_register_count) {
+            this.#max_register_count = owned.register_count;
+        }
+
+        this.version++;
+
+        return placement;
+    }
+
+    /**
+     * Give back a reference taken by {@link ProgramHeap#acquire}. The program's ranges and its id are
+     * released when the last one goes.
+     *
+     * @param {ProgramPlacement} placement
+     * @returns {boolean} whether that was the last reference, and the program is now gone
+     */
+    release(placement) {
+        assert.defined(placement, 'placement');
+        assert.greaterThan(placement.references, 0, 'placement.references — this placement has already been released');
+
+        placement.references--;
+
+        // `!== 0` rather than `> 0`, so that a release too many walks past the freeing branch
+        // instead of back into it. The assert above is the real answer to that mistake, but asserts
+        // are stripped from a shipped build and this is not a mistake to be quiet about: a second
+        // free would push the program id onto the free list twice, and the two effects that later
+        // took it would histogram into one bucket and run each other's code.
+        if (placement.references !== 0) {
+            return false;
+        }
+
+        const program = placement.program;
+
+        this.#code.free(placement.code_allocation);
+        this.#constants.free(placement.constant_allocation);
+
+        placement.code_allocation = null;
+        placement.constant_allocation = null;
+
+        this.#programs.delete(program);
+        this.#free_program_ids.push(placement.program_id);
+
+        if (program.register_count >= this.#max_register_count) {
+            this.#max_register_count = this.#find_max_register_count();
+        }
+
+        return true;
+    }
+
+    /**
+     * The packed buffer: `[header][constants][code]`. Word
+     * {@link ../ParticleConstants.js PARTICLE_PROGRAM_CODE_BASE_WORD} of the header is the word index
+     * the code starts at — the only absolute address in the buffer, and the reason a placement can
+     * hold section-relative offsets and survive the sections being resized.
+     *
+     * Both sections come out at their full capacity rather than trimmed to what is live: the offsets
+     * a placement holds are offsets into the capacity, and trimming would mean moving programs to
+     * close the holes, which is what a repack is for and what a buffer rebuild should not silently
+     * become.
+     *
+     * @returns {Uint32Array}
+     */
+    build_buffer() {
+        const constants = this.#constants.words;
+        const code = this.#code.words;
+
+        const code_base = PARTICLE_PROGRAM_HEADER_WORDS + constants.length;
+        const buffer = new Uint32Array(code_base + code.length);
+
+        buffer[PARTICLE_PROGRAM_CODE_BASE_WORD] = code_base;
+        buffer.set(constants, PARTICLE_PROGRAM_HEADER_WORDS);
+        buffer.set(code, code_base);
+
+        return buffer;
+    }
+
+    /**
+     * @returns {number}
+     */
+    #claim_program_id() {
+        if (this.#free_program_ids.length > 0) {
+            return this.#free_program_ids.pop();
+        }
+
+        return this.#next_program_id++;
+    }
+
+    /**
+     * @returns {number} the largest `register_count` among the programs still held
+     */
+    #find_max_register_count() {
+        let result = 0;
+
+        this.#programs.forEach((placement) => {
+            const count = placement.program.register_count;
+
+            if (count > result) {
+                result = count;
+            }
+        });
+
+        return result;
+    }
+
+    /**
+     * Find room for `placement` and write its words there, repacking the sections first if there is
+     * none to be found.
+     *
+     * @param {ProgramPlacement} placement
+     */
+    #place(placement) {
+        if (this.#try_place(placement)) {
+            return;
+        }
+
+        this.#repack(placement.instruction_count, placement.constant_word_count, 1);
+
+        if (this.#try_place(placement)) {
+            return;
+        }
+
+        // Meant to be unreachable — {@link grown_capacity} sizes a section with slack for exactly
+        // this reason — and not left to the assert alone all the same. The sizing rests on an
+        // argument about how the allocator rounds its bins, and the cost of that argument being
+        // wrong is not an exception: it is a program placed nowhere, which is a shader reading
+        // whatever the words at offset zero happen to be. Doubling both sections is cheaper than
+        // being right.
+        this.#repack(placement.instruction_count, placement.constant_word_count, 2);
+
+        const placed = this.#try_place(placement);
+
+        assert.ok(placed, 'two repacks sized for this program still had no room for it');
+    }
+
+    /**
+     * Allocate both ranges, or neither, and on success write the program into them.
+     *
+     * Both or neither matters: a half-placed program would leak the half that succeeded through the
+     * repack that follows, which walks the programs the heap holds and this is not yet one of them.
+     *
+     * @param {ProgramPlacement} placement
+     * @returns {boolean} whether it fit
+     */
+    #try_place(placement) {
+        const program = placement.program;
+
+        const code = this.#code.allocate(placement.instruction_count);
+        const constants = this.#constants.allocate(program.constant_word_count);
+
+        if (code === null || constants === null) {
+            this.#code.free(code);
+            this.#constants.free(constants);
+
+            return false;
+        }
+
+        placement.code_allocation = code;
+        placement.constant_allocation = constants;
+
+        placement.init_offset = code.offset;
+        placement.update_offset = code.offset + placement.init_count;
+        placement.constant_offset = constants.offset;
+
+        this.#code.write(placement.init_offset, program.init);
+        this.#code.write(placement.update_offset, program.update);
+        this.#constants.write(placement.constant_offset, program.constant_words);
+
+        return true;
+    }
+
+    /**
+     * Lay both sections out again from scratch, with room for the programs already held plus one
+     * more of the given size.
+     *
+     * This is the only thing that moves a program, and it happens for one of two reasons: a section
+     * has no contiguous run long enough (its free space is there but scattered), or its allocator has
+     * no node left to describe another range with. Compaction answers both, and a section that is
+     * genuinely full grows on the way — the capacities are only ever raised here, never lowered, so
+     * a set that peaked at a hundred effects does not pay for a resize every time it returns to
+     * three.
+     *
+     * Ids survive: the offsets move, the `program_id` an emitter record carries does not.
+     *
+     * @param {number} extra_instructions
+     * @param {number} extra_constant_words
+     * @param {number} growth multiplier on the capacity a section is allowed to keep — `1` to let it
+     *        stay where it is if compacting was enough, `2` to insist that it at least doubles
+     */
+    #repack(extra_instructions, extra_constant_words, growth) {
+        /**
+         * @type {ProgramPlacement[]}
+         */
+        const placements = [];
+
+        let instructions = extra_instructions;
+        let constant_words = extra_constant_words;
+
+        this.#programs.forEach((placement) => {
+            placements.push(placement);
+
+            instructions += placement.instruction_count;
+            constant_words += placement.constant_word_count;
+        });
+
+        // one node per live range plus one for the free remainder, doubled so the allocator is not
+        // rebuilt again on the very next program
+        const max_allocations = Math.max(INITIAL_ALLOCATION_CAPACITY, (placements.length + 2) * 2);
+
+        this.#code.reset(
+            grown_capacity(this.#code.capacity * growth, instructions, INITIAL_CODE_CAPACITY),
+            max_allocations
+        );
+        this.#constants.reset(
+            grown_capacity(this.#constants.capacity * growth, constant_words, INITIAL_CONSTANT_CAPACITY),
+            max_allocations
+        );
+
+        for (let i = 0; i < placements.length; i++) {
+            const placed = this.#try_place(placements[i]);
+
+            assert.ok(placed, 'a freshly reset section had no room for a program it already held');
+        }
+
+        this.placement_version++;
+        this.version++;
+    }
+}
+
+/**
+ * A capacity that holds `required` elements with room to spare: the one it has, doubled until it
+ * does.
+ *
+ * Doubling rather than fitting exactly is what keeps the number of repacks logarithmic in the size
+ * of the set — a section grown to exactly what the newest program needed would be repacked again by
+ * the one after it.
+ *
+ * The room to spare is not tidiness, it is correctness. The allocator files a free run under the
+ * largest BIN that fits INSIDE it, and its bins are 3-bit floats, so consecutive bins are up to a
+ * ninth apart: a free run of 68 is filed under 64, while a request for 68 is looked up from 72 and
+ * never finds it. A section sized to exactly what it holds therefore refuses the last program that
+ * fits in it. An eighth of slack — `capacity * 8 >= required * 9` — is what makes "it fits" mean it
+ * fits, for every allocation in the sequence a repack replays.
+ *
+ * @param {number} current
+ * @param {number} required
+ * @param {number} minimum
+ * @returns {number}
+ */
+function grown_capacity(current, required, minimum) {
+    let capacity = Math.max(current, minimum);
+
+    while (capacity * 8 < required * 9) {
+        capacity *= 2;
+    }
+
+    return capacity;
+}

package/src/shade/renderer/particles/runtime/ProgramPlacement.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Where one program sits in the {@link ./ProgramHeap.js ProgramHeap}, and what an emitter record
+ * carries to find it.
+ *
+ * A placement is the heap's, not the caller's: {@link ./ProgramHeap.js#acquire} hands one out and
+ * {@link ./ProgramHeap.js#release} takes it back, and every field here is written by the heap. It is
+ * shared — every emitter running the same bytecode holds the same placement object, which is what
+ * puts them in one simulation bucket — and it is MUTATED IN PLACE when the heap repacks. Holders
+ * therefore see the new offsets without being handed a new object, and only have to restage the
+ * record they wrote the old ones into.
+ *
+ * The offsets are section-relative, which is what lets the heap move a program without the shader
+ * knowing: instruction offsets count instructions from the code section's base, and
+ * {@link ProgramPlacement#constant_offset} counts words from the constant section's base. The one
+ * absolute address in the whole buffer is the header word saying where the code section starts.
+ */
+export class ProgramPlacement {
+    /**
+     * Dense-ish id of this program: the value the emitter record carries and the simulation-order
+     * pass histograms on. Stable for the life of the placement, repacks included — the offsets move,
+     * the id does not.
+     *
+     * Ids are handed out lowest-free-first and a released one is reused, so they stay inside
+     * `[0, ProgramHeap#program_id_capacity)` however many programs come and go.
+     *
+     * @type {number}
+     */
+    program_id: number;
+    /**
+     * First instruction of the INIT section, counted in instructions from the code base.
+     * @type {number}
+     */
+    init_offset: number;
+    /**
+     * Instructions in the INIT section.
+     * @type {number}
+     */
+    init_count: number;
+    /**
+     * First instruction of the UPDATE section, counted in instructions from the code base. Directly
+     * after INIT — the two sections of a program are allocated as one contiguous range.
+     * @type {number}
+     */
+    update_offset: number;
+    /**
+     * Instructions in the UPDATE section.
+     * @type {number}
+     */
+    update_count: number;
+    /**
+     * First word of this program's constant pool, counted in words from the constant base. The VM
+     * adds it to every program-local constant reference.
+     * @type {number}
+     */
+    constant_offset: number;
+    /**
+     * The heap's own copy of the bytecode — the key it is filed under, and what a repack rewrites
+     * into the moved range.
+     *
+     * @type {import("../isa/ParticleProgram.js").ParticleProgram|null}
+     */
+    program: import("../isa/ParticleProgram.js").ParticleProgram | null;
+    /**
+     * How many emitters hold this placement. The heap frees the ranges and releases the id when it
+     * reaches zero, so one emitter of a shared effect going away does not take the effect with it.
+     *
+     * @type {number}
+     */
+    references: number;
+    /**
+     * The code range, in instructions, as {@link ../../../../core/binary/allocator/OffsetAllocator.js}
+     * handed it out. `null` for a program with no instructions at all.
+     *
+     * @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null}
+     */
+    code_allocation: import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation | null;
+    /**
+     * The constant-pool range, in words. `null` for a program with an empty pool.
+     * @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null}
+     */
+    constant_allocation: import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation | null;
+    /**
+     * @returns {number} instructions this program occupies in the code section, both sections summed
+     */
+    get instruction_count(): number;
+    /**
+     * @returns {number} words this program occupies in the constant section
+     */
+    get constant_word_count(): number;
+}
+//# sourceMappingURL=ProgramPlacement.d.ts.map

package/src/shade/renderer/particles/runtime/ProgramPlacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgramPlacement.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ProgramPlacement.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;;;;;;;;OASG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,SAFU,OAAO,2BAA2B,EAAE,eAAe,GAAC,IAAI,CAEnD;IAEf;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;OAKG;IACH,iBAFU,OAAO,sDAAsD,EAAE,UAAU,GAAC,IAAI,CAEjE;IAEvB;;;OAGG;IACH,qBAFU,OAAO,sDAAsD,EAAE,UAAU,GAAC,IAAI,CAE7D;IAE3B;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,kCAEC;CACJ"}