Lily Math library for Graphics and Rendering.

fn Vec2::new(x: Float, y: Float) -> Vec2

Return a new 2D vector

fn Vec2::x(self) -> Float

Return the x component

fn Vec2::y(self) -> Float

Return the y component

fn Vec2::magnitude(self) -> Float

Return the magnitude (length) of the vector

fn Vec2::normalize(self) -> Vec2

Return a normalized (unit length) vector.

Behavior is undefined if the input has zero magnitude.

fn Vec2::add(self, other: Vec2) -> Vec2

Add two vectors

fn Vec2::sub(self, other: Vec2) -> Vec2

Subtract two vectors

fn Vec2::dot(self, other: Vec2) -> Float

Compute the dot product of two vectors

fn Vec2::lerp(
  self,
  other: Vec2,
  t: Float
) -> Vec2

Linear interpolation between two vectors.

t = 0.0 returns self. t = 1.0 returns other.

fn Vec2::distance(self, other: Vec2) -> Float

Distance between two points

fn Vec2::string(self) -> String

Convert vector to string for debugging

fn Vec3::new(
  x: Float,
  y: Float,
  z: Float
) -> Vec3

Return a new 3D vector

fn Vec3::x(self) -> Float

Return the x component

fn Vec3::y(self) -> Float

Return the y component

fn Vec3::z(self) -> Float

Return the z component

fn Vec3::magnitude(self) -> Float

Return the magnitude (length) of the vector

fn Vec3::normalize(self) -> Vec3

Return a normalized (unit magnitude) vector.

Behavior is undefined if the input has zero magnitude.

fn Vec3::add(self, other: Vec3) -> Vec3

Add two vectors

fn Vec3::sub(self, other: Vec3) -> Vec3

Subtract two vectors

fn Vec3::dot(self, other: Vec3) -> Float

Compute the dot product of two vectors

fn Vec3::lerp(
  self,
  other: Vec3,
  t: Float
) -> Vec3

Linear interpolation between two vectors.

t = 0.0 returns self. t = 1.0 returns other.

fn Vec3::distance(self, other: Vec3) -> Float

Distance between two points

fn Vec3::string(self) -> String

Convert vector to string for debugging

fn Mat3::identity() -> Mat3

Return an identity matrix

fn Mat3::mul(self, other: Mat3) -> Mat3

Multiply (compose) two matrices.

Multiplication order matters.

fn Mat3::string(self) -> String

Convert matrix to string for debugging

fn Vec4::new(
  x: Float,
  y: Float,
  z: Float,
  w: Float
) -> Vec4

Return a new 4D vector

fn Vec4::x(self) -> Float

Return the x component

fn Vec4::y(self) -> Float

Return the y component

fn Vec4::z(self) -> Float

Return the z component

fn Vec4::w(self) -> Float

Return the w component

fn Vec4::string(self) -> String

Convert vector to string for debugging

fn Quat::identity() -> Quat

Return an identity quaternion (no rotation)

fn Quat::from_rotation_z(radians: Float) -> Quat

Return a quaternion from rotation around Z axis

fn Quat::from_rotation_x(radians: Float) -> Quat

Return a quaternion from rotation around X axis

fn Quat::from_rotation_y(radians: Float) -> Quat

Return a quaternion from rotation around Y axis

fn Quat::x(self) -> Float

Return the x component

fn Quat::y(self) -> Float

Return the y component

fn Quat::z(self) -> Float

Return the z component

fn Quat::w(self) -> Float

Return the w component

fn Quat::normalize(self) -> Quat

Return a normalized (unit magnitude) quaternion

Behavior is undefined if the input has zero magnitude.

fn Quat::inverse(self) -> Quat

Return the inverse (opposite) rotation.

Behavior is undefined if the quaternion has zero magnitude.

fn Quat::mul(self, other: Quat) -> Quat

Multiply (compose) two quaternions.

Think of this as combining an existing rotation with an additional “delta” rotation.

Multiplication order matters and is not commutative.

fn Quat::slerp(
  self,
  other: Quat,
  t: Float
) -> Quat

Return the spherical linear interpolation between self and other.

t = 0.0 returns self. t = 1.0 returns other.

fn Quat::nlerp(
  self,
  other: Quat,
  t: Float
) -> Quat

Normalized linear interpolation (nlerp).

Typically faster than slerp, but does not result in constant angular velocity.

Use it for small angular differences or when interpolating frequently (e.g. per frame), as it is faster and looks similar to slerp.

t = 0.0 returns self. t = 1.0 returns other.

fn Quat::string(self) -> String

Convert quaternion to string for debugging

fn Mat4::identity() -> Mat4

Return an identity matrix (no transformation)

fn Mat4::ortho_2d_y_down_int(
  width: Int,
  height: Int,
  zoom: Float
) -> Mat4

Return an orthographic projection matrix for 2D (Y-down).

width and height are viewport dimensions in pixels. zoom must be positive. Read more about projections

fn Mat4::ortho_2d_int(
  width: Int,
  height: Int,
  zoom: Float
) -> Mat4

Return an orthographic projection matrix for 2D with normal RH (Y-going up).

width and height are viewport dimensions in pixels. zoom must be positive. Read more about projections

fn Mat4::ortho_2d_y_down_near_far_int(
  width: Int,
  height: Int,
  near: Int,
  far: Int
) -> Mat4

fn Mat4::ortho_2d_pixel_y_down_near_far_int(
  width: Int,
  height: Int,
  near: Int,
  far: Int
) -> Mat4

Uses pixel centers (-0.5)

fn Mat4::ortho_2d_pixel_near_far_int(
  width: Int,
  height: Int,
  near: Int,
  far: Int
) -> Mat4

Uses pixel centers (-0.5)

fn Mat4::from_translation(
  translation: Vec3
) -> Mat4

Return a translation matrix

fn Mat4::from_rotation_z(radians: Float) -> Mat4

Return a rotation matrix around Z axis (2D rotation)

fn Mat4::from_quat(rotation: Quat) -> Mat4

Return a rotation matrix from a quaternion

fn Mat4::from_scale(scale: Vec3) -> Mat4

Return a scale matrix

fn Mat4::from_rotation_translation(
  rotation: Quat,
  translation: Vec3
) -> Mat4

Return a transform from rotation and translation (no scale)

fn Mat4::from_scale_rotation_translation(
  scale: Vec3,
  rotation: Quat,
  translation: Vec3
) -> Mat4

Return a full transform from scale, rotation and translation

fn Mat4::mul(self, other: Mat4) -> Mat4

Multiply (compose) two matrices.

Multiplication order matters.

A * B and B * A (usually) produce different results. For example, rotate-then-translate is different from translate-then-rotate.

Build projection P once (for the viewport), build model M per object (for example, a translation), then multiply P * V * M.

This applies object/world transform first, then projection to clip space.

MVP convention:

• M (Model): object local space -> world space
• V (View): world space -> camera/view space
• P (Projection): maps view space -> clip space and encodes projection (aspect ratio and orthographic/perspective)

fn Mat4::translation(self) -> Vec3

Return the translation component (same as w_axis)

fn Mat4::x_axis(self) -> Vec3

Return the first column vector

fn Mat4::y_axis(self) -> Vec3

Return the second column vector

fn Mat4::z_axis(self) -> Vec3

Return the third column vector

fn Mat4::w_axis(self) -> Vec3

Return the fourth column vector (translation)

fn Mat4::to_scale_rotation_translation(
  self
) -> (Vec3, Quat, Vec3)

Decompose transform into scale, rotation and translation.

fn Mat4::to_mat4f(self) -> Mat4f

Convert to WebGPU type Mat4f (array of 16 F32)

fn Mat4::inverse(self) -> Mat4

Calculate the inverse matrix.

Behavior is undefined for non-invertible (singular) matrices. (e.g. when zero or close to zero scale on any axis)

fn Mat4::transpose(self) -> Mat4

Transpose the matrix (swap rows and columns)

fn Mat4::string(self) -> String

Convert matrix to string for debugging.

Do not rely on the string being formatted in a specific way.