@woosh/meep-engine 3.68.0 → 3.69.0

package/src/shade/renderer/trails/runtime/TrailFadeCurves.js

@@ -0,0 +1,220 @@
+import { assert } from "../../../../core/assert.js";
+import { ALLOCATOR_NO_SPACE, OffsetAllocator } from "../../../../core/binary/allocator/OffsetAllocator.js";
+import { HashMap } from "../../../../core/collection/map/HashMap.js";
+import {
+    ANIMATION_CURVE_KEYFRAME_FLOATS,
+    animation_curve_write_keys
+} from "../../animation/animation_curve_write_keys.js";
+
+/**
+ * Keys the store starts with room for.
+ * @type {number}
+ */
+const INITIAL_KEY_CAPACITY = 256;
+
+/**
+ * A curve's place in the key buffer, shared by every trail that fades by an equal curve.
+ */
+export class TrailFadeCurve {
+    /** @type {number} first key in the buffer */
+    first = 0;
+
+    /** @type {number} keys */
+    count = 0;
+
+    /** @type {number} trails holding it */
+    references = 0;
+
+    /** @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null} */
+    allocation = null;
+
+    /** @type {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve|null} the store's own copy */
+    curve = null;
+}
+
+/**
+ * The trails' fade curves on the GPU, one run of keys per distinct curve, in the layout
+ * `chunk_animation_curve_evaluate_keys` reads (`ANIMATION_CURVE_KEYFRAME_STRUCT`).
+ *
+ * A curve is the trails' class data, not theirs alone: every trail on the shared default fade, or on one
+ * curve a game hands out, reads one run. Curves are found by content — a curve that equals one held is
+ * that one — and kept by reference count, so the last trail to let go frees the run. The key is a copy,
+ * because a curve the caller holds can be edited in place.
+ *
+ * Nothing on the GPU writes the buffer, so it grows by replacement and the whole of it goes up again.
+ */
+export class TrailFadeCurves {
+    /**
+     * @type {GPUDevice}
+     */
+    #device;
+
+    /**
+     * @type {OffsetAllocator}
+     */
+    #allocator = new OffsetAllocator(INITIAL_KEY_CAPACITY);
+
+    /**
+     * @type {Float32Array}
+     */
+    #keys = new Float32Array(INITIAL_KEY_CAPACITY * ANIMATION_CURVE_KEYFRAME_FLOATS);
+
+    /**
+     * @type {HashMap<import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve, TrailFadeCurve>}
+     */
+    #curves = new HashMap();
+
+    /**
+     * @type {GPUBuffer|null}
+     */
+    #buffer = null;
+
+    /**
+     * Whether the CPU keys have changed since they last went up.
+     * @type {boolean}
+     */
+    #dirty = true;
+
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device) {
+        assert.defined(device, 'device');
+
+        this.#device = device;
+    }
+
+    /**
+     * @returns {number} distinct curves held
+     */
+    get count() {
+        return this.#curves.size;
+    }
+
+    /**
+     * The key buffer as the GPU should see it, uploaded first if anything changed.
+     *
+     * @returns {GPUBuffer}
+     */
+    flush() {
+        const keys = this.#keys;
+
+        if (this.#buffer !== null && this.#buffer.size !== keys.byteLength) {
+            this.#buffer.destroy();
+            this.#buffer = null;
+        }
+
+        if (this.#buffer === null) {
+            this.#buffer = this.#device.createBuffer({
+                label: "Trails / fade keys",
+                size: keys.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+
+            this.#dirty = true;
+        }
+
+        if (this.#dirty) {
+            this.#device.queue.writeBuffer(this.#buffer, 0, keys.buffer, keys.byteOffset, keys.byteLength);
+            this.#dirty = false;
+        }
+
+        return this.#buffer;
+    }
+
+    /**
+     * Hold a curve equal to `curve`, placing its keys if none is held.
+     *
+     * @param {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} curve at least one key
+     * @returns {TrailFadeCurve}
+     */
+    acquire(curve) {
+        assert.greaterThan(curve.keys.length, 0, 'a fade curve needs a key');
+
+        let held = this.#curves.get(curve);
+
+        if (held === undefined) {
+            held = this.#place(curve);
+        }
+
+        held.references++;
+
+        return held;
+    }
+
+    /**
+     * @param {TrailFadeCurve} held from {@link acquire}
+     */
+    release(held) {
+        assert.greaterThan(held.references, 0, 'released more often than acquired');
+
+        held.references--;
+
+        if (held.references > 0) {
+            return;
+        }
+
+        this.#curves.delete(held.curve);
+        this.#allocator.free(held.allocation);
+
+        held.allocation = null;
+        held.curve = null;
+    }
+
+    destroy() {
+        this.#buffer?.destroy();
+        this.#buffer = null;
+        this.#dirty = true;
+    }
+
+    /**
+     * @param {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} curve
+     * @returns {TrailFadeCurve}
+     */
+    #place(curve) {
+        const count = curve.keys.length;
+
+        let allocation = this.#allocator.allocate(count);
+
+        if (allocation.offset === ALLOCATOR_NO_SPACE) {
+            this.#grow(count);
+
+            allocation = this.#allocator.allocate(count);
+
+            assert.notEqual(allocation.offset, ALLOCATOR_NO_SPACE, 'the fade key store grew and still has no room');
+        }
+
+        animation_curve_write_keys(this.#keys, allocation.offset * ANIMATION_CURVE_KEYFRAME_FLOATS, curve);
+
+        this.#dirty = true;
+
+        const held = new TrailFadeCurve();
+
+        held.first = allocation.offset;
+        held.count = count;
+        held.allocation = allocation;
+        held.curve = curve.clone();
+
+        this.#curves.set(held.curve, held);
+
+        return held;
+    }
+
+    /**
+     * @param {number} required keys of the curve that did not fit
+     */
+    #grow(required) {
+        const allocator = this.#allocator;
+
+        const size = Math.max(allocator.size * 2, allocator.grow_target_for(required));
+
+        allocator.grow(size);
+
+        const keys = new Float32Array(size * ANIMATION_CURVE_KEYFRAME_FLOATS);
+
+        keys.set(this.#keys);
+
+        this.#keys = keys;
+        this.#dirty = true;
+    }
+}

package/src/shade/renderer/trails/runtime/TrailKnotPool.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Every trail's knots, in one storage buffer: a run per trail, handed out by an {@link OffsetAllocator}
+ * in knots.
+ *
+ * The knots are the GPU's — seeded, committed and rewritten on the device — so the pool grows by copy:
+ * a larger buffer, the whole old one copied in at offset 0, and {@link OffsetAllocator#grow} appending
+ * the new tail as free space. No run moves, so every trail's `knot_base` stays what it was. Growth stops
+ * at the device's `maxBufferSize` and `maxStorageBufferBindingSize`; a run that cannot be housed past
+ * that is a failed {@link allocate}.
+ *
+ * Grows outside the frame: the copy is submitted on its own before the next frame records, and the old
+ * buffer is destroyed after that submission.
+ */
+export class TrailKnotPool {
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device: GPUDevice);
+    /**
+     * @returns {GPUBuffer}
+     */
+    get buffer(): GPUBuffer;
+    /**
+     * @returns {number} knots the pool has room for
+     */
+    get capacity(): number;
+    /**
+     * A run of `count` knots, growing the pool when it has no room.
+     *
+     * @param {number} count
+     * @returns {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation} its offset is in
+     * knots; a failed allocation's is `ALLOCATOR_NO_SPACE`
+     */
+    allocate(count: number): import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation;
+    /**
+     * @param {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation} allocation from {@link allocate}
+     */
+    free(allocation: import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation): void;
+    /**
+     * Write knots laid down on the CPU into the run starting at `knot_offset`.
+     *
+     * @param {number} knot_offset
+     * @param {Uint32Array} words whole knots, `TRAIL_KNOT_WORDS` apiece
+     */
+    write(knot_offset: number, words: Uint32Array): void;
+    destroy(): void;
+    #private;
+}
+//# sourceMappingURL=TrailKnotPool.d.ts.map

package/src/shade/renderer/trails/runtime/TrailKnotPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrailKnotPool.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/runtime/TrailKnotPool.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;GAYG;AACH;IAgBI;;OAEG;IACH,+BAUC;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,gBAJW,MAAM,GACJ,OAAO,sDAAsD,EAAE,UAAU,CAerF;IAED;;OAEG;IACH,iBAFW,OAAO,sDAAsD,EAAE,UAAU,QAInF;IAED;;;;;OAKG;IACH,mBAHW,MAAM,SACN,WAAW,QASrB;IAED,gBAEC;;CAgDJ"}

package/src/shade/renderer/trails/runtime/TrailKnotPool.js

@@ -0,0 +1,162 @@
+import { assert } from "../../../../core/assert.js";
+import { ALLOCATOR_NO_SPACE, OffsetAllocator } from "../../../../core/binary/allocator/OffsetAllocator.js";
+import { TRAIL_KNOT_BYTES } from "../data/TRAIL_KNOT.js";
+
+/**
+ * Knots the pool starts with room for.
+ * @type {number}
+ */
+const INITIAL_KNOT_CAPACITY = 4096;
+
+/**
+ * Every trail's knots, in one storage buffer: a run per trail, handed out by an {@link OffsetAllocator}
+ * in knots.
+ *
+ * The knots are the GPU's — seeded, committed and rewritten on the device — so the pool grows by copy:
+ * a larger buffer, the whole old one copied in at offset 0, and {@link OffsetAllocator#grow} appending
+ * the new tail as free space. No run moves, so every trail's `knot_base` stays what it was. Growth stops
+ * at the device's `maxBufferSize` and `maxStorageBufferBindingSize`; a run that cannot be housed past
+ * that is a failed {@link allocate}.
+ *
+ * Grows outside the frame: the copy is submitted on its own before the next frame records, and the old
+ * buffer is destroyed after that submission.
+ */
+export class TrailKnotPool {
+    /**
+     * @type {GPUDevice}
+     */
+    #device;
+
+    /**
+     * @type {OffsetAllocator}
+     */
+    #allocator;
+
+    /**
+     * @type {GPUBuffer}
+     */
+    #buffer;
+
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device) {
+        assert.defined(device, 'device');
+
+        this.#device = device;
+        this.#allocator = new OffsetAllocator(INITIAL_KNOT_CAPACITY);
+        this.#buffer = device.createBuffer({
+            label: "Trails / knots",
+            size: INITIAL_KNOT_CAPACITY * TRAIL_KNOT_BYTES,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+        });
+    }
+
+    /**
+     * @returns {GPUBuffer}
+     */
+    get buffer() {
+        return this.#buffer;
+    }
+
+    /**
+     * @returns {number} knots the pool has room for
+     */
+    get capacity() {
+        return this.#allocator.size;
+    }
+
+    /**
+     * A run of `count` knots, growing the pool when it has no room.
+     *
+     * @param {number} count
+     * @returns {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation} its offset is in
+     * knots; a failed allocation's is `ALLOCATOR_NO_SPACE`
+     */
+    allocate(count) {
+        assert.isPositiveInteger(count, 'count');
+
+        let allocation = this.#allocator.allocate(count);
+
+        if (allocation.offset === ALLOCATOR_NO_SPACE) {
+            this.#grow(count);
+
+            allocation = this.#allocator.allocate(count);
+        }
+
+        return allocation;
+    }
+
+    /**
+     * @param {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation} allocation from {@link allocate}
+     */
+    free(allocation) {
+        this.#allocator.free(allocation);
+    }
+
+    /**
+     * Write knots laid down on the CPU into the run starting at `knot_offset`.
+     *
+     * @param {number} knot_offset
+     * @param {Uint32Array} words whole knots, `TRAIL_KNOT_WORDS` apiece
+     */
+    write(knot_offset, words) {
+        assert.isNonNegativeInteger(knot_offset, 'knot_offset');
+
+        this.#device.queue.writeBuffer(
+            this.#buffer, knot_offset * TRAIL_KNOT_BYTES,
+            words.buffer, words.byteOffset, words.byteLength
+        );
+    }
+
+    destroy() {
+        this.#buffer.destroy();
+    }
+
+    /**
+     * @param {number} required knots of the run that did not fit
+     */
+    #grow(required) {
+        const device = this.#device;
+        const limits = device.limits;
+
+        const old_buffer = this.#buffer;
+        const old_size = old_buffer.size;
+
+        const ceiling_knots = Math.floor(
+            Math.min(limits.maxBufferSize, limits.maxStorageBufferBindingSize) / TRAIL_KNOT_BYTES
+        );
+
+        // the allocator's own answer for a run that size to land, doubled so a stream of short trails
+        // does not pay a copy of the whole pool apiece
+        const knots = Math.min(
+            Math.max(this.#allocator.size * 2, this.#allocator.grow_target_for(required)),
+            ceiling_knots
+        );
+
+        if (knots <= this.#allocator.size) {
+            // as large as this device allows
+            return;
+        }
+
+        const new_buffer = device.createBuffer({
+            label: old_buffer.label,
+            size: knots * TRAIL_KNOT_BYTES,
+            usage: old_buffer.usage,
+        });
+
+        // past the fallible part: OffsetAllocator#grow cannot be undone
+        this.#allocator.grow(knots);
+
+        const encoder = device.createCommandEncoder({ label: "Trails / knots / grow" });
+
+        // runs did not move, so the bytes land back under the bases the trails already hold
+        encoder.copyBufferToBuffer(old_buffer, 0, new_buffer, 0, old_size);
+
+        device.queue.submit([encoder.finish()]);
+
+        old_buffer.destroy();
+
+        this.#buffer = new_buffer;
+    }
+}

package/src/shade/renderer/trails/runtime/TrailParameters.d.ts

@@ -0,0 +1,52 @@
+/**
+ * What the GPU trail runtime is told about one trail: its look and its rules, as the CPU authors them.
+ * Plain data, compared field by field once a frame by whoever owns it, so a game can write a component
+ * field from code that has never heard of the renderer.
+ *
+ * `knot_count`, `radial` and `authored` are build-time: a change to any of them rebuilds the trail.
+ */
+export class TrailParameters {
+    /** @type {number} knots in the ring, at least 2 */
+    knot_count: number;
+    /** @type {number} radial segments around the tube, at least 3 */
+    radial: number;
+    /** @type {number} seconds a knot takes to fade out */
+    max_age: number;
+    /** @type {number} tube diameter */
+    width: number;
+    /** @type {boolean} knots are committed by distance travelled rather than by time */
+    distance_mode: boolean;
+    /** @type {number} distance between commits in distance mode */
+    spawn_distance: number;
+    /** @type {boolean} the head follows the entity */
+    spawning: boolean;
+    /** @type {boolean} the trail fades in over its first `max_age` seconds */
+    warmup: boolean;
+    /** @type {Float32Array} linear RGB, unbounded, and base opacity */
+    color: Float32Array;
+    /** @type {Float32Array} the head's place in the entity's local frame */
+    offset: Float32Array;
+    /** @type {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve|null} opacity over a knot's life */
+    fade: import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve | null;
+    /** @type {import("../../../../engine/graphics/trail/TrailKnots.js").TrailKnots|null} knots laid down by the author, or null for a trail the entity draws */
+    authored: import("../../../../engine/graphics/trail/TrailKnots.js").TrailKnots | null;
+    /** @type {number} the {@link authored} version these parameters were taken at */
+    authored_version: number;
+    /**
+     * @param {TrailParameters} other
+     */
+    copy(other: TrailParameters): void;
+    /**
+     * Whether `other` would build the same trail: same knot count, radial count and authored layout.
+     *
+     * @param {TrailParameters} other
+     * @returns {boolean}
+     */
+    same_build(other: TrailParameters): boolean;
+    /**
+     * @param {TrailParameters} other
+     * @returns {boolean}
+     */
+    equals(other: TrailParameters): boolean;
+}
+//# sourceMappingURL=TrailParameters.d.ts.map

package/src/shade/renderer/trails/runtime/TrailParameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrailParameters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/runtime/TrailParameters.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH;IACI,mDAAmD;IACnD,YADW,MAAM,CACF;IAEf,iEAAiE;IACjE,QADW,MAAM,CACN;IAEX,sDAAsD;IACtD,SADW,MAAM,CACL;IAEZ,mCAAmC;IACnC,OADW,MAAM,CACP;IAEV,oFAAoF;IACpF,eADW,OAAO,CACI;IAEtB,+DAA+D;IAC/D,gBADW,MAAM,CACE;IAEnB,kDAAkD;IAClD,UADW,OAAO,CACF;IAEhB,0EAA0E;IAC1E,QADW,OAAO,CACJ;IAEd,mEAAmE;IACnE,OADW,YAAY,CACgB;IAEvC,wEAAwE;IACxE,QADW,YAAY,CACM;IAE7B,4HAA4H;IAC5H,MADW,OAAO,sDAAsD,EAAE,cAAc,GAAC,IAAI,CACjF;IAEZ,4JAA4J;IAC5J,UADW,OAAO,iDAAiD,EAAE,UAAU,GAAC,IAAI,CACpE;IAEhB,iFAAiF;IACjF,kBADW,MAAM,CACK;IAEtB;;OAEG;IACH,YAFW,eAAe,QAwBzB;IAED;;;;;OAKG;IACH,kBAHW,eAAe,GACb,OAAO,CAOnB;IAED;;;OAGG;IACH,cAHW,eAAe,GACb,OAAO,CAoBnB;CACJ"}

package/src/shade/renderer/trails/runtime/TrailParameters.js

@@ -0,0 +1,126 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * @param {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve|null} a
+ * @param {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve|null} b
+ * @returns {boolean} whether the two give the same fade
+ */
+function same_curve(a, b) {
+    if (a === b) {
+        return true;
+    }
+
+    return a !== null && b !== null && a.equals(b);
+}
+
+/**
+ * What the GPU trail runtime is told about one trail: its look and its rules, as the CPU authors them.
+ * Plain data, compared field by field once a frame by whoever owns it, so a game can write a component
+ * field from code that has never heard of the renderer.
+ *
+ * `knot_count`, `radial` and `authored` are build-time: a change to any of them rebuilds the trail.
+ */
+export class TrailParameters {
+    /** @type {number} knots in the ring, at least 2 */
+    knot_count = 2;
+
+    /** @type {number} radial segments around the tube, at least 3 */
+    radial = 8;
+
+    /** @type {number} seconds a knot takes to fade out */
+    max_age = 5;
+
+    /** @type {number} tube diameter */
+    width = 1;
+
+    /** @type {boolean} knots are committed by distance travelled rather than by time */
+    distance_mode = false;
+
+    /** @type {number} distance between commits in distance mode */
+    spawn_distance = 1;
+
+    /** @type {boolean} the head follows the entity */
+    spawning = true;
+
+    /** @type {boolean} the trail fades in over its first `max_age` seconds */
+    warmup = true;
+
+    /** @type {Float32Array} linear RGB, unbounded, and base opacity */
+    color = new Float32Array([1, 1, 1, 1]);
+
+    /** @type {Float32Array} the head's place in the entity's local frame */
+    offset = new Float32Array(3);
+
+    /** @type {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve|null} opacity over a knot's life */
+    fade = null;
+
+    /** @type {import("../../../../engine/graphics/trail/TrailKnots.js").TrailKnots|null} knots laid down by the author, or null for a trail the entity draws */
+    authored = null;
+
+    /** @type {number} the {@link authored} version these parameters were taken at */
+    authored_version = -1;
+
+    /**
+     * @param {TrailParameters} other
+     */
+    copy(other) {
+        this.knot_count = other.knot_count;
+        this.radial = other.radial;
+        this.max_age = other.max_age;
+        this.width = other.width;
+        this.distance_mode = other.distance_mode;
+        this.spawn_distance = other.spawn_distance;
+        this.spawning = other.spawning;
+        this.warmup = other.warmup;
+        this.color.set(other.color);
+        this.offset.set(other.offset);
+
+        // a copy, not the curve: a curve can be edited in place, and a snapshot that shares it would
+        // never see the edit
+        if (other.fade === null) {
+            this.fade = null;
+        } else if (this.fade === null || !this.fade.equals(other.fade)) {
+            this.fade = other.fade.clone();
+        }
+
+        this.authored = other.authored;
+        this.authored_version = other.authored_version;
+    }
+
+    /**
+     * Whether `other` would build the same trail: same knot count, radial count and authored layout.
+     *
+     * @param {TrailParameters} other
+     * @returns {boolean}
+     */
+    same_build(other) {
+        return this.knot_count === other.knot_count
+            && this.radial === other.radial
+            && this.authored === other.authored
+            && this.authored_version === other.authored_version;
+    }
+
+    /**
+     * @param {TrailParameters} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        assert.defined(other, 'other');
+
+        return this.same_build(other)
+            && this.max_age === other.max_age
+            && this.width === other.width
+            && this.distance_mode === other.distance_mode
+            && this.spawn_distance === other.spawn_distance
+            && this.spawning === other.spawning
+            && this.warmup === other.warmup
+            && this.color[0] === other.color[0]
+            && this.color[1] === other.color[1]
+            && this.color[2] === other.color[2]
+            && this.color[3] === other.color[3]
+            && this.offset[0] === other.offset[0]
+            && this.offset[1] === other.offset[1]
+            && this.offset[2] === other.offset[2]
+            && same_curve(this.fade, other.fade);
+    }
+}

package/src/shade/renderer/trails/shaders/chunk_trail_frame_transport.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Below this squared length the transported normal is degenerate — the previous normal was nearly
+ * parallel to the new tangent — and a fresh basis is built from the tangent instead.
+ * @type {number}
+ */
+export const TRAIL_FRAME_DEGENERATE_EPSILON_SQR: number;
+/**
+ * `trail_frame_transport(tangent, previous_normal) -> TrailFrame`: the rotation-minimising frame of a
+ * tube's ring, carried from the previous knot's normal onto the plane perpendicular to the unit
+ * `tangent` (Gram-Schmidt), with `binormal = tangent × normal`. The ring keeps its orientation as the
+ * tangent turns, with no twist.
+ *
+ * When the previous normal is (nearly) parallel to the tangent the projection collapses, and the frame
+ * is built from the tangent alone, by the construction `v3_orthonormal_matrix_from_normal` uses on the
+ * CPU, so both paths bootstrap the same frame.
+ *
+ * The same arithmetic as `tube_frame_transport`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_frame_transport: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_trail_frame_transport.d.ts.map

package/src/shade/renderer/trails/shaders/chunk_trail_frame_transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_trail_frame_transport.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/shaders/chunk_trail_frame_transport.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iDAFU,MAAM,CAEwC;AAExD;;;;;;;;;;;;;GAaG;AACH,0CAFU,SAAS,CAmCjB;0BAxDwB,oCAAoC"}