handle40 methods, 2 fields, 6 operators

Vec2

A 2D vector (Y-up, center-origin). Construct with datumhue.math.vec2(x, y). #v is v:length(), not a component count.

Obtained from: datumhue.math.vec2, datumhue.time.tween (in its callback), datumhue.input.mouse_position, datumhue.input.app_mouse_position, datumhue.input.mouse_delta, datumhue.input.scroll_delta, datumhue.input.touches, datumhue.input.app_touch_position and 38 more
Accepted by: datumhue.time.tween, datumhue.audio.synth, datumhue.audio.sfx, datumhue.audio.play, datumhue.physics.point_query, datumhue.debug.input.gamepad_stick, Scene:sprite, SceneNode:deform and 53 more
Operators: Vec2 + Vec2 -> Vec2 Component-wise addition.
Vec2 - Vec2 -> Vec2 Component-wise subtraction.
Vec2 * Vec2 | number -> Vec2 Vector or scalar multiplication.
Vec2 / Vec2 | number -> Vec2 Vector or scalar division.
-Vec2 -> Vec2 Negation.
#Vec2 -> number Magnitude (the # operator).

Fields 2

Field	Type	Access	Description
`x`	number	read-only	X component.
`y`	number	read-only	Y component.

Methods 40

Vec2:length

method

Vec2:length() -> number

Magnitude.

Vec2:length_squared

method

Vec2:length_squared() -> number

Squared magnitude (no sqrt).

Vec2:to_angle

method

Vec2:to_angle() -> number

Angle in radians from the +X axis.

Example

-- Radians counterclockwise from +X, from -pi to pi.
local up = datumhue.math.vec2(0, 1)
local down = datumhue.math.vec2(0, -1)
print(string.format("%.4f", up:to_angle())) --> 1.5708
print(string.format("%.4f", down:to_angle())) --> -1.5708

Vec2:min_element

method

Vec2:min_element() -> number

Smallest component.

Vec2:max_element

method

Vec2:max_element() -> number

Largest component.

Vec2:normalize

method

Vec2:normalize() -> Vec2

Unit vector. Raises if v is zero-length / non-finite; use normalize_or or try_normalize for a fallback.

Vec2:normalize_or

method

Vec2:normalize_or(fallback: Vec2) -> Vec2

Unit vector, or fallback if v is zero-length / non-finite.

Vec2:try_normalize

method

Vec2:try_normalize() -> Vec2?

Unit vector, or nil if v is zero-length / non-finite.

Vec2:distance_squared

method

Vec2:distance_squared(o: Vec2) -> number

Squared Euclidean distance to o (no sqrt).

Vec2:signum

method

Vec2:signum() -> Vec2

Component-wise sign (-1, 0, or +1).

Vec2:fract

method

Vec2:fract() -> Vec2

Component-wise fractional part (self - self.trunc()).

Vec2:recip

method

Vec2:recip() -> Vec2

Component-wise reciprocal (1/x).

Vec2:element_sum

method

Vec2:element_sum() -> number

Sum of the components.

Vec2:element_product

method

Vec2:element_product() -> number

Product of the components.

Vec2:to_array

method

Vec2:to_array() -> number[]

Components as a {x, y} array.

Vec2:perp

method

Vec2:perp() -> Vec2

Perpendicular vector (90 deg CCW).

Example

-- A quarter turn counterclockwise.
print(datumhue.math.vec2(3, 4):perp()) --> vec2(-4.0, 3.0)

Vec2:abs

method

Vec2:abs() -> Vec2

Component-wise absolute value.

Vec2:floor

method

Vec2:floor() -> Vec2

Component-wise floor.

Vec2:ceil

method

Vec2:ceil() -> Vec2

Component-wise ceil.

Vec2:round

method

Vec2:round() -> Vec2

Component-wise round.

Vec2:dot

method

Vec2:dot(o: Vec2) -> number

Dot product.

Vec2:distance

method

Vec2:distance(o: Vec2) -> number

Euclidean distance to o.

Vec2:perp_dot

method

Vec2:perp_dot(o: Vec2) -> number

Perpendicular dot (2D cross).

Vec2:angle_to

method

Vec2:angle_to(o: Vec2) -> number

Signed angle to o in radians.

Example

-- Signed radians: positive turns counterclockwise.
local east = datumhue.math.vec2(1, 0)
local north = datumhue.math.vec2(0, 1)
print(string.format("%.4f", east:angle_to(north))) --> 1.5708
print(string.format("%.4f", north:angle_to(east))) --> -1.5708

Vec2:rotate

method

Vec2:rotate(o: Vec2) -> Vec2

Rotate v by the rotation o represents.

Example

-- A rotation is a unit vector at its angle: (0, 1) is a quarter
-- turn counterclockwise.
local v = datumhue.math.vec2(3, 4)
print(v:rotate(datumhue.math.vec2(0, 1))) --> vec2(-4.0, 3.0)
local turn = datumhue.math.vec2.from_angle(math.pi / 2)
print(v:rotate(turn):round()) --> vec2(-4.0, 3.0)

Vec2:midpoint

method

Vec2:midpoint(o: Vec2) -> Vec2

Midpoint between v and o.

Vec2:reflect

method

Vec2:reflect(o: Vec2) -> Vec2

Reflect v about the normal o.

Vec2:min

method

Vec2:min(o: Vec2) -> Vec2

Component-wise minimum.

Vec2:max

method

Vec2:max(o: Vec2) -> Vec2

Component-wise maximum.

Vec2:project_onto

method

Vec2:project_onto(o: Vec2) -> Vec2

Projection of v onto o. Errors if o is zero-length.

Vec2:reject_from

method

Vec2:reject_from(o: Vec2) -> Vec2

Rejection of v from o. Errors if o is zero-length.

Vec2:lerp

method

Vec2:lerp(o: Vec2, t: number) -> Vec2

Linear interpolation toward o by t; t outside 0..1 extrapolates past the endpoints (not clamped).

Example

local a = datumhue.math.vec2(0, 0)
local b = datumhue.math.vec2(10, 20)
print(a:lerp(b, 0.25)) --> vec2(2.5, 5.0)
-- t past 1 keeps going.
print(a:lerp(b, 1.5)) --> vec2(15.0, 30.0)

Vec2:move_towards

method

Vec2:move_towards(o: Vec2, d: number) -> Vec2

Move toward o by at most distance d.

Vec2:clamp

method

Vec2:clamp(lo: Vec2, hi: Vec2) -> Vec2

Component-wise clamp to [lo, hi].

In the guide: Draw and animate

Vec2:clamp_length

method

Vec2:clamp_length(lo: number, hi: number) -> Vec2

Clamp magnitude to [lo, hi].

Vec2:is_normalized

method

Vec2:is_normalized() -> boolean

Whether the vector is unit length.

Vec2:extend

method

Vec2:extend(z: number) -> Vec3

Extend to a Vec3 with the given z.

Vec2:with_x

method

Vec2:with_x(x: number) -> Vec2

Copy with x replaced.

In the guide: Draw and animate API conventions

Vec2:with_y

method

Vec2:with_y(y: number) -> Vec2

Copy with y replaced.

Vec2:unpack

method

Vec2:unpack() -> number, number

Return the x and y components as two values.

Example

local x, y = datumhue.math.vec2(3, 4):unpack()
print(x, y) --> 3.0 4.0

`/` or `Ctrl` `K`	Search
`↑` `↓` `Enter`	Pick a result
`Tab`	Next result filter
`j` `k`	Next or previous entry
`[` `]`	Previous or next page
`y`	Copy a link to the current entry
`?`	These shortcuts
`Esc`	Close