🥮 mooncakes.io
    Sign in

    Milky2018/moon_rapier/core does not have a README file

    AngDim2

    source
    type AngDim2 = Int

    AngDim3

    source
    type AngDim3 = Int

    Dim2

    source
    type Dim2 = Int

    Dim3

    source
    type Dim3 = Int

    Real

    source
    type Real = Float

    SimdAngVector2

    source
    type SimdAngVector2 = Float

    SimdAngularInertia2

    source
    type SimdAngularInertia2 = Float

    TangentImpulse2

    source
    type TangentImpulse2 = Float

    Aabb

    source
    pub struct Aabb {
      mins : Vec2
      maxs : Vec2
    }

    Aabb::Aabb

    source
    fn Aabb::Aabb(mins : Vec2, maxs : Vec2) -> Aabb

    Aabb::combine

    source
    fn Aabb::combine(self : Aabb, other : Aabb) -> Aabb

    Aabb::contains_point

    source
    fn Aabb::contains_point(self : Aabb, point : Vec2) -> Bool

    Aabb::from_points

    source
    fn Aabb::from_points(a : Vec2, b : Vec2) -> Aabb

    Aabb::intersects

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

    Aabb3

    source
    pub struct Aabb3 {
      mins : Vec3
      maxs : Vec3
    }

    Aabb3::Aabb3

    source
    fn Aabb3::Aabb3(mins : Vec3, maxs : Vec3) -> Aabb3

    Aabb3::combine

    source
    fn Aabb3::combine(self : Aabb3, other : Aabb3) -> Aabb3

    Aabb3::dilated

    source
    fn Aabb3::dilated(self : Aabb3, amount : Float) -> Aabb3

    Aabb3::from_points

    source
    fn Aabb3::from_points(a : Vec3, b : Vec3) -> Aabb3

    Aabb3::intersects

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

    DMatrix

    source
    #alias(JacobianView2)
    #alias(JacobianViewMut3)
    #alias(JacobianViewMut2)
    #alias(JacobianView3)
    pub struct DMatrix {
      rows : Int
      cols : Int
      data : Array[Float]
    }

    A minimal dynamic matrix type used for Rapier public-surface parity.

    This is not a full nalgebra replacement; it is a small, deterministic, allocation-backed matrix for internal use and for parity mapping.

    DMatrix::DMatrix

    source
    fn DMatrix::DMatrix(rows : Int, cols : Int, init : Float) -> DMatrix

    DMatrix::cols

    source
    fn DMatrix::cols(self : DMatrix) -> Int

    DMatrix::get

    source
    fn DMatrix::get(self : DMatrix, r : Int, c : Int) -> Float?

    DMatrix::identity

    source
    fn DMatrix::identity(n : Int) -> DMatrix

    DMatrix::rows

    source
    fn DMatrix::rows(self : DMatrix) -> Int

    DMatrix::set

    source
    fn DMatrix::set(self : DMatrix, r : Int, c : Int, v : Float) -> DMatrix

    DMatrix::zeros

    source
    fn DMatrix::zeros(rows : Int, cols : Int) -> DMatrix

    Isometry2

    source
    #alias(SimdPose2)
    pub struct Isometry2 {
      translation : Vec2
      rotation : Rot2
    }

    Isometry2::Isometry2

    source
    fn Isometry2::Isometry2(translation : Vec2, rotation : Rot2) -> Isometry2

    Isometry2::from_translation

    source
    fn Isometry2::from_translation(translation : Vec2) -> Isometry2

    Isometry2::identity

    source
    fn Isometry2::identity() -> Isometry2

    Isometry2::inverse

    source
    fn Isometry2::inverse(self : Isometry2) -> Isometry2

    Isometry2::mul

    source
    fn Isometry2::mul(self : Isometry2, other : Isometry2) -> Isometry2

    Isometry2::transform_point

    source
    fn Isometry2::transform_point(self : Isometry2, point : Vec2) -> Vec2

    Isometry3

    source
    #alias(SimdPose3)
    pub struct Isometry3 {
      translation : Vec3
      rotation : Quat
    }

    Isometry3::Isometry3

    source
    fn Isometry3::Isometry3(translation : Vec3, rotation : Quat) -> Isometry3

    Isometry3::from_translation

    source
    fn Isometry3::from_translation(translation : Vec3) -> Isometry3

    Isometry3::identity

    source
    fn Isometry3::identity() -> Isometry3

    Isometry3::inverse

    source
    fn Isometry3::inverse(self : Isometry3) -> Isometry3

    Isometry3::mul

    source
    fn Isometry3::mul(self : Isometry3, other : Isometry3) -> Isometry3

    Isometry3::transform_point

    source
    fn Isometry3::transform_point(self : Isometry3, point : Vec3) -> Vec3

    MassProperties

    source
    pub struct MassProperties {
      mass : Float
      inv_mass : Float
      inertia : Float
      inv_inertia : Float
      center_of_mass : Vec2
    }

    MassProperties::MassProperties

    source
    fn MassProperties::MassProperties(mass : Float, inertia : Float, center_of_mass : Vec2) -> MassProperties

    MassProperties::add

    source

    MassProperties::default

    source

    MassProperties::set_mass

    source
    fn MassProperties::set_mass(self : MassProperties, new_mass : Float, update_inertia : Bool) -> MassProperties

    MassProperties::transform_by

    source
    fn MassProperties::transform_by(self : MassProperties, transform : Isometry2) -> MassProperties

    MassProperties3

    source
    pub struct MassProperties3 {
      mass : Float
      inv_mass : Float
      inertia : SdpMat3
      inv_inertia : SdpMat3
      center_of_mass : Vec3
    }

    3D mass properties: mass, center-of-mass, and angular inertia expressed about the COM.

    MassProperties3::MassProperties3

    source
    fn MassProperties3::MassProperties3(mass : Float, inertia : SdpMat3, center_of_mass : Vec3) -> MassProperties3

    MassProperties3::add

    source

    MassProperties3::default

    source

    MassProperties3::set_mass

    source
    fn MassProperties3::set_mass(self : MassProperties3, new_mass : Float, update_inertia : Bool) -> MassProperties3

    MassProperties3::transform_by

    source
    fn MassProperties3::transform_by(self : MassProperties3, transform : Isometry3) -> MassProperties3

    Mat2

    source
    #alias(SimdMatrix2)
    pub struct Mat2 {
      m00 : Float
      m01 : Float
      m10 : Float
      m11 : Float
    }

    Mat2::Mat2

    source
    fn Mat2::Mat2(m00 : Float, m01 : Float, m10 : Float, m11 : Float) -> Mat2

    Mat2::add

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

    Mat2::determinant

    source
    fn Mat2::determinant(self : Mat2) -> Float

    Mat2::identity

    source
    fn Mat2::identity() -> Mat2

    Mat2::inverse

    source
    fn Mat2::inverse(self : Mat2) -> Mat2

    Mat2::mul

    source
    fn Mat2::mul(self : Mat2, other : Mat2) -> Mat2

    Mat2::mul_vec2

    source
    fn Mat2::mul_vec2(self : Mat2, v : Vec2) -> Vec2

    Mat2::sub

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

    Mat2::transpose

    source
    fn Mat2::transpose(self : Mat2) -> Mat2

    Mat2::zero

    source
    fn Mat2::zero() -> Mat2

    Mat3

    source
    #alias(SimdMatrix3)
    pub struct Mat3 {
      m00 : Float
      m01 : Float
      m02 : Float
      m10 : Float
      m11 : Float
      m12 : Float
      m20 : Float
      m21 : Float
      m22 : Float
    }

    3x3 matrix (row-major).

    Mat3::Mat3

    source
    fn Mat3::Mat3(m00 : Float, m01 : Float, m02 : Float, m10 : Float, m11 : Float, m12 : Float, m20 : Float, m21 : Float, m22 : Float) -> Mat3

    Mat3::add

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

    Mat3::determinant

    source
    fn Mat3::determinant(self : Mat3) -> Float

    Mat3::from_diagonal

    source
    fn Mat3::from_diagonal(diag : Vec3) -> Mat3

    Mat3::identity

    source
    fn Mat3::identity() -> Mat3

    Mat3::inverse

    source
    fn Mat3::inverse(self : Mat3) -> Mat3

    Mat3::mul

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

    Mat3::mul_vec3

    source
    fn Mat3::mul_vec3(self : Mat3, v : Vec3) -> Vec3

    Mat3::scale

    source
    fn Mat3::scale(self : Mat3, s : Float) -> Mat3

    Mat3::sub

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

    Mat3::transpose

    source
    fn Mat3::transpose(self : Mat3) -> Mat3

    Mat3::zero

    source
    fn Mat3::zero() -> Mat3

    Quat

    source
    #alias(SimdRotation3)
    pub struct Quat {
      x : Float
      y : Float
      z : Float
      w : Float
    }

    Unit quaternion used as 3D rotation.

    Quat::Quat

    source
    fn Quat::Quat(x : Float, y : Float, z : Float, w : Float) -> Quat

    Quat::conjugate

    source
    fn Quat::conjugate(self : Quat) -> Quat

    Quat::dot

    source
    fn Quat::dot(self : Quat, other : Quat) -> Float

    Quat::identity

    source
    fn Quat::identity() -> Quat

    Quat::imag

    source
    fn Quat::imag(self : Quat) -> Vec3

    Quat::inverse

    source
    fn Quat::inverse(self : Quat) -> Quat

    Quat::mul

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

    Hamilton product (applies other then self when used as rotation composition).

    Quat::negated

    source
    fn Quat::negated(self : Quat) -> Quat

    Quat::norm_squared

    source
    fn Quat::norm_squared(self : Quat) -> Float

    Quat::normalize

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

    Quat::real

    source
    fn Quat::real(self : Quat) -> Float

    Quat::rotate_vec3

    source
    fn Quat::rotate_vec3(self : Quat, v : Vec3) -> Vec3

    Rotate a vector by this quaternion.

    Quat::to_mat3

    source
    fn Quat::to_mat3(self : Quat) -> Mat3

    Quat::to_scaled_axis

    source
    fn Quat::to_scaled_axis(self : Quat) -> Vec3

    Convert this quaternion to a scaled axis representation (axis * angle). This always returns the shortest representation (angle in [0, pi]).

    Rot2

    source
    #alias(SimdRotation2)
    pub struct Rot2 {
      sin : Float
      cos : Float
    }

    Rot2::angle

    source
    fn Rot2::angle(self : Rot2) -> Float

    Rot2::from_angle

    source
    fn Rot2::from_angle(angle : Float) -> Rot2

    Rot2::identity

    source
    fn Rot2::identity() -> Rot2

    Rot2::inverse

    source
    fn Rot2::inverse(self : Rot2) -> Rot2

    Rot2::mul

    source
    fn Rot2::mul(self : Rot2, other : Rot2) -> Rot2

    Rot2::rotate_vec2

    source
    fn Rot2::rotate_vec2(self : Rot2, v : Vec2) -> Vec2

    SdpMat3

    source
    #alias(SimdAngularInertia3)
    pub struct SdpMat3 {
      m11 : Float
      m12 : Float
      m13 : Float
      m22 : Float
      m23 : Float
      m33 : Float
    }

    Symmetric 3x3 matrix stored in a compact form (6 values).

    This matches the Rapier/Parry SdpMatrix3 storage pattern and is used for angular inertia tensors.

    SdpMat3::SdpMat3

    source
    fn SdpMat3::SdpMat3(m11 : Float, m12 : Float, m13 : Float, m22 : Float, m23 : Float, m33 : Float) -> SdpMat3

    SdpMat3::from_diagonal

    source
    fn SdpMat3::from_diagonal(diag : Vec3) -> SdpMat3

    SdpMat3::into_mat3

    source
    fn SdpMat3::into_mat3(self : SdpMat3) -> Mat3

    SdpMat3::inverse

    source
    fn SdpMat3::inverse(self : SdpMat3) -> SdpMat3

    SdpMat3::transform_vec3

    source
    fn SdpMat3::transform_vec3(self : SdpMat3, v : Vec3) -> Vec3

    SdpMat3::zero

    source
    fn SdpMat3::zero() -> SdpMat3

    UserData128

    source
    pub struct UserData128 {
      hi : UInt64
      lo : UInt64
    }

    A Rapier-compatible u128-equivalent payload used by RigidBody/Collider user data.

    Representation is (hi, lo) where the numeric value is (hi << 64) | lo.

    UserData128::equals

    source
    fn UserData128::equals(self : UserData128, other : UserData128) -> Bool

    UserData128::from_int_truncate

    source
    fn UserData128::from_int_truncate(value : Int) -> UserData128

    Back-compat helper: interpret the given Int as an unsigned payload truncated to 64 bits, stored in the low 64 bits of this UserData128.

    UserData128::from_parts

    source
    fn UserData128::from_parts(hi : UInt64, lo : UInt64) -> UserData128

    UserData128::from_u64

    source
    fn UserData128::from_u64(value : UInt64) -> UserData128

    UserData128::hi

    source
    fn UserData128::hi(self : UserData128) -> UInt64

    UserData128::lo

    source
    fn UserData128::lo(self : UserData128) -> UInt64

    UserData128::to_int_truncate

    source
    fn UserData128::to_int_truncate(self : UserData128) -> Int

    Back-compat helper: return the low 64 bits truncated to Int.

    UserData128::to_parts

    source
    fn UserData128::to_parts(self : UserData128) -> (UInt64, UInt64)

    UserData128::zero

    source
    fn UserData128::zero() -> UserData128

    Vec2

    source
    #alias(SimdVector2)
    #alias(SimdPoint2)
    #alias(TangentImpulse3)
    pub struct Vec2 {
      x : Float
      y : Float
    }

    Vec2::Vec2

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

    Vec2::add

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

    Vec2::cross

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

    Vec2::dot

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

    Vec2::length

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

    Vec2::length_squared

    source
    fn Vec2::length_squared(self : Vec2) -> Float

    Vec2::normalize

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

    Vec2::sub

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

    Vec2::zero

    source
    fn Vec2::zero() -> Vec2

    Vec3

    source
    #alias(SimdVector3)
    #alias(SimdPoint3)
    #alias(SimdAngVector3)
    pub struct Vec3 {
      x : Float
      y : Float
      z : Float
    }

    3D vector. This is the dim3 counterpart of Vec2.

    Vec3::Vec3

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

    Vec3::add

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

    Vec3::cross

    source
    fn Vec3::cross(self : Vec3, other : Vec3) -> Vec3

    Vec3::dot

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

    Vec3::length

    source
    fn Vec3::length(self : Vec3) -> Float

    Vec3::length_squared

    source
    fn Vec3::length_squared(self : Vec3) -> Float

    Vec3::normalize

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

    Vec3::scale

    source
    fn Vec3::scale(self : Vec3, s : Float) -> Vec3

    Vec3::sub

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

    Vec3::zero

    source
    fn Vec3::zero() -> Vec3

    ANG_DIM2

    source
    let ANG_DIM2 : Int

    ANG_DIM3

    source
    let ANG_DIM3 : Int

    MAX_MANIFOLD_POINTS2

    source
    let MAX_MANIFOLD_POINTS2 : Int

    MAX_MANIFOLD_POINTS3

    source
    let MAX_MANIFOLD_POINTS3 : Int

    RAPIER_REFERENCE_VERSION

    source
    let RAPIER_REFERENCE_VERSION : String

    SPATIAL_DIM2

    source
    let SPATIAL_DIM2 : Int

    SPATIAL_DIM3

    source
    let SPATIAL_DIM3 : Int

    VERSION

    source
    let VERSION : String

    abs

    source
    fn abs(value : Float) -> Float

    acos

    source
    fn acos(value : Float) -> Float

    asin

    source
    fn asin(value : Float) -> Float

    atan2

    source
    fn atan2(y : Float, x : Float) -> Float

    clamp

    source
    fn clamp(value : Float, min_value : Float, max_value : Float) -> Float

    cos

    source
    fn cos(value : Float) -> Float

    fn pi() -> Float

    rotation_between

    source
    fn rotation_between(from : Vec3, to : Vec3) -> Quat

    Construct a rotation that maps the direction from to the direction to.

    rotation_from_angle

    source
    fn rotation_from_angle(angle : Float) -> Rot2

    rotation_from_scaled_axis

    source
    fn rotation_from_scaled_axis(axis_angle : Vec3) -> Quat

    Construct a rotation from a scaled axis (axis * angle).

    sin

    source
    fn sin(value : Float) -> Float

    two_pi

    source
    fn two_pi() -> Float

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io