/**
 * Imparts momentum into the fluid along the swept path of a moving source — the wake
 * left by an agent passing through air or water.
 *
 * Each call to {@link apply} treats the segment from {@link previous_position} to
 * {@link position} (both in WORLD coordinates) as a swept tube. The matrix
 * `world_to_grid` converts both endpoints into the target field's grid space, and the
 * effector splats `(position - previous_position) / dt * strength` into every fluid
 * cell within the kernel of that grid-space segment, weighted by a smooth
 * `(1 - d/R)²` falloff. After the splat the effector copies `position` into
 * `previous_position` so the next call automatically tracks the next segment.
 *
 * Works at any user-supplied {@link radius}, including sub-cell. The kernel is
 * internally floored at `1` grid cell — small user radii (bullets, arrows) still
 * produce a roughly 1-cell-wide tube instead of silently missing every cell. The
 * intent: users supply radii in world units without thinking about cell size; the
 * effector picks the smallest physically meaningful footprint when the converted
 * radius is below one cell.
 *
 * When the entity carrying a {@link FluidEffectorsComponent} also has a Transform,
 * {@link FluidSystem} calls {@link syncFromTransform} on this effector each step —
 * which pulls the latest world-space position off the transform. On the very first
 * sync `previous_position` is seeded equal to `position` to suppress the spurious
 * wake from `[0, 0, 0]`.
 *
 * For sources you position manually (no Transform on the entity, or no entity at
 * all), call {@link reset_trail} once after the initial placement and after any
 * teleport so the next apply doesn't splat a wake across the jump.
 */
export class WakeFluidEffector extends AbstractFluidEffector {
    /**
     * Current world-space position of the source. Updated each step from the entity
     * Transform (via {@link syncFromTransform}) when one is available, otherwise set
     * by user code before each step.
     * @type {[number, number, number]}
     */
    position: [number, number, number];
    /**
     * Position at the start of the swept segment, world space. {@link apply} copies
     * `position` into this at the end of every successful splat. Caller normally
     * doesn't touch it directly.
     * @type {[number, number, number]}
     */
    previous_position: [number, number, number];
    /**
     * Influence radius of the swept tube, in WORLD units. Converted to grid units via
     * the `world_to_grid` matrix's uniform scale, then internally floored to 1 grid
     * cell so sub-cell world-radii still hit cells (see class docstring).
     * @type {number}
     */
    radius: number;
    /**
     * Multiplier on the imparted velocity. `1` means an on-segment cell takes the
     * source's full grid-space velocity (before falloff weighting). `< 1` softens the
     * wake; `> 1` exaggerates it.
     * @type {number}
     */
    strength: number;
    /**
     * Snap {@link previous_position} to {@link position}. Call once after manual
     * initial placement, and after any teleport, so the next {@link apply} doesn't
     * splat a wake across the jump.
     */
    reset_trail(): void;
    #private;
}
import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
//# sourceMappingURL=WakeFluidEffector.d.ts.map