@needle-tools/engine/lib/engine/engine_math.d.ts

Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in.

import type { Quaternion, Vector2, Vector3, Vector4 } from "three";
import type { Vec3 } from "./engine_types.js";
declare type Vector = Vector3 | Vector4 | Vector2 | Quaternion;
declare class MathHelper {
    random<T>(arr: Array<T>): T | null;
    random(min?: number, max?: number): number;
    randomVector3(target: Vector3, min?: number, max?: number): void;
    clamp(value: number, min: number, max: number): number;
    clamp01(value: number): number;
    /**
     * Linear interpolate
     */
    lerp(value1: number, value2: number, t: number): number;
    /**
     *
     */
    inverseLerp(value1: number, value2: number, t: number): number;
    /**
     * Remaps a value from one range to another.
     * @param value The value to remap.
     * @param min1 The minimum value of the current range.
     * @param max1 The maximum value of the current range.
     * @param min2 The minimum value of the target range.
     * @param max2 The maximum value of the target range.
     */
    remap(value: number, min1: number, max1: number, min2: number, max2: number): number;
    moveTowards(value1: number, value2: number, amount: number): number;
    readonly Rad2Deg: number;
    readonly Deg2Rad: number;
    readonly Epsilon = 0.00001;
    /**
     * Converts radians to degrees
     */
    toDegrees(radians: number): number;
    /**
     * Converts degrees to radians
     */
    toRadians(degrees: number): number;
    tan(radians: number): number;
    gammaToLinear(gamma: number): number;
    linearToGamma(linear: number): number;
    approximately(v1: Vector, v2: Vector, epsilon?: number): boolean;
    easeInOutCubic(x: number): number;
}
export declare const Mathf: MathHelper;
declare class LowPassFilter {
    y: number | null;
    s: number | null;
    alpha: number;
    constructor(alpha: number);
    setAlpha(alpha: number): void;
    filter(value: number, alpha: number): number;
    lastValue(): number | null;
    reset(value: number): void;
}
/**
 * OneEuroFilter is a simple low-pass filter for noisy signals. It uses a one-euro filter to smooth the signal.
 */
export declare class OneEuroFilter {
    /**
     * An estimate of the frequency in Hz of the signal (> 0), if timestamps are not available.
     */
    freq: number;
    /**
     * Min cutoff frequency in Hz (> 0). Lower values allow to remove more jitter.
     */
    minCutOff: number;
    /**
     * Parameter to reduce latency (> 0). Higher values make the filter react faster to changes.
     */
    beta: number;
    /**
     * Used to filter the derivates. 1 Hz by default. Change this parameter if you know what you are doing.
     */
    dCutOff: number;
    /**
     * The low-pass filter for the signal.
     */
    x: LowPassFilter;
    /**
     * The low-pass filter for the derivates.
     */
    dx: LowPassFilter;
    /**
     * The last time the filter was called.
     */
    lasttime: number | null;
    /** Create a new OneEuroFilter
     * @param freq - An estimate of the frequency in Hz of the signal (> 0), if timestamps are not available.
     * @param minCutOff - Min cutoff frequency in Hz (> 0). Lower values allow to remove more jitter.
     * @param beta - Parameter to reduce latency (> 0). Higher values make the filter react faster to changes.
     * @param dCutOff - Used to filter the derivates. 1 Hz by default. Change this parameter if you know what you are doing.
     */
    constructor(freq: number, minCutOff?: number, beta?: number, dCutOff?: number);
    alpha(cutOff: number): number;
    /** Filter your value: call with your value and the current timestamp (e.g. from this.context.time.time) */
    filter(x: number, time?: number | null): number;
    reset(x?: number): void;
}
export declare class OneEuroFilterXYZ {
    readonly x: OneEuroFilter;
    readonly y: OneEuroFilter;
    readonly z: OneEuroFilter;
    /** Create a new OneEuroFilter
     * @param freq - An estimate of the frequency in Hz of the signal (> 0), if timestamps are not available.
     * @param minCutOff - Min cutoff frequency in Hz (> 0). Lower values allow to remove more jitter.
     * @param beta - Parameter to reduce latency (> 0). Higher values make the filter react faster to changes.
     * @param dCutOff - Used to filter the derivates. 1 Hz by default. Change this parameter if you know what you are doing.
     */
    constructor(freq: number, minCutOff?: number, beta?: number, dCutOff?: number);
    filter(value: Vec3, target: Vec3, time?: number | null): void;
    reset(value?: Vec3): void;
}
export {};