🥮 mooncakes.io

    wccerty/moonbit-artboard/src/math does not have a README file

    CubicBezier

    source
    pub struct CubicBezier {
      p0 : Vec2
      p1 : Vec2
      p2 : Vec2
      p3 : Vec2
    } derive(Eq, 
    Debug    )

    CubicBezier::approximate_length

    source
    fn CubicBezier::approximate_length(self : CubicBezier, samples : Int) -> Double

    CubicBezier::bounds

    source
    fn CubicBezier::bounds(self : CubicBezier) -> Rect2D

    CubicBezier::evaluate

    source
    fn CubicBezier::evaluate(self : CubicBezier, t : Double) -> Vec2

    CubicBezier::new

    source
    fn CubicBezier::new(p0 : Vec2, p1 : Vec2, p2 : Vec2, p3 : Vec2) -> CubicBezier

    CubicBezier::split

    source
    fn CubicBezier::split(self : CubicBezier, t : Double) -> (CubicBezier, CubicBezier)

    CubicBezier::tangent

    source
    fn CubicBezier::tangent(self : CubicBezier, t : Double) -> Vec2

    Matrix2D

    source
    pub struct Matrix2D {
      a : Double
      b : Double
      c : Double
      d : Double
      tx : Double
      ty : Double
    } derive(Eq, 
    Debug    )

    Matrix2D::approximately_equal

    source
    fn Matrix2D::approximately_equal(self : Matrix2D, target : Matrix2D, tolerance : Double) -> Bool

    Matrix2D::around

    source
    fn Matrix2D::around(self : Matrix2D, center : Vec2) -> Matrix2D

    Matrix2D::components

    source
    fn Matrix2D::components(self : Matrix2D) -> TransformComponents

    Matrix2D::decompose

    source
    fn Matrix2D::decompose(self : Matrix2D) -> MatrixDecomposition

    Matrix2D::determinant

    source
    fn Matrix2D::determinant(self : Matrix2D) -> Double

    Matrix2D::identity

    source
    fn Matrix2D::identity() -> Matrix2D

    Matrix2D::invert

    source
    fn Matrix2D::invert(self : Matrix2D) -> Matrix2D?

    Matrix2D::is_identity

    source
    fn Matrix2D::is_identity(self : Matrix2D, tolerance : Double) -> Bool

    Matrix2D::lerp

    source
    fn Matrix2D::lerp(self : Matrix2D, target : Matrix2D, amount : Double) -> Matrix2D

    Matrix2D::maximum_scale

    source
    fn Matrix2D::maximum_scale(self : Matrix2D) -> Double

    Matrix2D::minimum_scale

    source
    fn Matrix2D::minimum_scale(self : Matrix2D) -> Double

    Matrix2D::multiply

    source
    fn Matrix2D::multiply(self : Matrix2D, other : Matrix2D) -> Matrix2D

    Matrix2D::new

    source
    fn Matrix2D::new(a : Double, b : Double, c : Double, d : Double, tx : Double, ty : Double) -> Matrix2D

    Matrix2D::reflection_x

    source
    fn Matrix2D::reflection_x() -> Matrix2D

    Matrix2D::reflection_y

    source
    fn Matrix2D::reflection_y() -> Matrix2D

    Matrix2D::rotation

    source
    fn Matrix2D::rotation(angle_radians : Double) -> Matrix2D

    Matrix2D::rotation_at

    source
    fn Matrix2D::rotation_at(angle_radians : Double, center : Vec2) -> Matrix2D

    Matrix2D::scaling

    source
    fn Matrix2D::scaling(sx : Double, sy : Double) -> Matrix2D

    Matrix2D::scaling_at

    source
    fn Matrix2D::scaling_at(sx : Double, sy : Double, center : Vec2) -> Matrix2D

    Matrix2D::shearing

    source
    fn Matrix2D::shearing(kx : Double, ky : Double) -> Matrix2D

    Matrix2D::transform_bounds

    source
    fn Matrix2D::transform_bounds(self : Matrix2D, rect : Rect2D) -> Rect2D

    Matrix2D::transform_point

    source
    fn Matrix2D::transform_point(self : Matrix2D, p : Vec2) -> Vec2

    Matrix2D::transform_points

    source
    fn Matrix2D::transform_points(self : Matrix2D, points : Array[Vec2]) -> Array[Vec2]

    Matrix2D::transform_vector

    source
    fn Matrix2D::transform_vector(self : Matrix2D, v : Vec2) -> Vec2

    Matrix2D::translation

    source
    fn Matrix2D::translation(x : Double, y : Double) -> Matrix2D

    Matrix2D::uniform_scale

    source
    fn Matrix2D::uniform_scale(self : Matrix2D) -> Double

    Matrix2D::with_translation

    source
    fn Matrix2D::with_translation(self : Matrix2D, translation : Vec2) -> Matrix2D

    Matrix4x4

    source
    pub(all) struct Matrix4x4 {
      m00 : Double
      m01 : Double
      m02 : Double
      m03 : Double
      m10 : Double
      m11 : Double
      m12 : Double
      m13 : Double
      m20 : Double
      m21 : Double
      m22 : Double
      m23 : Double
      m30 : Double
      m31 : Double
      m32 : Double
      m33 : Double
    } derive(Eq, 
    Debug    )

    Matrix4x4::identity

    source
    fn Matrix4x4::identity() -> Matrix4x4

    Matrix4x4::multiply

    source
    fn Matrix4x4::multiply(self : Matrix4x4, other : Matrix4x4) -> Matrix4x4

    Matrix4x4::rotation_x

    source
    fn Matrix4x4::rotation_x(angle_rad : Double) -> Matrix4x4

    Matrix4x4::rotation_y

    source
    fn Matrix4x4::rotation_y(angle_rad : Double) -> Matrix4x4

    Matrix4x4::rotation_z

    source
    fn Matrix4x4::rotation_z(angle_rad : Double) -> Matrix4x4

    Matrix4x4::scaling

    source
    fn Matrix4x4::scaling(sx : Double, sy : Double, sz : Double) -> Matrix4x4

    Matrix4x4::translation

    source
    fn Matrix4x4::translation(x : Double, y : Double, z : Double) -> Matrix4x4

    MatrixDecomposition

    source
    pub struct MatrixDecomposition {
      translation : Vec2
      scale : Vec2
      rotation : Double
      skew : Vec2
    } derive(Eq, 
    Debug    )

    QuadraticBezier

    source
    pub struct QuadraticBezier {
      p0 : Vec2
      p1 : Vec2
      p2 : Vec2
    } derive(Eq, 
    Debug    )

    QuadraticBezier::evaluate

    source
    fn QuadraticBezier::evaluate(self : QuadraticBezier, t : Double) -> Vec2

    QuadraticBezier::new

    source
    fn QuadraticBezier::new(p0 : Vec2, p1 : Vec2, p2 : Vec2) -> QuadraticBezier

    QuadraticBezier::to_cubic

    source

    Rect2D

    source
    pub struct Rect2D {
      min_x : Double
      min_y : Double
      max_x : Double
      max_y : Double
    } derive(Eq, 
    Debug    )

    impl Show for Rect2D

    Rect2D::center

    source
    fn Rect2D::center(self : Rect2D) -> Vec2

    Rect2D::contains_point

    source
    fn Rect2D::contains_point(self : Rect2D, p : Vec2) -> Bool

    Rect2D::contains_rect

    source
    fn Rect2D::contains_rect(self : Rect2D, other : Rect2D) -> Bool

    Rect2D::corners

    source
    fn Rect2D::corners(self : Rect2D) -> Array[Vec2]

    Rect2D::empty

    source
    fn Rect2D::empty() -> Rect2D

    Rect2D::expand

    source
    fn Rect2D::expand(self : Rect2D, amount : Double) -> Rect2D

    Rect2D::from_point

    source
    fn Rect2D::from_point(p : Vec2) -> Rect2D

    Rect2D::from_points

    source
    fn Rect2D::from_points(points : Array[Vec2]) -> Rect2D

    Rect2D::height

    source
    fn Rect2D::height(self : Rect2D) -> Double

    Rect2D::intersection

    source
    fn Rect2D::intersection(self : Rect2D, other : Rect2D) -> Rect2D

    Rect2D::intersects

    source
    fn Rect2D::intersects(self : Rect2D, other : Rect2D) -> Bool

    Rect2D::is_empty

    source
    fn Rect2D::is_empty(self : Rect2D) -> Bool

    Rect2D::new

    source
    fn Rect2D::new(min_x : Double, min_y : Double, max_x : Double, max_y : Double) -> Rect2D

    Rect2D::union

    source
    fn Rect2D::union(self : Rect2D, other : Rect2D) -> Rect2D

    Rect2D::width

    source
    fn Rect2D::width(self : Rect2D) -> Double

    SegmentProjection

    source
    pub(all) struct SegmentProjection {
      point : Vec2
      parameter : Double
      distance_squared : Double
    } derive(Eq, 
    Debug    )

    TransformComponents

    source
    pub(all) struct TransformComponents {
      translation : Vec2
      scale : Vec2
      rotation : Double
      skew : Vec2
    } derive(Eq, 
    Debug    )

    TransformComponents::identity

    source

    TransformComponents::lerp

    source

    TransformComponents::new

    source
    fn TransformComponents::new(translation : Vec2, scale : Vec2, rotation : Double, skew : Vec2) -> TransformComponents

    TransformComponents::to_matrix

    source

    Triangle2D

    source
    pub(all) struct Triangle2D {
      p0 : Vec2
      p1 : Vec2
      p2 : Vec2
    } derive(Eq, 
    Debug    )

    Vec2

    source
    pub struct Vec2 {
      x : Double
      y : Double
    } derive(Eq, 
    Debug    )

    impl Show for Vec2

    Vec2::add

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

    Vec2::angle

    source
    fn Vec2::angle(self : Vec2) -> Double

    Vec2::angle_between

    source
    fn Vec2::angle_between(self : Vec2, other : Vec2) -> Double

    Vec2::cross

    source
    fn Vec2::cross(self : Vec2, other : Vec2) -> Double

    Vec2::distance

    source
    fn Vec2::distance(self : Vec2, other : Vec2) -> Double

    Vec2::distance_sq

    source
    fn Vec2::distance_sq(self : Vec2, other : Vec2) -> Double

    Vec2::dot

    source
    fn Vec2::dot(self : Vec2, other : Vec2) -> Double

    Vec2::length

    source
    fn Vec2::length(self : Vec2) -> Double

    Vec2::length_sq

    source
    fn Vec2::length_sq(self : Vec2) -> Double

    Vec2::lerp

    source
    fn Vec2::lerp(self : Vec2, target : Vec2, t : Double) -> Vec2

    Vec2::max

    source
    fn Vec2::max(self : Vec2, other : Vec2) -> Vec2

    Vec2::min

    source
    fn Vec2::min(self : Vec2, other : Vec2) -> Vec2

    Vec2::negate

    source
    fn Vec2::negate(self : Vec2) -> Vec2

    Vec2::new

    source
    fn Vec2::new(x : Double, y : Double) -> Vec2

    Vec2::normalize

    source
    fn Vec2::normalize(self : Vec2) -> Vec2

    Vec2::perpendicular

    source
    fn Vec2::perpendicular(self : Vec2) -> Vec2

    Vec2::reflect

    source
    fn Vec2::reflect(self : Vec2, normal : Vec2) -> Vec2

    Vec2::rotate

    source
    fn Vec2::rotate(self : Vec2, angle_radians : Double) -> Vec2

    Vec2::scale

    source
    fn Vec2::scale(self : Vec2, scalar : Double) -> Vec2

    Vec2::sub

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

    Vec2::unit_x

    source
    fn Vec2::unit_x() -> Vec2

    Vec2::unit_y

    source
    fn Vec2::unit_y() -> Vec2

    Vec2::zero

    source
    fn Vec2::zero() -> Vec2

    clamp_double

    source
    fn clamp_double(value : Double, minimum : Double, maximum : Double) -> Double

    distance_squared_to_segment

    source
    fn distance_squared_to_segment(point : Vec2, start : Vec2, end : Vec2) -> Double

    evaluate_b_spline

    source
    fn evaluate_b_spline(p0 : Vec2, p1 : Vec2, p2 : Vec2, p3 : Vec2, t : Double) -> Vec2

    evaluate_catmull_rom

    source
    fn evaluate_catmull_rom(p0 : Vec2, p1 : Vec2, p2 : Vec2, p3 : Vec2, t : Double) -> Vec2

    flatten_cubic

    source
    fn flatten_cubic(curve : CubicBezier, tolerance : Double, max_depth : Int) -> Array[Vec2]

    flatten_quadratic

    source
    fn flatten_quadratic(curve : QuadraticBezier, tolerance : Double, max_depth : Int) -> Array[Vec2]

    interpolate_catmull_rom_spline

    source
    fn interpolate_catmull_rom_spline(points : Array[Vec2], segments_per_span : Int) -> Array[Vec2]

    interpolate_transform

    source
    fn interpolate_transform(start : Matrix2D, target : Matrix2D, amount : Double) -> Matrix2D

    nearly_equal

    source
    fn nearly_equal(left : Double, right : Double, tolerance : Double) -> Bool

    project_point_to_segment

    source
    fn project_point_to_segment(point : Vec2, start : Vec2, end : Vec2) -> SegmentProjection

    signed_area

    source
    fn signed_area(points : Array[Vec2]) -> Double

    triangulate_polygon

    source
    fn triangulate_polygon(vertices : Array[Vec2]) -> Array[Triangle2D]

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io