@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/trails/graph_trails_avboit.d.ts

@@ -0,0 +1,126 @@
+/**
+ * @typedef {Object} TrailSegmentsHandles
+ * @property {number} occupancy graph handle of the occupancy bits, after the trails marked theirs
+ * @property {number} segment_list graph handle of the visible segments, a region per draw class
+ * @property {number} args graph handle of the indexed indirect draws, one per draw class
+ * @property {(number|undefined)[]} radials the radial count of each draw class, a hole where none is used
+ */
+/**
+ * The trails' AVBOIT occupancy and this view's draw lists: the segments pass, a thread per live segment
+ * dispatched from the frame's scan, then a pass that turns each draw class's count into its indexed
+ * indirect draw.
+ *
+ * Each draw class has a region of the segment list as long as the most segments its trails can show,
+ * the counters start at those regions, and the list is sized in powers of two so a count that climbs a
+ * little each frame does not make a new buffer each frame.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera graph handle of the camera uniform
+ * @param {ArrayLike<number>} params.cluster_parameters the frame's depth curve
+ * @param {number} params.occupancy graph handle of the occupancy bits, to add to
+ * @param {import("./graph_trails.js").TrailSimulationHandles} params.simulation this frame's simulation
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} params.runtime
+ * @returns {TrailSegmentsHandles}
+ */
+export function graph_trails_avboit_segments({ graph, camera, cluster_parameters, occupancy, simulation, runtime }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    cluster_parameters: ArrayLike<number>;
+    occupancy: number;
+    simulation: import("./graph_trails.js").TrailSimulationHandles;
+    runtime: import("./GPUTrailSystem.js").GPUTrailSystem;
+}): TrailSegmentsHandles;
+/**
+ * The trails' extinction into the AVBOIT volume, through the unlit splat.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera
+ * @param {number} params.warp
+ * @param {number[]} params.voxel_resolution
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume
+ * @param {import("./graph_trails.js").TrailSimulationHandles} params.simulation
+ * @param {TrailSegmentsHandles} params.segments
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} params.runtime
+ * @returns {{extinction: number, overflow: number, dummy: number}}
+ */
+export function graph_trails_avboit_splat({ graph, camera, warp, voxel_resolution, volume, simulation, segments, runtime }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    warp: number;
+    voxel_resolution: number[];
+    volume: {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    simulation: import("./graph_trails.js").TrailSimulationHandles;
+    segments: TrailSegmentsHandles;
+    runtime: import("./GPUTrailSystem.js").GPUTrailSystem;
+}): {
+    extinction: number;
+    overflow: number;
+    dummy: number;
+};
+/**
+ * The trails into the AVBOIT accumulators, through the unlit draw.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {import("../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.camera
+ * @param {number} params.depth_texture
+ * @param {number} params.warp
+ * @param {number} params.integral
+ * @param {number} params.volumetrics_lut
+ * @param {number} params.volumetrics_metadata
+ * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators
+ * @param {import("./graph_trails.js").TrailSimulationHandles} params.simulation
+ * @param {TrailSegmentsHandles} params.segments
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} params.runtime
+ * @returns {{color: number, norm: number, extinction: number, emission: number}}
+ */
+export function graph_trails_avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators, simulation, segments, runtime, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    view_ctx: import("../view/GPUViewContext.js").GPUViewContext;
+    camera: number;
+    depth_texture: number;
+    warp: number;
+    integral: number;
+    volumetrics_lut: number;
+    volumetrics_metadata: number;
+    accumulators: {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    simulation: import("./graph_trails.js").TrailSimulationHandles;
+    segments: TrailSegmentsHandles;
+    runtime: import("./GPUTrailSystem.js").GPUTrailSystem;
+}): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
+export type TrailSegmentsHandles = {
+    /**
+     * graph handle of the occupancy bits, after the trails marked theirs
+     */
+    occupancy: number;
+    /**
+     * graph handle of the visible segments, a region per draw class
+     */
+    segment_list: number;
+    /**
+     * graph handle of the indexed indirect draws, one per draw class
+     */
+    args: number;
+    /**
+     * the radial count of each draw class, a hole where none is used
+     */
+    radials: (number | undefined)[];
+};
+//# sourceMappingURL=graph_trails_avboit.d.ts.map

package/src/shade/renderer/trails/graph_trails_avboit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_trails_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/trails/graph_trails_avboit.js"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACqD,UAAU,EAArE,OAAO,mBAAmB,EAAE,sBAAsB;IACG,OAAO,EAA5D,OAAO,qBAAqB,EAAE,cAAc;IAC1C,oBAAoB,CA8GhC;AA2DD;;;;;;;;;;;;;GAaG;AACH;IAVkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACW,gBAAgB,EAAjC,MAAM,EAAE;IACsD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IACM,UAAU,EAArE,OAAO,mBAAmB,EAAE,sBAAsB;IACrB,QAAQ,EAArC,oBAAoB;IACiC,OAAO,EAA5D,OAAO,qBAAqB,EAAE,cAAc;IAC1C;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAejE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;IAdkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IACR,UAAU,EAArE,OAAO,mBAAmB,EAAE,sBAAsB;IACrB,QAAQ,EAArC,oBAAoB;IACiC,OAAO,EAA5D,OAAO,qBAAqB,EAAE,cAAc;IAC1C;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAgC/E;;;;;eA5Qa,MAAM;;;;kBACN,MAAM;;;;UACN,MAAM;;;;aACN,CAAC,MAAM,GAAC,SAAS,CAAC,EAAE"}

package/src/shade/renderer/trails/graph_trails_avboit.js

@@ -0,0 +1,300 @@
+import { assert } from "../../../core/assert.js";
+import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
+import { graph_avboit_unlit_draw, graph_avboit_unlit_splat } from "../rasterize/native/avboit/graph_avboit_unlit.js";
+import { graph_import_buffer } from "../shader/graph/graph_import_buffer.js";
+import { TRAIL_AVBOIT_BIND_GROUP_VERTEX, TRAIL_AVBOIT_DRAW_PIPELINE, TRAIL_AVBOIT_DRAW_RESOURCES, TRAIL_AVBOIT_SPLAT_PIPELINE, TRAIL_AVBOIT_SPLAT_RESOURCES } from "./shaders/shader_trail_avboit.js";
+import { shader_trail_avboit_segments } from "./shaders/shader_trail_avboit_segments.js";
+import { shader_trail_draw_args, TRAIL_DRAW_ARGS_WORDS, TRAIL_DRAW_ARGS_WORKGROUP_SIZE } from "./shaders/shader_trail_draw_args.js";
+import { TRAIL_VERTEX_GROUP } from "./shaders/chunk_trail_vertex.js";
+
+/**
+ * The fewest segment-list entries a frame's list is sized for.
+ * @type {number}
+ */
+const SEGMENT_LIST_MIN_ENTRIES = 64;
+
+/**
+ * @param {number} x
+ * @returns {number} the smallest power of two at or above `x`
+ */
+function power_of_two_at_least(x) {
+    let p = 1;
+
+    while (p < x) {
+        p *= 2;
+    }
+
+    return p;
+}
+
+/**
+ * @typedef {Object} TrailSegmentsHandles
+ * @property {number} occupancy graph handle of the occupancy bits, after the trails marked theirs
+ * @property {number} segment_list graph handle of the visible segments, a region per draw class
+ * @property {number} args graph handle of the indexed indirect draws, one per draw class
+ * @property {(number|undefined)[]} radials the radial count of each draw class, a hole where none is used
+ */
+
+/**
+ * The trails' AVBOIT occupancy and this view's draw lists: the segments pass, a thread per live segment
+ * dispatched from the frame's scan, then a pass that turns each draw class's count into its indexed
+ * indirect draw.
+ *
+ * Each draw class has a region of the segment list as long as the most segments its trails can show,
+ * the counters start at those regions, and the list is sized in powers of two so a count that climbs a
+ * little each frame does not make a new buffer each frame.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera graph handle of the camera uniform
+ * @param {ArrayLike<number>} params.cluster_parameters the frame's depth curve
+ * @param {number} params.occupancy graph handle of the occupancy bits, to add to
+ * @param {import("./graph_trails.js").TrailSimulationHandles} params.simulation this frame's simulation
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} params.runtime
+ * @returns {TrailSegmentsHandles}
+ */
+export function graph_trails_avboit_segments({ graph, camera, cluster_parameters, occupancy, simulation, runtime }) {
+    assert.isNonNegativeInteger(camera, "camera");
+    assert.isNonNegativeInteger(occupancy, "occupancy");
+
+    const classes = runtime.draw_classes;
+    const class_count = classes.length;
+
+    assert.greaterThan(class_count, 0, "a frame with no draw class has no trails to draw");
+
+    const regions = new Uint32Array(class_count);
+    const info = new Uint32Array(class_count * 2);
+    const radials = new Array(class_count);
+
+    let total = 0;
+
+    for (let c = 0; c < class_count; c++) {
+        const draw_class = classes[c];
+
+        regions[c] = total;
+
+        info[c * 2] = draw_class === undefined ? 0 : draw_class.radial;
+        info[c * 2 + 1] = total;
+
+        radials[c] = draw_class === undefined ? undefined : draw_class.radial;
+
+        if (draw_class !== undefined) {
+            total += draw_class.segments;
+        }
+    }
+
+    const list_bytes = power_of_two_at_least(Math.max(SEGMENT_LIST_MIN_ENTRIES, total)) * 4;
+    const counts_bytes = power_of_two_at_least(Math.max(4, class_count)) * 4;
+    const args_bytes = power_of_two_at_least(Math.max(4, class_count)) * TRAIL_DRAW_ARGS_WORDS * 4;
+
+    const now = runtime.now;
+
+    function execute_segments(data, resources, context) {
+        const encoder = context.encoder;
+
+        // each class's counter starts at its region, so a place the append hands back is where to write
+        encoder.writeBuffer(resources.get(data.class_counts), 0, regions.buffer, 0, regions.byteLength);
+
+        shader_trail_avboit_segments.dispatchIndirect({
+            encoder,
+            bindings: {
+                camera: resources.get(data.camera),
+                trail_database: resources.get(data.trail_database),
+                knots: resources.get(data.knots),
+                fade_keys: resources.get(data.fade_keys),
+                segment_sums: resources.get(data.segment_sums),
+                class_counts: resources.get(data.class_counts),
+                segment_list: resources.get(data.segment_list),
+                occupancy: resources.get(data.occupancy),
+                settings: { cluster_parameters, now },
+            },
+            command: resources.get(data.command),
+        });
+    }
+
+    const segments_data = {};
+    const segments = graph.add("Trail AVBOIT Segments", segments_data, execute_segments);
+
+    segments_data.camera = segments.read(camera);
+    segments_data.trail_database = segments.read(simulation.trail_database);
+    segments_data.knots = segments.read(simulation.knots);
+    segments_data.fade_keys = segments.read(simulation.fade_keys);
+    segments_data.segment_sums = segments.read(simulation.segment_sums);
+    segments_data.command = segments.read(simulation.segments_command);
+    segments_data.class_counts = segments.create("trails/class_counts", BufferResourceDescriptor.from(
+        counts_bytes, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    ));
+    segments_data.segment_list = segments.create("trails/segment_list", BufferResourceDescriptor.from(
+        list_bytes, GPUBufferUsage.STORAGE,
+    ));
+    segments.read(occupancy);
+    segments_data.occupancy = segments.write(occupancy);
+
+    function execute_args(data, resources, context) {
+        const encoder = context.encoder;
+
+        shader_trail_draw_args.dispatch({
+            encoder,
+            bindings: {
+                class_counts: resources.get(data.class_counts),
+                classes: encoder.allocateTransientBufferAndLoad(info.buffer, GPUBufferUsage.STORAGE, 0, info.byteLength),
+                args: resources.get(data.args),
+                settings: { class_count },
+            },
+            group_count_x: Math.ceil(class_count / TRAIL_DRAW_ARGS_WORKGROUP_SIZE),
+            group_count_y: 1,
+            group_count_z: 1,
+        });
+    }
+
+    const args_data = {};
+    const args = graph.add("Trail Draw Args", args_data, execute_args);
+
+    args_data.class_counts = args.read(segments_data.class_counts);
+    args_data.args = args.create("trails/draw_args", BufferResourceDescriptor.from(
+        args_bytes, GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+    ));
+
+    return {
+        occupancy: segments_data.occupancy,
+        segment_list: segments_data.segment_list,
+        args: args_data.args,
+        radials,
+    };
+}
+
+/**
+ * The draws of one trail pass: the vertex group, then an indexed indirect draw per draw class, from the
+ * class's static index buffer.
+ *
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} runtime
+ * @param {(number|undefined)[]} radials
+ * @param {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} pipeline
+ * @returns {function(GPURenderPassEncoder, Object, Object<string, *>): void}
+ */
+function trail_draws(runtime, radials, pipeline) {
+    return (pass_encoder, graphics, inputs) => {
+        const vertex_group = TRAIL_VERTEX_GROUP.generateBindings({
+            camera: inputs.camera,
+            trail_frame: inputs.trail_frame,
+            segment_list: inputs.segment_list,
+            knots: inputs.knots,
+            trail_database: inputs.trail_database,
+            fade_keys: inputs.fade_keys,
+        });
+
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, TRAIL_AVBOIT_BIND_GROUP_VERTEX, vertex_group);
+
+        for (let c = 0; c < radials.length; c++) {
+            const radial = radials[c];
+
+            if (radial === undefined) {
+                continue;
+            }
+
+            pass_encoder.setIndexBuffer(runtime.index_buffer(radial), "uint32");
+            pass_encoder.drawIndexedIndirect(inputs.args, c * TRAIL_DRAW_ARGS_WORDS * 4);
+        }
+    };
+}
+
+/**
+ * The graph handles the trails' vertex stage reads.
+ *
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} graph
+ * @param {number} camera
+ * @param {import("./graph_trails.js").TrailSimulationHandles} simulation
+ * @param {TrailSegmentsHandles} segments
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} runtime
+ * @returns {Object<string, number>}
+ */
+function vertex_inputs(graph, camera, simulation, segments, runtime) {
+    return {
+        camera,
+        trail_frame: graph_import_buffer(graph, runtime.frame_uniform, "trails/frame"),
+        segment_list: segments.segment_list,
+        knots: simulation.knots,
+        trail_database: simulation.trail_database,
+        fade_keys: simulation.fade_keys,
+        args: segments.args,
+    };
+}
+
+/**
+ * The trails' extinction into the AVBOIT volume, through the unlit splat.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera
+ * @param {number} params.warp
+ * @param {number[]} params.voxel_resolution
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume
+ * @param {import("./graph_trails.js").TrailSimulationHandles} params.simulation
+ * @param {TrailSegmentsHandles} params.segments
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} params.runtime
+ * @returns {{extinction: number, overflow: number, dummy: number}}
+ */
+export function graph_trails_avboit_splat({ graph, camera, warp, voxel_resolution, volume, simulation, segments, runtime }) {
+    return graph_avboit_unlit_splat({
+        graph,
+        label: "Trail AVBOIT Splat",
+        pipeline: TRAIL_AVBOIT_SPLAT_PIPELINE,
+        resources: TRAIL_AVBOIT_SPLAT_RESOURCES,
+        inputs: vertex_inputs(graph, camera, simulation, segments, runtime),
+        warp,
+        voxel_resolution,
+        volume,
+        is_empty: () => false,
+        record: trail_draws(runtime, segments.radials, TRAIL_AVBOIT_SPLAT_PIPELINE),
+    });
+}
+
+/**
+ * The trails into the AVBOIT accumulators, through the unlit draw.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {import("../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.camera
+ * @param {number} params.depth_texture
+ * @param {number} params.warp
+ * @param {number} params.integral
+ * @param {number} params.volumetrics_lut
+ * @param {number} params.volumetrics_metadata
+ * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators
+ * @param {import("./graph_trails.js").TrailSimulationHandles} params.simulation
+ * @param {TrailSegmentsHandles} params.segments
+ * @param {import("./GPUTrailSystem.js").GPUTrailSystem} params.runtime
+ * @returns {{color: number, norm: number, extinction: number, emission: number}}
+ */
+export function graph_trails_avboit_draw({
+                                             graph,
+                                             view_ctx,
+                                             camera,
+                                             depth_texture,
+                                             warp,
+                                             integral,
+                                             volumetrics_lut,
+                                             volumetrics_metadata,
+                                             accumulators,
+                                             simulation,
+                                             segments,
+                                             runtime,
+                                         }) {
+    return graph_avboit_unlit_draw({
+        graph,
+        label: "Trail AVBOIT Draw",
+        pipeline: TRAIL_AVBOIT_DRAW_PIPELINE,
+        resources: TRAIL_AVBOIT_DRAW_RESOURCES,
+        inputs: vertex_inputs(graph, camera, simulation, segments, runtime),
+        view_ctx,
+        depth_texture,
+        warp,
+        integral,
+        volumetrics_lut,
+        volumetrics_metadata,
+        accumulators,
+        is_empty: () => false,
+        record: trail_draws(runtime, segments.radials, TRAIL_AVBOIT_DRAW_PIPELINE),
+    });
+}

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

@@ -0,0 +1,56 @@
+/**
+ * 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: number;
+    /** @type {number} keys */
+    count: number;
+    /** @type {number} trails holding it */
+    references: number;
+    /** @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null} */
+    allocation: import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation | null;
+    /** @type {import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve|null} the store's own copy */
+    curve: import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve | 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 {
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device: GPUDevice);
+    /**
+     * @returns {number} distinct curves held
+     */
+    get count(): number;
+    /**
+     * The key buffer as the GPU should see it, uploaded first if anything changed.
+     *
+     * @returns {GPUBuffer}
+     */
+    flush(): GPUBuffer;
+    /**
+     * 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: import("../../../../engine/animation/curve/AnimationCurve.js").AnimationCurve): TrailFadeCurve;
+    /**
+     * @param {TrailFadeCurve} held from {@link acquire}
+     */
+    release(held: TrailFadeCurve): void;
+    destroy(): void;
+    #private;
+}
+//# sourceMappingURL=TrailFadeCurves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TrailFadeCurves.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/runtime/TrailFadeCurves.js"],"names":[],"mappings":"AAcA;;GAEG;AACH;IACI,6CAA6C;IAC7C,OADW,MAAM,CACP;IAEV,0BAA0B;IAC1B,OADW,MAAM,CACP;IAEV,uCAAuC;IACvC,YADW,MAAM,CACF;IAEf,6FAA6F;IAC7F,YADW,OAAO,sDAAsD,EAAE,UAAU,GAAC,IAAI,CACvE;IAElB,sHAAsH;IACtH,OADW,OAAO,sDAAsD,EAAE,cAAc,GAAC,IAAI,CAChF;CAChB;AAED;;;;;;;;;;GAUG;AACH;IAgCI;;OAEG;IACH,+BAIC;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,mBAwBC;IAED;;;;;OAKG;IACH,eAHW,OAAO,sDAAsD,EAAE,cAAc,GAC3E,cAAc,CAc1B;IAED;;OAEG;IACH,cAFW,cAAc,QAgBxB;IAED,gBAIC;;CAoDJ"}