src/vector2.c file

Functions

auto vec2_zero(void) -> vector2: Returns a vector2 with both components set to 0.0f.
auto vec2_one(void) -> vector2: Returns a vector2 with both components set to 1.0f.
auto vec2_x_axis(vm_float_t x) -> vector2: Returns a vector2 along the x-axis (y = 0.0f).
auto vec2_y_axis(vm_float_t y) -> vector2: Returns a vector2 along the y-axis (x = 0.0f).
auto vec2_x_scale(vm_float_t x) -> vector2: Returns a vector2 representing x-axis scaling (y = 1.0f).
auto vec2_y_scale(vm_float_t y) -> vector2: Returns a vector2 representing y-axis scaling (x = 1.0f).
auto vec2_scale(vector2 v, vm_float_t s) -> vector2: Scales a vector by a scalar component-wise.
auto vec2_add(vector2 a, vector2 b) -> vector2: Adds two vectors component-wise.
auto vec2_sub(vector2 a, vector2 b) -> vector2: Subtracts the second vector from the first component-wise.
auto vec2_mul_scalar(vector2 v, vm_float_t s) -> vector2: Multiplies a vector by a scalar component-wise.
auto vec2_div_scalar(vector2 v, vm_float_t s) -> vector2: Divides a vector by a scalar component-wise.
auto vec2_mul(vector2 a, vector2 b) -> vector2: Multiplies two vectors component-wise (Hadamard product).
auto vec2_neg(vector2 v) -> vector2: Negates the vector (multiplies each component by -1.0f).
auto vec2_abs(vector2 v) -> vector2: Returns the absolute values of each component.
auto vec2_cross(vector2 a, vector2 b) -> vector2: Computes the 2D cross-product as a vector.
auto vec2_normalize(vector2 v) -> vector2: Normalizes the vector to unit length.
auto vec2_min(vector2 a, vector2 b) -> vector2: Returns the component-wise minimum of two vectors.
auto vec2_max(vector2 a, vector2 b) -> vector2: Returns the component-wise maximum of two vectors.
auto vec2_sign(vector2 v) -> vector2: Returns the sign of each component (+1.0f, -1.0f, or 0.0f).
auto vec2_floor(vector2 v) -> vector2: Applies floor to each component.
auto vec2_ceil(vector2 v) -> vector2: Applies ceil to each component.
auto vec2_round(vector2 v) -> vector2: Applies round to each component.
auto vec2_perpendicular(vector2 v) -> vector2: Returns the perpendicular vector (90 degrees counterclockwise).
auto vec2_reflect(vector2 v, vector2 normal) -> vector2: Reflects vector v across the normal, storing the result in res.
auto vec2_project(vector2 a, vector2 b) -> vector2: Projects the first vector onto the second.
auto vec2_tangent(vector2 v) -> vector2: Returns the tangent vector perpendicular to the input (90 degrees clockwise).
auto vec2_rotate(vector2 v, vm_float_t radians) -> vector2: Rotates the input vector counterclockwise by the given angle (radians).
auto vec2_rotate_deg(vector2 v, vm_float_t degrees) -> vector2: Rotates a vector2 by the given angle in degrees.
auto vec2_slide(vector2 v, vector2 normal) -> vector2: Slides the input vector tangent to the normal (removes normal component).
auto vec2_clamp(vector2 v, vector2 min, vector2 max) -> vector2: Clamps vector v component-wise between min and max.
auto vec2_dot(vector2 a, vector2 b) -> vm_float_t: Computes the dot product of two vectors.
auto vec2_length(vector2 v) -> vm_float_t: Computes the length (magnitude) of the vector.
auto vec2_aspect_ratio(vector2 v) -> vm_float_t: Computes the aspect ratio of the vector (x / y).
auto vec2_distance(vector2 a, vector2 b) -> vm_float_t: Computes the Euclidean distance between two vectors (treated as points).
auto vec2_angle(vector2 a, vector2 b) -> vm_float_t: Computes the angle between two vectors (in radians, range [0, PI]).
auto vec2_lerp(vector2 a, vector2 b, vm_float_t t) -> vector2: Linearly interpolates from a to b by t.
auto vec2_div(vector2 a, vector2 b) -> vector2: Divides two vectors component-wise.
auto vec2_add_scalar(vector2 v, vm_float_t s) -> vector2: Adds a scalar to each component.
auto vec2_sub_scalar(vector2 v, vm_float_t s) -> vector2: Subtracts a scalar from each component.
auto vec2_clamp_scalar(vector2 v, vm_float_t min, vm_float_t max) -> vector2: Clamps each component to the scalar range [min, max].
auto vec2_saturate(vector2 v) -> vector2: Clamps each component to the range [0, 1].
auto vec2_fract(vector2 v) -> vector2: Returns the fractional part of each component.
auto vec2_refract(vector2 incident, vector2 normal, vm_float_t eta) -> vector2: Computes the refraction of incident across normal with ratio eta.
auto vec2_reject(vector2 a, vector2 b) -> vector2: Returns the component of a orthogonal to b.
auto vec2_splat(vm_float_t s) -> vector2: Returns a vector with every component set to s.
auto vec2_from_angle(vm_float_t radians) -> vector2: Returns the unit vector at the given angle in radians.
auto vec2_from_angle_deg(vm_float_t degrees) -> vector2: Creates a vector2 from an angle given in degrees.
auto vec2_rotate_around(vector2 v, vector2 pivot, vm_float_t radians) -> vector2: Rotates v around pivot by angle radians.
auto vec2_rotate_around_deg(vector2 v, vector2 pivot, vm_float_t degrees) -> vector2: Rotates a vector2 around a pivot point by the given angle in degrees.
auto vec2_move_toward(vector2 current, vector2 target, vm_float_t max_delta) -> vector2: Moves current toward target by at most max_delta.
auto vec2_limit_length(vector2 v, vm_float_t max_len) -> vector2: Clamps the vector length to max_len.
auto vec2_to_vec3(vector2 v, vm_float_t z) -> vector3: Converts a vector2 to a vector3 using z.
auto vec2_length_squared(vector2 v) -> vm_float_t: Returns the squared Euclidean length.
auto vec2_length_manhattan(vector2 v) -> vm_float_t: Returns the Manhattan (L1) length.
auto vec2_length_chebyshev(vector2 v) -> vm_float_t: Returns the Chebyshev (L-inf) length.
auto vec2_distance_squared(vector2 a, vector2 b) -> vm_float_t: Returns the squared Euclidean distance between a and b.
auto vec2_cross_scalar(vector2 a, vector2 b) -> vm_float_t: Returns the 2D cross product as a scalar (a.x*b.y - a.y*b.x).
auto vec2_heading(vector2 v) -> vm_float_t: Returns the heading angle of the vector in radians.
auto vec2_heading_deg(vector2 v) -> vm_float_t: Returns the heading angle of the vector in degrees.
auto vec2_min_component(vector2 v) -> vm_float_t: Returns the smallest component.
auto vec2_max_component(vector2 v) -> vm_float_t: Returns the largest component.
auto vec2_sum(vector2 v) -> vm_float_t: Returns the sum of all components.
auto vec2_is_zero(vector2 v) -> bool: Returns true if every component is zero.
auto vec2_is_normalized(vector2 v) -> bool: Returns true if the vector has unit length.
auto vec2_near(vector2 a, vector2 b, vm_float_t eps) -> bool: Returns true if a and b are within eps of each other.

Function documentation

vector2 vec2_zero(void)

Returns a vector2 with both components set to 0.0f.

Returns	The zero vector2.

vector2 vec2_one(void)

Returns a vector2 with both components set to 1.0f.

Returns	The one vector2.

vector2 vec2_x_axis(vm_float_t x)

Returns a vector2 along the x-axis (y = 0.0f).

Parameters
x	The x component value.
Returns	The x-axis vector2.

vector2 vec2_y_axis(vm_float_t y)

Returns a vector2 along the y-axis (x = 0.0f).

Parameters
y	The y component value.
Returns	The y-axis vector2.

vector2 vec2_x_scale(vm_float_t x)

Returns a vector2 representing x-axis scaling (y = 1.0f).

Parameters
x	The x scale factor.
Returns	The x-scale vector2.

vector2 vec2_y_scale(vm_float_t y)

Returns a vector2 representing y-axis scaling (x = 1.0f).

Parameters
y	The y scale factor.
Returns	The y-scale vector2.

vector2 vec2_scale(vector2 v, vm_float_t s)

Scales a vector by a scalar component-wise.

Parameters
v	The input vector.
s	The scalar multiplier.
Returns	The scaled vector2.

vector2 vec2_add(vector2 a, vector2 b)

Adds two vectors component-wise.

Parameters
a	The first vector.
b	The second vector.
Returns	The sum vector2.

vector2 vec2_sub(vector2 a, vector2 b)

Subtracts the second vector from the first component-wise.

Parameters
a	The first vector.
b	The second vector.
Returns	The difference vector2.

vector2 vec2_mul_scalar(vector2 v, vm_float_t s)

Multiplies a vector by a scalar component-wise.

Parameters
v	The input vector.
s	The scalar multiplier.
Returns	The scaled vector2.

vector2 vec2_div_scalar(vector2 v, vm_float_t s)

Divides a vector by a scalar component-wise.

Parameters
v	The input vector.
s	The scalar divisor (non-zero).
Returns	The divided vector2.

vector2 vec2_mul(vector2 a, vector2 b)

Multiplies two vectors component-wise (Hadamard product).

Parameters
a	The first vector.
b	The second vector.
Returns	The product vector2.

vector2 vec2_neg(vector2 v)

Negates the vector (multiplies each component by -1.0f).

Parameters
v	The input vector.
Returns	The negated vector2.

vector2 vec2_abs(vector2 v)

Returns the absolute values of each component.

Parameters
v	The input vector.
Returns	The absolute value vector2.

vector2 vec2_cross(vector2 a, vector2 b)

Computes the 2D cross-product as a vector.

Parameters
a	The first vector.
b	The second vector.
Returns	The cross-product vector2.

vector2 vec2_normalize(vector2 v)

Normalizes the vector to unit length.

Parameters
v	The input vector.
Returns	The normalized vector2 (unchanged if zero length).

vector2 vec2_min(vector2 a, vector2 b)

Returns the component-wise minimum of two vectors.

Parameters
a	The first vector.
b	The second vector.
Returns	The minimum vector2.

vector2 vec2_max(vector2 a, vector2 b)

Returns the component-wise maximum of two vectors.

Parameters
a	The first vector.
b	The second vector.
Returns	The maximum vector2.

vector2 vec2_sign(vector2 v)

Returns the sign of each component (+1.0f, -1.0f, or 0.0f).

Parameters
v	The input vector.
Returns	The sign vector2.

vector2 vec2_floor(vector2 v)

Applies floor to each component.

Parameters
v	The input vector.
Returns	The floored vector2.

vector2 vec2_ceil(vector2 v)

Applies ceil to each component.

Parameters
v	The input vector.
Returns	The ceiled vector2.

vector2 vec2_round(vector2 v)

Applies round to each component.

Parameters
v	The input vector.
Returns	The rounded vector2.

vector2 vec2_perpendicular(vector2 v)

Returns the perpendicular vector (90 degrees counterclockwise).

Parameters
v	The input vector.
Returns	The perpendicular vector2.

vector2 vec2_reflect(vector2 v, vector2 normal)

Reflects vector v across the normal, storing the result in res.

Parameters
v	The incident vector.
normal	The unit normal vector.
Returns	The reflected vector2.

vector2 vec2_project(vector2 a, vector2 b)

Projects the first vector onto the second.

Parameters
a	The vector to project.
b	The projection direction vector.
Returns	The projected vector2.

vector2 vec2_tangent(vector2 v)

Returns the tangent vector perpendicular to the input (90 degrees clockwise).

Parameters
v	The input vector.
Returns	The tangent vector2.

vector2 vec2_rotate(vector2 v, vm_float_t radians)

Rotates the input vector counterclockwise by the given angle (radians).

Parameters
v	The input vector.
radians	The rotation angle in radians.
Returns	The rotated vector2.

vector2 vec2_rotate_deg(vector2 v, vm_float_t degrees)

Rotates a vector2 by the given angle in degrees.

Parameters
v	The vector2 to rotate.
degrees	The rotation angle in degrees.
Returns	The rotated vector2.

vector2 vec2_slide(vector2 v, vector2 normal)

Slides the input vector tangent to the normal (removes normal component).

Parameters
v	The input vector.
normal	The unit normal vector.
Returns	The slid vector2.

vector2 vec2_clamp(vector2 v, vector2 min, vector2 max)

Clamps vector v component-wise between min and max.

Parameters
v	The input vector.
min	The minimum bounds vector.
max	The maximum bounds vector.
Returns	The clamped vector2.

vm_float_t vec2_dot(vector2 a, vector2 b)

Computes the dot product of two vectors.

Parameters
a	The first vector.
b	The second vector.
Returns	The dot product scalar.

vm_float_t vec2_length(vector2 v)

Computes the length (magnitude) of the vector.

Parameters
v	The input vector.
Returns	The length scalar.

vm_float_t vec2_aspect_ratio(vector2 v)

Computes the aspect ratio of the vector (x / y).

Parameters
v	The input vector.
Returns	The aspect ratio scalar.

Returns 0.0f if y == 0.0f.

vm_float_t vec2_distance(vector2 a, vector2 b)

Computes the Euclidean distance between two vectors (treated as points).

Parameters
a	The first point.
b	The second point.
Returns	The distance scalar.

vm_float_t vec2_angle(vector2 a, vector2 b)

Computes the angle between two vectors (in radians, range [0, PI]).

Parameters
a	The first vector.
b	The second vector.
Returns	The angle scalar.

Returns 0.0f if either vector has zero length.

vector2 vec2_lerp(vector2 a, vector2 b, vm_float_t t)

Linearly interpolates from a to b by t.

Parameters
a	First input vector.
b	Second input vector.
t	Interpolation factor.
Returns	The resulting vector2.

vector2 vec2_div(vector2 a, vector2 b)

Divides two vectors component-wise.

Parameters
a	First input vector.
b	Second input vector.
Returns	The resulting vector2.

vector2 vec2_add_scalar(vector2 v, vm_float_t s)

Adds a scalar to each component.

Parameters
v	Input vector.
s	Scalar value.
Returns	The resulting vector2.

vector2 vec2_sub_scalar(vector2 v, vm_float_t s)

Subtracts a scalar from each component.

Parameters
v	Input vector.
s	Scalar value.
Returns	The resulting vector2.

vector2 vec2_clamp_scalar(vector2 v, vm_float_t min, vm_float_t max)

Clamps each component to the scalar range [min, max].

Parameters
v	Input vector.
min	Lower bound.
max	Upper bound.
Returns	The resulting vector2.

vector2 vec2_saturate(vector2 v)

Clamps each component to the range [0, 1].

Parameters
v	Input vector.
Returns	The resulting vector2.

vector2 vec2_fract(vector2 v)

Returns the fractional part of each component.

Parameters
v	Input vector.
Returns	The resulting vector2.

vector2 vec2_refract(vector2 incident, vector2 normal, vm_float_t eta)

Computes the refraction of incident across normal with ratio eta.

Parameters
incident	Incident vector.
normal	Surface normal.
eta	Ratio of indices of refraction.
Returns	The resulting vector2.

vector2 vec2_reject(vector2 a, vector2 b)

Returns the component of a orthogonal to b.

Parameters
a	First input vector.
b	Second input vector.
Returns	The resulting vector2.

vector2 vec2_splat(vm_float_t s)

Returns a vector with every component set to s.

Parameters
s	Scalar value.
Returns	The resulting vector2.

vector2 vec2_from_angle(vm_float_t radians)

Returns the unit vector at the given angle in radians.

Parameters
radians	Angle in radians.
Returns	The resulting vector2.

vector2 vec2_from_angle_deg(vm_float_t degrees)

Creates a vector2 from an angle given in degrees.

Parameters
degrees	The angle in degrees.
Returns	A unit vector2 representing the given angle.

The resulting vector has unit length and points in the direction specified by the angle. The angle is converted to radians internally before computing the cosine and sine.

vector2 vec2_rotate_around(vector2 v, vector2 pivot, vm_float_t radians)

Rotates v around pivot by angle radians.

Parameters
v	Input vector.
pivot	Rotation pivot.
radians	Angle in radians.
Returns	The resulting vector2.

vector2 vec2_rotate_around_deg(vector2 v, vector2 pivot, vm_float_t degrees)

Rotates a vector2 around a pivot point by the given angle in degrees.

Parameters
v	The vector2 to rotate.
pivot	The vector2 to rotate around.
degrees	The rotation angle in degrees.
Returns	The rotated vector2.

vector2 vec2_move_toward(vector2 current, vector2 target, vm_float_t max_delta)

Moves current toward target by at most max_delta.

Parameters
current	Current position.
target	Target position.
max_delta	Maximum distance to move.
Returns	The resulting vector2.

vector2 vec2_limit_length(vector2 v, vm_float_t max_len)

Clamps the vector length to max_len.

Parameters
v	Input vector.
max_len	Maximum length.
Returns	The resulting vector2.

vector3 vec2_to_vec3(vector2 v, vm_float_t z)

Converts a vector2 to a vector3 using z.

Parameters
v	Input vector.
z	Z component.
Returns	The resulting vector3.

vm_float_t vec2_length_squared(vector2 v)

Returns the squared Euclidean length.

Parameters
v	Input vector.
Returns	The resulting scalar.

vm_float_t vec2_length_manhattan(vector2 v)

Returns the Manhattan (L1) length.

Parameters
v	Input vector.
Returns	The resulting scalar.

vm_float_t vec2_length_chebyshev(vector2 v)

Returns the Chebyshev (L-inf) length.

Parameters
v	Input vector.
Returns	The resulting scalar.

vm_float_t vec2_distance_squared(vector2 a, vector2 b)

Returns the squared Euclidean distance between a and b.

Parameters
a	First input vector.
b	Second input vector.
Returns	The resulting scalar.

vm_float_t vec2_cross_scalar(vector2 a, vector2 b)

Returns the 2D cross product as a scalar (a.x*b.y - a.y*b.x).

Parameters
a	First input vector.
b	Second input vector.
Returns	The resulting scalar.

vm_float_t vec2_heading(vector2 v)

Returns the heading angle of the vector in radians.

Parameters
v	Input vector.
Returns	The resulting scalar.

vm_float_t vec2_heading_deg(vector2 v)

Returns the heading angle of the vector in degrees.

Parameters
v	The vector2 whose heading is to be calculated.
Returns	The heading angle of the vector in degrees.

Computes the angle between the positive x-axis and the vector using atan2, then converts the result from radians to degrees.

vm_float_t vec2_min_component(vector2 v)

Returns the smallest component.

Parameters
v	Input vector.
Returns	The resulting scalar.

vm_float_t vec2_max_component(vector2 v)

Returns the largest component.

Parameters
v	Input vector.
Returns	The resulting scalar.

vm_float_t vec2_sum(vector2 v)

Returns the sum of all components.

Parameters
v	Input vector.
Returns	The resulting scalar.

bool vec2_is_zero(vector2 v)

Returns true if every component is zero.

Parameters
v	Input vector.
Returns	True if every component is zero.

bool vec2_is_normalized(vector2 v)

Returns true if the vector has unit length.

Parameters
v	Input vector.
Returns	True if the vector has unit length.

bool vec2_near(vector2 a, vector2 b, vm_float_t eps)

Returns true if a and b are within eps of each other.

Parameters
a	First input vector.
b	Second input vector.
eps	Distance tolerance.
Returns	True if a and b are within eps.