src_Math.js

// @ts-check

/**
 * Subset of the JavaScript Math object and Unity Mathf static functions. Uses the Unity Mathf implementations.
 */
export class Mathf {
    /**
     * @param {number} value
     * @returns {number}
     */
    abs(value) { return Math.abs(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    acos(value) { return Math.acos(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    asin(value) { return Math.asin(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    atan(value) { return Math.atan(value); }

    /**
     * @param {number} y
     * @param {number} x
     * @returns {number}
     */
    atan2(y, x) { return Math.atan2(y, x); }

    /**
     * @param {number} value
     * @returns {number}
     */
    ceil(value) { return Math.ceil(value); }

    /**
     * Clamps the given value between the given minimum float and maximum float values. Returns the given value if it is within the minimum and maximum range.
     * @param {number} value
     * @param {number} min
     * @param {number} max
     * @returns {number}
     */
    clamp(value, min, max) { return 0; }

    /**
     * Clamps the given value between 0 and 1. Returns the given value if it is between 0 and 1.
     * @param {number} value
     * @returns {number}
     */
    clamp01(value) { return 0; }

    /**
     * @param {number} value
     * @returns {number}
     */
    cos(value) { return Math.cos(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    exp(value) { return Math.exp(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    floor(value) { return Math.floor(value); }

    /**
     * Calculates the linear parameter t that produces the interpolant value within the range [a, b], see https://docs.unity3d.com/2018.1/Documentation/ScriptReference/Mathf.InverseLerp.html
     * @param {number} value
     * @param {number} a
     * @param {number} b
     * @returns {number} t
     */
    inverseLerp(a, b, value) { return 0; }

    /**
     * Linearly interpolates between a and b by t.
     * @param {number} a
     * @param {number} b
     * @param {number} t
     * @returns {number}
     */
     lerp(a, b, t) { return 0; }

     /**
     * Same as Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees.
     * @param {number} a
     * @param {number} b
     * @param {number} t
     * @returns {number}
     */
     lerpAngle(a, b, t) { return 0; }

     /**
     * 	Linearly interpolates between a and b by t with no limit to t.
     * @param {number} a
     * @param {number} b
     * @param {number} t
     * @returns {number}
     */
     lerpUnclamped(a, b, t) { return 0; }

    /**
     * @param {number} value
     * @returns {number}
     */
    log(value) { return Math.log(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    log10(value) { return Math.log10(value); }

    /**
     * @param {...number[]} values
     * @returns {number}
     */
    max(values) { return 0; }

    /**
     * @param {...number[]} values
     * @returns {number}
     */
    min(values) { return 0; }

    /**
     * PingPongs the value t, so that it is never larger than length and never smaller than 0.
     * @param {number} t
     * @param {number} length
     * @returns {number}
     */
    pingPong(t, length) { return 0; }

    /**
     * @param {number} x
     * @param {number} y
     * @returns {number}
     */
    pow(x, y) { return Math.pow(x, y); }

    /**
     * Returns a random number between 0 and 1. Uses the Unity Random.value implementation.
     * @returns {number}
     */
    random() { return Math.random(); }

    /**
     * @param {number} value
     * @returns {number}
     */
    round(value) { return Math.round(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    sign(value) { return Math.sign(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    sin(value) { return Math.sin(value); }

    /**
     * Interpolates between min and max with smoothing at the limits.
     * @param {number} min
     * @param {number} max
     * @param {number} t
     * @returns {number}
     */
    smoothStep(min,max,t) { return 0; }

    /**
     * @param {number} value
     * @returns {number}
     */
    sqrt(value) { return Math.sqrt(value); }

    /**
     * @param {number} value
     * @returns {number}
     */
    tan(value) { return Math.tan(value); }
}