@thi.ng/boids/boid.d.ts

n-dimensional boids simulation with modular behavior system

import type { IDistance } from "@thi.ng/distance";
import type { ITimeStep, ReadonlyTimeStep } from "@thi.ng/timestep";
import { VectorState } from "@thi.ng/timestep/state";
import type { ReadonlyVec, Vec, VecAPI } from "@thi.ng/vectors";
import type { BoidOpts, IBoidAccel, IBoidBehavior } from "./api.js";
import { Radial } from "./region.js";
export declare class Boid implements ITimeStep {
    pos: VectorState;
    vel: VectorState;
    api: VecAPI;
    accel: IBoidAccel;
    behaviors: IBoidBehavior[];
    region: Radial<Boid>;
    opts: BoidOpts;
    /**
     * Pre-allocated vector for force accumulation, used by/for behavior
     * updates.
     */
    force: Vec;
    constructor(opts: BoidOpts, api: VecAPI, distance: IDistance<ReadonlyVec>, pos: Vec, vel: Vec);
    /**
     * Integration step of the thi.ng/timestep update cycle. See
     * [`ITimeStep`](https://docs.thi.ng/umbrella/timestep/interfaces/ITimeStep.html)
     *
     * @param dt
     * @param ctx
     */
    integrate(dt: number, ctx: ReadonlyTimeStep): void;
    /**
     * Interplation step of the thi.ng/timestep update cycle. See
     * [`ITimeStep`](https://docs.thi.ng/umbrella/timestep/interfaces/ITimeStep.html)
     *
     * @param alpha
     * @param ctx
     */
    interpolate(alpha: number, ctx: ReadonlyTimeStep): void;
    /**
     * Queries the spatial index for other boids in the current region, or if
     * `pos` is given also moves the search region to new position before
     * querying.
     *
     * @remarks
     * IMPORTANT: The returned array will always contain the current boid itself
     * too. Filtering has been left out here for performance reasons and is left
     * to downstream code.
     *
     * @param r
     * @param pos
     */
    neighbors(r: number, pos?: Vec): Boid[];
    steerTowards(target: ReadonlyVec, out?: Vec): Vec<number>;
    /**
     * Mutably divides given `force` by `num` (if > 0) and limits result via
     * {@link Boid.limitForce}.
     *
     * @param force
     * @param num
     */
    averageForce(force: Vec, num: number): Vec<number>;
    /**
     * If force > 0, computes: `limit(normalize(force, maxSpeed) - vel, maxForce)`.
     * Otherwise, returns input as is.
     *
     * @param force
     */
    limitForce(force: Vec): Vec<number>;
}
/**
 * Returns a new {@link Boid} instance configured to use optimized 2D vector
 * operations.
 *
 * @param accel
 * @param pos
 * @param vel
 * @param opts
 */
export declare const defBoid2: (pos: Vec, vel: Vec, opts: BoidOpts) => Boid;
/**
 * Returns a new {@link Boid} instance configured to use optimized 3D vector
 * operations.
 *
 * @param accel
 * @param pos
 * @param vel
 * @param opts
 */
export declare const defBoid3: (pos: Vec, vel: Vec, opts: BoidOpts) => Boid;
//# sourceMappingURL=boid.d.ts.map