🥮 mooncakes.io
README

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
}
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
}
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]
}
fn DMatrix::DMatrix(rows : Int, cols : Int, init : Float) -> DMatrix

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::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
}
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
}
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
}
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
}
fn MassProperties3::MassProperties3(mass : Float, inertia : SdpMat3, center_of_mass : Vec3) -> MassProperties3

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

#
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
}
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
}
fn Mat3::Mat3(m00 : Float, m01 : Float, m02 : Float, m10 : Float, m11 : Float, m12 : Float, m20 : Float, m21 : Float, m22 : Float) -> Mat3

3x3 matrix (row-major).

#
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
}
fn Quat::Quat(x : Float, y : Float, z : Float, w : Float) -> Quat

Unit quaternion used as 3D rotation.

#
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
}
fn SdpMat3::SdpMat3(m11 : Float, m12 : Float, m13 : Float, m22 : Float, m23 : Float, m33 : Float) -> SdpMat3

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::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
}
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
}
fn Vec3::Vec3(x : Float, y : Float, z : Float) -> Vec3

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

#
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