Variable Vec2Const

Type Declaration

• add: (a: Pair<number>, b: number | Pair<number>) => Pair<number>

• ceil: (a: Pair<number>) => Pair<number>

• div: (a: Pair<number>, b: number | Pair<number>) => Pair<number>

• floor: (a: Pair<number>) => Pair<number>

• map: <I, O>(op: (a: I) => O) => (a: Pair<I>) => Pair<O>

  Turn a unary function into a pair-wise unary function.

  Param: op

  A function that takes one arg and returns something.

  Returns

  A function that takes a pair such as [number, number] (Vector2) and transforms it with op.

• map2: <I, O>(op: (a: I, b: I) => O) => (a: Pair<I>, b: I | Pair<I>) => Pair<O>

  Turn a binary function into a pair-wise binary function, for example one that operates on two Vector2s.

  Param: op

  A function that takes two values and calculates one.

  Returns

  A function that runs op pair-wise on both arguments, constructing a new pair.

• max: (a: Pair<number>, b: number | Pair<number>) => Pair<number>

  Returns the maximum of two coordinates, i.e. the lower right corner of a bounding box containing them.

• min: (a: Pair<number>, b: number | Pair<number>) => Pair<number>

  Returns the minimum of two coordinates, i.e. the upper left corner of a bounding box containing them.

• mod: (a: Pair<number>, b: number | Pair<number>) => Pair<number>

  Apply a true modulus (i.e. where -1 % 3 == 2) to a Vector2.

  For JS-style modulus (who wants that?) use Vec2.map2((a,b) => a % b)

• mul: (a: Pair<number>, b: number | Pair<number>) => Pair<number>

• negate: (a: Pair<number>) => Pair<number>

• round: (a: Pair<number>) => Pair<number>

• sub: (a: Pair<number>, b: number | Pair<number>) => Pair<number>

• angle: function

  • angle(v: Vector2): number

    Parameters

    • v: Vector2

    Returns number

• clamp: function

  • clamp(v: Vector2, min: Vector2, max: Vector2): Vector2

    Parameters

    • v: Vector2
    • min: Vector2
    • max: Vector2

    Returns Vector2

• cross: function

  • cross(a: Vector2, b: Vector2): number

    Parameters

    • a: Vector2
    • b: Vector2

    Returns number

• distance: function

  • distance(a: Vector2, b: Vector2): number

    Parameters

    • a: Vector2
    • b: Vector2

    Returns number

• dot: function

  • dot(a: Vector2, b: Vector2): number

    Parameters

    • a: Vector2
    • b: Vector2

    Returns number

• eq: function

  • eq(v: Vector2, other: Vector2, epsilon: 0): boolean

    Apply deep (not referential) equality to a pair of Vec2s.

    Parameters

    • v: Vector2
    • other: Vector2
    • epsilon: 0

      Tolerance factor for inexact matches.

    Returns boolean

• fromAngle: function

  • fromAngle(angle: number, len?: number): Vector2

    Parameters

    • angle: number
    • len: number = 1

    Returns Vector2

• fromPolar: function

  • fromPolar(r: number, angle: number): Vector2

    Parameters

    • r: number
    • angle: number

    Returns Vector2

• length: function

  • length(v: Vector2): number

    Parameters

    • v: Vector2

    Returns number

• lengthSq: function

  • lengthSq(v: Vector2): number

    Parameters

    • v: Vector2

    Returns number

• lerp: function

  • lerp(a: Vector2, b: Vector2, t: number): Vector2

    Parameters

    • a: Vector2
    • b: Vector2
    • t: number

    Returns Vector2

• normalize: function

  • normalize(v: Vector2): Vector2

    Set the length of a Vector2 to 1.0 while preserving its angle.

    Parameters

    • v: Vector2

    Returns Vector2

• rotate: function

  • rotate(v: Vector2, angle: number): Vector2

    Parameters

    • v: Vector2
    • angle: number

    Returns Vector2

• toPolar: function

  • toPolar(v: Vector2): { angle: number; r: number }

    Parameters

    • v: Vector2

    Returns { angle: number; r: number }

• zero: function

  • zero(): Vector2

    Returns Vector2