Vec2
Interface representing a 2D vector. A 2D vector is represented by (x, y) coordinates, and can
represent a point in a plane, a directional vector, or other types of data with three ordered
dimensions. Vec2 objects are created with the ecs.math.vec2
Vec2Factory, or through operations
on other Vec2 objects.
Code Example
const {vec2} = ecs.math
const a = vec2.xy(1, 2)
const b = vec2.scale(3) // b is 3, 3
const c = a.plus(b).times(vec2.xy(5, 4)).normalize() // c is (1, 1)
Source
The Vec2Source interface represents any object that has x and y properties and hence can be used
as a data source to create a Vec2. In addition, Vec2Source can be used as an argument to Vec2
algorithms, meaning that any object with {x: number, y: number}
properties can be used.
Vec2Source has the following enumerable properties:
readonly x: number
Access the x component of the vector.
readonly y: number
Access the y component of the vector.
Factory
Vec2 objects are created with the ecs.math.vec2
Vec2Factory, with the following methods:
vec2.from()
vec2.from({x, y}: {x: number, y: number}) => Vec2
Create a Vec2 from a Vec2, or other object with x, y properties.
vec2.one()
vec2.one: () => Vec2
Create a Vec2 with all elements set to one. This is equivalent to vec2.from({x: 1, y: 1})
.
vec2.scale()
vec2.scale: (s: number) => Vec2
Create a Vec2 with all elements set to the scale value s. This is equivalent to
vec2.from({x: s, y: s})
.
vec2.xy()
vec2.xy: (x: number, y: number) => Vec2
Create a Vec2 from x, y values. This is equivalent to vec2.from({x, y})
.
vec2.zero()
vec2.zero: () => Vec2
Create a Vec2 with all components set to zero. This is equivalent to vec2.from({x: 0, y: 0})
.
Properties
Vec2 has the following enumerable properties:
readonly x: number
Access the x component of the vector.
readonly y: number
Access the y component of the vector.
Immutable API
The following methods perform computations based on the current value of a Vec2, but do not modify its contents. Methods that return Vec2 types return new objects. Immutable APIs are typically safer, more readable, and less error-prone than mutable APIs, but may be inefficient in situations where thousands of objects are allocated each frame. In cases where object garbage collection is a performance concern, prefer the Mutable API (below).