@woosh/meep-engine/src/engine/network/sim/SmoothingState.d.ts

Pure JavaScript game engine. Fully featured and production ready.

export class SmoothingState {
    /**
     * Begin tracking an entity. Initial error is zero.
     * @param {number} entity_id
     */
    track(entity_id: number): void;
    /**
     * Stop tracking an entity. Releases the stored error state.
     * @param {number} entity_id
     */
    untrack(entity_id: number): void;
    /**
     * Returns true if `entity_id` has tracked smoothing state.
     * @param {number} entity_id
     * @returns {boolean}
     */
    is_tracked(entity_id: number): boolean;
    /**
     * Apply a correction. Called when the simulation position has been snapped
     * from `pre_render_pos` (the position the entity rendered at last frame,
     * i.e. `sim_old + error_old`) to `post_correction_pos` (the new
     * authoritative sim position). The error term absorbs the jump so the
     * rendered position (`sim + error`) stays continuous.
     *
     * Note this is an assignment, not an accumulation: the prior error is
     * already baked into `pre_render_pos`, so adding it again would
     * double-count and drift visibly across successive corrections.
     *
     * @param {number} entity_id
     * @param {Vector3|ArrayLike<number>} pre_render_pos position the entity was about to render at
     * @param {Vector3|ArrayLike<number>} post_correction_pos the new authoritative simulation position
     */
    apply_position_correction(entity_id: number, pre_render_pos: Vector3 | ArrayLike<number>, post_correction_pos: Vector3 | ArrayLike<number>): void;
    /**
     * Same as {@link apply_position_correction} but for orientation. Stores the
     * relative rotation `pre_render_rot * inverse(post_correction_rot)` as the
     * error quaternion so that the render path's `error * post == pre`
     * invariant holds.
     *
     * Like position, this is an assignment: `pre_render_rot` already
     * incorporates the prior error (it's the orientation the entity rendered
     * at last frame), so composing with `error_old` again would double-count
     * and drift across successive corrections.
     *
     * @param {number} entity_id
     * @param {Quaternion|ArrayLike<number>} pre_render_rot
     * @param {Quaternion|ArrayLike<number>} post_correction_rot
     */
    apply_orientation_correction(entity_id: number, pre_render_rot: Quaternion | ArrayLike<number>, post_correction_rot: Quaternion | ArrayLike<number>): void;
    /**
     * Decay both error terms toward zero. Position uses adaptive decay
     * (slow for small errors, fast for large); orientation uses a flat
     * decay matching the position decay at the current position-error magnitude.
     *
     * Should be called once per render frame for each tracked entity.
     *
     * @param {number} entity_id
     */
    decay(entity_id: number): void;
    /**
     * Get the render position by adding the error term to the simulation position.
     *
     * @param {number} entity_id
     * @param {Vector3|ArrayLike<number>} sim_pos input
     * @param {Vector3|ArrayLike<number>} out_pos output (mutated)
     */
    render_position(entity_id: number, sim_pos: Vector3 | ArrayLike<number>, out_pos: Vector3 | ArrayLike<number>): void;
    /**
     * Direct access to the per-entity error terms (or undefined if not tracked).
     *
     * @param {number} entity_id
     * @returns {{position_error: Vector3, orientation_error: Quaternion}|undefined}
     */
    state_for(entity_id: number): {
        position_error: Vector3;
        orientation_error: Quaternion;
    } | undefined;
    /**
     * Number of tracked entities.
     * @returns {number}
     */
    tracked_count(): number;
    #private;
}
import Vector3 from "../../../core/geom/Vector3.js";
import Quaternion from "../../../core/geom/Quaternion.js";
//# sourceMappingURL=SmoothingState.d.ts.map