Milky2018/moon_rapier/dynamics does not have a README file
AxesMask
AxisState3DReal
pub(all) enum AxisState3DReal {
Free
Locked
Limited(Float, Float)
}Builder helpers for the real dim3 joint constraints.
BodyPair
pub struct BodyPair {
body1 : RigidBodyHandle
body2 : RigidBodyHandle
}
fn BodyPair::BodyPair(body1 : RigidBodyHandle, body2 : RigidBodyHandle) -> BodyPairCCDSolver
CCDSolver::clamp_motions
fn CCDSolver::clamp_motions(self : CCDSolver, dt : Float, bodies : RigidBodySet, impacts : PredictedImpacts) -> UnitCCDSolver::clamp_motions3
fn CCDSolver::clamp_motions3(self : CCDSolver, dt : Float, bodies : RigidBodySet3, impacts : PredictedImpacts) -> UnitCCDSolver::find_first_impact
fn CCDSolver::find_first_impact(self : CCDSolver, impacts : PredictedImpacts) -> (RigidBodyHandle, Float)?Find the first time-of-impact among the predicted impacts.
This port currently does not compute CCD impacts, so this always returns None.
CCDSolver::predict_impacts_at_next_positions
fn CCDSolver::predict_impacts_at_next_positions(self : CCDSolver, _bodies : RigidBodySet, _dt : Float) -> PredictedImpactsPredicts potential impacts if all bodies moved to their next_position.
This port currently does not perform CCD shape-casts against colliders here, so it returns
NoImpacts. It is still exposed for pub parity.
CCDSolver::update_ccd_active_flags
fn CCDSolver::update_ccd_active_flags(self : CCDSolver, islands : IslandManager, bodies : RigidBodySet, dt : Float, include_forces : Bool) -> BoolCCDSolver::update_ccd_active_flags3
fn CCDSolver::update_ccd_active_flags3(self : CCDSolver, islands : IslandManager3, bodies : RigidBodySet3, dt : Float, include_forces : Bool) -> BoolCoefficientCombineRule
pub(all) enum CoefficientCombineRule {
Average
Min
Multiply
Max
ClampedSum
}CoefficientCombineRule::combine
fn CoefficientCombineRule::combine(coeff1 : Float, coeff2 : Float, rule_value1 : CoefficientCombineRule, rule_value2 : CoefficientCombineRule) -> FloatContactGraph
pub struct ContactGraph {
pairs : Array[(RigidBodyHandle, RigidBodyHandle)]
}
fn ContactGraph::ContactGraph() -> ContactGraphContactGraph::add_pair
fn ContactGraph::add_pair(self : ContactGraph, body1 : RigidBodyHandle, body2 : RigidBodyHandle) -> UnitDVector
type DVectorFixedJoint
pub struct FixedJoint {
local_anchor1 : Vec2
local_anchor2 : Vec2
}
fn FixedJoint::FixedJoint() -> FixedJointFixedJoint3DRealBuilder
pub struct FixedJoint3DRealBuilder {
inner : GenericJoint3DRealBuilder
}
fn FixedJoint3DRealBuilder::FixedJoint3DRealBuilder() -> FixedJoint3DRealBuilderFixedJoint3DRealBuilder::build
FixedJoint3DRealBuilder::local_anchor1
fn FixedJoint3DRealBuilder::local_anchor1(self : FixedJoint3DRealBuilder, a : Vec3) -> FixedJoint3DRealBuilderFixedJoint3DRealBuilder::local_anchor2
fn FixedJoint3DRealBuilder::local_anchor2(self : FixedJoint3DRealBuilder, a : Vec3) -> FixedJoint3DRealBuilderFixedJoint3DRealBuilder::local_basis1
fn FixedJoint3DRealBuilder::local_basis1(self : FixedJoint3DRealBuilder, q : Quat) -> FixedJoint3DRealBuilderFixedJoint3DRealBuilder::local_basis2
fn FixedJoint3DRealBuilder::local_basis2(self : FixedJoint3DRealBuilder, q : Quat) -> FixedJoint3DRealBuilderFixedJointBuilder
pub struct FixedJointBuilder {
// private fields
}
fn FixedJointBuilder::FixedJointBuilder() -> FixedJointBuilderFixedJointBuilder::local_anchor1
FixedJointBuilder::local_anchor2
FrictionModel
pub enum FrictionModel {
Simplified
Coulomb
}Friction models for contact constraints.
Rapier exposes this in 3D; we include it unconditionally for pub parity.
GenericJoint
pub struct GenericJoint {
local_frame1 : Isometry2
local_frame2 : Isometry2
axis3 : Vec3
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
local_frame1_rotation : Quat
local_frame2_rotation : Quat
locked_axes : JointAxesMask
limit_axes : JointAxesMask
motor_axes : JointAxesMask
coupled_axes : JointAxesMask
limits : JointLimits3
motors : JointMotors3
softness : SpringCoefficients
contacts_enabled : Bool
enabled : JointEnabled
user_data : Int
}
fn GenericJoint::GenericJoint(locked_axes : JointAxesMask) -> GenericJointGenericJoint::as_prismatic_mut
GenericJoint::as_revolute_mut
GenericJoint::as_spherical_mut
GenericJoint::flip
Flips the orientation of the joint, including limits and motors.
Ported from rapier-reference GenericJoint::flip.
GenericJoint::from_3d_real
GenericJoint::from_pin_slot
GenericJoint::from_prismatic
GenericJoint::from_revolute
GenericJoint::limits_axis
GenericJoint::local_frame1_rotation
GenericJoint::local_frame2_rotation
GenericJoint::lock_axes
GenericJoint::motor
GenericJoint::motor_model
GenericJoint::set_contacts_enabled
GenericJoint::set_coupled_axes
GenericJoint::set_enabled
GenericJoint::set_enabled_by_attached_body
fn GenericJoint::set_enabled_by_attached_body(self : GenericJoint, attached_enabled : Bool) -> GenericJointGenericJoint::set_limit_axes
GenericJoint::set_limits
GenericJoint::set_limits_axis
fn GenericJoint::set_limits_axis(self : GenericJoint, axis : JointAxis, min : Float, max : Float) -> GenericJointGenericJoint::set_local_anchor1
GenericJoint::set_local_anchor1_3
GenericJoint::set_local_anchor2
GenericJoint::set_local_anchor2_3
GenericJoint::set_local_frame1
GenericJoint::set_local_frame1_3
GenericJoint::set_local_frame1_rotation
GenericJoint::set_local_frame2
GenericJoint::set_local_frame2_3
GenericJoint::set_local_frame2_rotation
GenericJoint::set_locked_axes
GenericJoint::set_motor
fn GenericJoint::set_motor(self : GenericJoint, axis : JointAxis, target_pos : Float, target_vel : Float, stiffness : Float, damping : Float) -> GenericJointGenericJoint::set_motor_axes
GenericJoint::set_motor_max_force
fn GenericJoint::set_motor_max_force(self : GenericJoint, axis : JointAxis, max_force : Float) -> GenericJointGenericJoint::set_motor_model
fn GenericJoint::set_motor_model(self : GenericJoint, axis : JointAxis, model : MotorModel) -> GenericJointGenericJoint::set_motor_position
fn GenericJoint::set_motor_position(self : GenericJoint, axis : JointAxis, target_pos : Float, stiffness : Float, damping : Float) -> GenericJointGenericJoint::set_motor_velocity
fn GenericJoint::set_motor_velocity(self : GenericJoint, axis : JointAxis, target_vel : Float, factor : Float) -> GenericJointGenericJoint::set_motors
GenericJoint::set_softness
GenericJoint::to_3d_real
GenericJoint3DReal
pub struct GenericJoint3DReal {
local_frame1 : Isometry3
local_frame2 : Isometry3
axis_states : Array[AxisState3DReal]
motors : Array[MotorState3DReal]
coupled_axes : JointAxesMask3DReal
contacts_enabled : Bool
}Generic 3D joint configuration used by the real dim3 backend.
The constraint is defined in a joint frame attached to each body:
body.pos * local_frame1 and body.pos * local_frame2.
Axis limits/motors are expressed in the joint frame of body1.
GenericJoint3DReal::to_generic_joint
GenericJoint3DRealBuilder
pub struct GenericJoint3DRealBuilder {
locked_axes : JointAxesMask3DReal
contacts_enabled : Bool
coupled_axes : JointAxesMask3DReal
local_anchor1 : Vec3
local_anchor2 : Vec3
local_basis1 : Quat
local_basis2 : Quat
axis_states : Array[AxisState3DReal]
motors : Array[MotorState3DReal]
}
fn GenericJoint3DRealBuilder::GenericJoint3DRealBuilder(locked_axes : JointAxesMask3DReal) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::build
GenericJoint3DRealBuilder::contacts_enabled
fn GenericJoint3DRealBuilder::contacts_enabled(self : GenericJoint3DRealBuilder, enabled : Bool) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::coupled_axes
fn GenericJoint3DRealBuilder::coupled_axes(self : GenericJoint3DRealBuilder, coupled_axes : JointAxesMask3DReal) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::limits
fn GenericJoint3DRealBuilder::limits(self : GenericJoint3DRealBuilder, axis : JointAxis3DReal, min : Float, max : Float) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::local_anchor1
fn GenericJoint3DRealBuilder::local_anchor1(self : GenericJoint3DRealBuilder, local_anchor1 : Vec3) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::local_anchor2
fn GenericJoint3DRealBuilder::local_anchor2(self : GenericJoint3DRealBuilder, local_anchor2 : Vec3) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::local_axis1
fn GenericJoint3DRealBuilder::local_axis1(self : GenericJoint3DRealBuilder, axis : Vec3) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::local_axis2
fn GenericJoint3DRealBuilder::local_axis2(self : GenericJoint3DRealBuilder, axis : Vec3) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::local_basis1
fn GenericJoint3DRealBuilder::local_basis1(self : GenericJoint3DRealBuilder, local_basis1 : Quat) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::local_basis2
fn GenericJoint3DRealBuilder::local_basis2(self : GenericJoint3DRealBuilder, local_basis2 : Quat) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::motor_max_force
fn GenericJoint3DRealBuilder::motor_max_force(self : GenericJoint3DRealBuilder, axis : JointAxis3DReal, max_force : Float) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::motor_position
fn GenericJoint3DRealBuilder::motor_position(self : GenericJoint3DRealBuilder, axis : JointAxis3DReal, target_pos : Float, stiffness : Float, damping : Float) -> GenericJoint3DRealBuilderGenericJoint3DRealBuilder::motor_velocity
fn GenericJoint3DRealBuilder::motor_velocity(self : GenericJoint3DRealBuilder, axis : JointAxis3DReal, target_vel : Float, damping : Float) -> GenericJoint3DRealBuilderGenericJointConstraint
pub struct GenericJointConstraint {
is_rigid_body1 : Bool
is_rigid_body2 : Bool
solver_vel1 : Int
solver_vel2 : Int
ndofs1 : Int
j_id1 : Int
ndofs2 : Int
j_id2 : Int
joint_id : Int
impulse : Float
impulse_bounds : (Float, Float)
inv_lhs : Float
rhs : Float
rhs_wo_bias : Float
cfm_coeff : Float
cfm_gain : Float
writeback_id : WritebackId
}A single scalar constraint used by Rapier's generic joint constraint machinery.
This is exposed for pub parity and as a stable data container. The actual solver
implementation in this repository may not use this type directly.
GenericJointConstraint3DReal
pub struct GenericJointConstraint3DReal {
body1 : RigidBodyHandle
body2 : RigidBodyHandle
data : GenericJoint3DReal
}Internal storage type for generic constraints in JointSet3DReal.
Group
ImpulseJoint
pub struct ImpulseJoint {
body1 : RigidBodyHandle
body2 : RigidBodyHandle
data : GenericJoint
impulses : Vec2
ang_impulse : Float
handle : ImpulseJointHandle
}ImpulseJoint::set_enabled
ImpulseJoint::set_enabled_by_attached_body
fn ImpulseJoint::set_enabled_by_attached_body(self : ImpulseJoint, attached_enabled : Bool) -> ImpulseJointImpulseJointGraph
pub struct ImpulseJointGraph {
nodes : Array[RigidBodyHandle]
edges : Array[(RigidBodyHandle, RigidBodyHandle, ImpulseJoint)]
}ImpulseJointGraph::edges
fn ImpulseJointGraph::edges(self : ImpulseJointGraph) -> Array[(RigidBodyHandle, RigidBodyHandle, ImpulseJoint)]ImpulseJointGraph::nodes
ImpulseJointHandle
pub struct ImpulseJointHandle {
id : Int
generation : Int
}ImpulseJointHandle::from_raw_parts
ImpulseJointHandle::into_raw_parts
ImpulseJointSet
pub struct ImpulseJointSet {
// private fields
}
fn ImpulseJointSet::ImpulseJointSet() -> ImpulseJointSetImpulseJointSet::attached_enabled_joints
fn ImpulseJointSet::attached_enabled_joints(self : ImpulseJointSet, handle : RigidBodyHandle) -> Array[(RigidBodyHandle, RigidBodyHandle, ImpulseJointHandle, ImpulseJoint)]ImpulseJointSet::attached_joints
fn ImpulseJointSet::attached_joints(self : ImpulseJointSet, handle : RigidBodyHandle) -> Array[(RigidBodyHandle, RigidBodyHandle, ImpulseJointHandle, ImpulseJoint)]ImpulseJointSet::contains
ImpulseJointSet::get
ImpulseJointSet::get_mut
fn ImpulseJointSet::get_mut(self : ImpulseJointSet, handle : ImpulseJointHandle, wake_up : Bool) -> ImpulseJoint?ImpulseJointSet::get_unknown_gen
fn ImpulseJointSet::get_unknown_gen(self : ImpulseJointSet, id : Int) -> (ImpulseJoint, ImpulseJointHandle)?ImpulseJointSet::get_unknown_gen_mut
fn ImpulseJointSet::get_unknown_gen_mut(self : ImpulseJointSet, id : Int) -> (ImpulseJoint, ImpulseJointHandle)?ImpulseJointSet::insert
fn ImpulseJointSet::insert(self : ImpulseJointSet, body1 : RigidBodyHandle, body2 : RigidBodyHandle, joint : GenericJoint, wake_up : Bool) -> ImpulseJointHandleImpulseJointSet::iter
ImpulseJointSet::iter_mut
ImpulseJointSet::joint_graph
ImpulseJointSet::joints_between
fn ImpulseJointSet::joints_between(self : ImpulseJointSet, body1 : RigidBodyHandle, body2 : RigidBodyHandle) -> Array[(ImpulseJointHandle, ImpulseJoint)]ImpulseJointSet::map_attached_joints_mut
fn ImpulseJointSet::map_attached_joints_mut(self : ImpulseJointSet, handle : RigidBodyHandle, f : (RigidBodyHandle, RigidBodyHandle, ImpulseJointHandle, ImpulseJoint) -> Unit) -> UnitImpulseJointSet::remove
fn ImpulseJointSet::remove(self : ImpulseJointSet, handle : ImpulseJointHandle, wake_up : Bool) -> ImpulseJoint?ImpulseJointSet::remove_joints_attached_to_rigid_body
fn ImpulseJointSet::remove_joints_attached_to_rigid_body(self : ImpulseJointSet, handle : RigidBodyHandle) -> Array[ImpulseJointHandle]ImpulseJointSet::select_active_interactions
fn ImpulseJointSet::select_active_interactions(self : ImpulseJointSet, islands : IslandManager, bodies : RigidBodySet, out : Array[Array[Int]]) -> UnitImpulseJointSet::set_enabled
fn ImpulseJointSet::set_enabled(self : ImpulseJointSet, handle : ImpulseJointHandle, enabled : Bool) -> UnitImpulseJointSet::set_impulses
fn ImpulseJointSet::set_impulses(self : ImpulseJointSet, handle : ImpulseJointHandle, impulses : Vec2) -> UnitImpulseJointSet::set_solver_impulses
fn ImpulseJointSet::set_solver_impulses(self : ImpulseJointSet, handle : ImpulseJointHandle, impulses : Vec2, ang_impulse : Float, motor_lin_x : Float, motor_lin_y : Float, motor_ang_z : Float, limit_lin_x : Float, limit_lin_y : Float, limit_ang_z : Float) -> UnitImpulseJointSet::take_to_join
fn ImpulseJointSet::take_to_join(self : ImpulseJointSet) -> Array[(RigidBodyHandle, RigidBodyHandle)]ImpulseJointSet::take_wake_up
ImpulseJointSet3
pub struct ImpulseJointSet3 {
// private fields
}
fn ImpulseJointSet3::ImpulseJointSet3() -> ImpulseJointSet33D-flavored impulse joint set.
ImpulseJointSet3::attached_enabled_joints
fn ImpulseJointSet3::attached_enabled_joints(self : ImpulseJointSet3, handle : RigidBodyHandle) -> Array[(RigidBodyHandle, RigidBodyHandle, ImpulseJointHandle, ImpulseJoint)]ImpulseJointSet3::attached_joints
fn ImpulseJointSet3::attached_joints(self : ImpulseJointSet3, handle : RigidBodyHandle) -> Array[(RigidBodyHandle, RigidBodyHandle, ImpulseJointHandle, ImpulseJoint)]ImpulseJointSet3::contains
ImpulseJointSet3::get
ImpulseJointSet3::get_mut
fn ImpulseJointSet3::get_mut(self : ImpulseJointSet3, handle : ImpulseJointHandle, wake_up : Bool) -> ImpulseJoint?ImpulseJointSet3::get_unknown_gen
fn ImpulseJointSet3::get_unknown_gen(self : ImpulseJointSet3, id : Int) -> (ImpulseJoint, ImpulseJointHandle)?ImpulseJointSet3::get_unknown_gen_mut
fn ImpulseJointSet3::get_unknown_gen_mut(self : ImpulseJointSet3, id : Int) -> (ImpulseJoint, ImpulseJointHandle)?ImpulseJointSet3::insert
fn ImpulseJointSet3::insert(self : ImpulseJointSet3, body1 : RigidBodyHandle, body2 : RigidBodyHandle, joint : GenericJoint, wake_up : Bool) -> ImpulseJointHandleImpulseJointSet3::iter
ImpulseJointSet3::iter_mut
ImpulseJointSet3::joint_graph
ImpulseJointSet3::joints_between
fn ImpulseJointSet3::joints_between(self : ImpulseJointSet3, body1 : RigidBodyHandle, body2 : RigidBodyHandle) -> Array[(ImpulseJointHandle, ImpulseJoint)]ImpulseJointSet3::map_attached_joints_mut
fn ImpulseJointSet3::map_attached_joints_mut(self : ImpulseJointSet3, handle : RigidBodyHandle, f : (RigidBodyHandle, RigidBodyHandle, ImpulseJointHandle, ImpulseJoint) -> Unit) -> UnitImpulseJointSet3::remove
fn ImpulseJointSet3::remove(self : ImpulseJointSet3, handle : ImpulseJointHandle, wake_up : Bool) -> ImpulseJoint?ImpulseJointSet3::remove_joints_attached_to_rigid_body
fn ImpulseJointSet3::remove_joints_attached_to_rigid_body(self : ImpulseJointSet3, handle : RigidBodyHandle) -> Array[ImpulseJointHandle]ImpulseJointSet3::select_active_interactions
fn ImpulseJointSet3::select_active_interactions(self : ImpulseJointSet3, islands : IslandManager, bodies : RigidBodySet, out : Array[Array[Int]]) -> UnitImpulseJointSet3::set_enabled
fn ImpulseJointSet3::set_enabled(self : ImpulseJointSet3, handle : ImpulseJointHandle, enabled : Bool) -> UnitImpulseJointSet3::set_impulses
fn ImpulseJointSet3::set_impulses(self : ImpulseJointSet3, handle : ImpulseJointHandle, impulses : Vec2) -> UnitImpulseJointSet3::set_solver_impulses
fn ImpulseJointSet3::set_solver_impulses(self : ImpulseJointSet3, handle : ImpulseJointHandle, impulses : Vec2, ang_impulse : Float, motor_lin_x : Float, motor_lin_y : Float, motor_ang_z : Float, limit_lin_x : Float, limit_lin_y : Float, limit_ang_z : Float) -> UnitImpulseJointSet3::take_to_join
fn ImpulseJointSet3::take_to_join(self : ImpulseJointSet3) -> Array[(RigidBodyHandle, RigidBodyHandle)]ImpulseJointSet3::take_wake_up
IndexSequence
IndexSequence::inv_rearrange_rows
IndexSequence::rearrange_columns
fn IndexSequence::rearrange_columns(self : IndexSequence, vec : RowDVector, keep_columns : Bool) -> UnitIndexSequence::rearrange_rows
IndexSequence::with_rearranged_rows_mut
fn IndexSequence::with_rearranged_rows_mut(self : IndexSequence, vec : DVector, action : (DVector) -> Unit) -> UnitIntegrationParameters
pub struct IntegrationParameters {
dt : Float
min_ccd_dt : Float
contact_softness : SpringCoefficients
warmstart_coefficient : Float
length_unit : Float
normalized_allowed_linear_error : Float
normalized_max_corrective_velocity : Float
normalized_prediction_distance : Float
num_solver_iterations : Int
num_internal_pgs_iterations : Int
num_internal_stabilization_iterations : Int
min_island_size : Int
max_ccd_substeps : Int
friction_model : FrictionModel
}
fn IntegrationParameters::IntegrationParameters() -> IntegrationParametersIntegrationParameters::allowed_linear_error
IntegrationParameters::inv_dt
IntegrationParameters::max_corrective_velocity
IntegrationParameters::prediction_distance
IntegrationParameters::set_contact_softness
fn IntegrationParameters::set_contact_softness(self : IntegrationParameters, contact_softness : SpringCoefficients) -> IntegrationParametersIntegrationParameters::set_dt
IntegrationParameters::set_inv_dt
fn IntegrationParameters::set_inv_dt(self : IntegrationParameters, inv_dt : Float) -> IntegrationParametersIntegrationParameters::set_length_unit
fn IntegrationParameters::set_length_unit(self : IntegrationParameters, length_unit : Float) -> IntegrationParametersIntegrationParameters::set_max_ccd_substeps
fn IntegrationParameters::set_max_ccd_substeps(self : IntegrationParameters, max_ccd_substeps : Int) -> IntegrationParametersIntegrationParameters::set_min_ccd_dt
fn IntegrationParameters::set_min_ccd_dt(self : IntegrationParameters, min_ccd_dt : Float) -> IntegrationParametersIntegrationParameters::set_min_island_size
fn IntegrationParameters::set_min_island_size(self : IntegrationParameters, min_island_size : Int) -> IntegrationParametersIntegrationParameters::set_normalized_allowed_linear_error
fn IntegrationParameters::set_normalized_allowed_linear_error(self : IntegrationParameters, normalized_allowed_linear_error : Float) -> IntegrationParametersIntegrationParameters::set_normalized_max_corrective_velocity
fn IntegrationParameters::set_normalized_max_corrective_velocity(self : IntegrationParameters, normalized_max_corrective_velocity : Float) -> IntegrationParametersIntegrationParameters::set_normalized_prediction_distance
fn IntegrationParameters::set_normalized_prediction_distance(self : IntegrationParameters, normalized_prediction_distance : Float) -> IntegrationParametersIntegrationParameters::set_num_internal_pgs_iterations
fn IntegrationParameters::set_num_internal_pgs_iterations(self : IntegrationParameters, num_internal_pgs_iterations : Int) -> IntegrationParametersIntegrationParameters::set_num_internal_stabilization_iterations
fn IntegrationParameters::set_num_internal_stabilization_iterations(self : IntegrationParameters, num_internal_stabilization_iterations : Int) -> IntegrationParametersIntegrationParameters::set_num_solver_iterations
fn IntegrationParameters::set_num_solver_iterations(self : IntegrationParameters, num_solver_iterations : Int) -> IntegrationParametersIntegrationParameters::set_warmstart_coefficient
fn IntegrationParameters::set_warmstart_coefficient(self : IntegrationParameters, warmstart_coefficient : Float) -> IntegrationParametersIntegrationParameters::with_dt
fn IntegrationParameters::with_dt(self : IntegrationParameters, dt : Float) -> IntegrationParametersReturn a copy of these parameters with a different time-step, without mutating self.
InteractionGroups
pub struct InteractionGroups {
memberships : Group
filter : Group
test_mode : InteractionTestMode
}
fn InteractionGroups::InteractionGroups(memberships : Group, filter : Group, test_mode : InteractionTestMode) -> InteractionGroupsInteractionGroups::memberships
InteractionGroups::passes
InteractionGroups::test_and
InteractionGroups::test_groups
InteractionGroups::test_mode
InteractionGroups::test_or
InteractionGroups::with_filter
InteractionGroups::with_memberships
fn InteractionGroups::with_memberships(self : InteractionGroups, memberships : Group) -> InteractionGroupsInverseKinematicsOption
pub struct InverseKinematicsOption {
damping : Float
max_iters : Int
constrained_axes : JointAxesMask
epsilon_linear : Float
epsilon_angular : Float
}InverseKinematicsOption::default
InverseKinematicsOption::set_constrained_axes
fn InverseKinematicsOption::set_constrained_axes(self : InverseKinematicsOption, constrained_axes : JointAxesMask) -> InverseKinematicsOptionInverseKinematicsOption::set_damping
fn InverseKinematicsOption::set_damping(self : InverseKinematicsOption, damping : Float) -> InverseKinematicsOptionInverseKinematicsOption::set_epsilon_angular
fn InverseKinematicsOption::set_epsilon_angular(self : InverseKinematicsOption, epsilon_angular : Float) -> InverseKinematicsOptionInverseKinematicsOption::set_epsilon_linear
fn InverseKinematicsOption::set_epsilon_linear(self : InverseKinematicsOption, epsilon_linear : Float) -> InverseKinematicsOptionInverseKinematicsOption::set_max_iters
fn InverseKinematicsOption::set_max_iters(self : InverseKinematicsOption, max_iters : Int) -> InverseKinematicsOptionIslandManager
pub struct IslandManager {
islands : Array[Island?]
awake_islands : Array[Int]
free_islands : Array[Int]
traversal_candidates : Array[SleepCandidate]
traversal_timestamp : Int
optimizer : IslandsOptimizer
stack : Array[RigidBodyHandle]
body_island_ids : Array[Int]
body_island_generations : Array[Int]
body_island_indices : Array[Int]
body_state_generations : Array[Int]
}
fn IslandManager::IslandManager() -> IslandManagerIslandManager::active_bodies
IslandManager::active_islands
IslandManager::interaction_started_or_stopped
fn IslandManager::interaction_started_or_stopped(self : IslandManager, bodies : RigidBodySet, handle1 : RigidBodyHandle?, handle2 : RigidBodyHandle?, started : Bool, wake_up : Bool) -> UnitIslandManager::island_additional_solver_iterations
IslandManager::island_bodies
IslandManager::rigid_body_removed_or_disabled
fn IslandManager::rigid_body_removed_or_disabled(self : IslandManager, handle : RigidBodyHandle, bodies : RigidBodySet) -> UnitIslandManager::rigid_body_updated
fn IslandManager::rigid_body_updated(self : IslandManager, handle : RigidBodyHandle, bodies : RigidBodySet) -> UnitIslandManager::update_islands
fn IslandManager::update_islands(self : IslandManager, dt : Float, length_unit : Float, bodies : RigidBodySet, contacts : ContactGraph, impulse_joints : ImpulseJointSet, multibody_joints : MultibodyJointSet) -> UnitIslandManager::wake_up
fn IslandManager::wake_up(self : IslandManager, bodies : RigidBodySet, handle : RigidBodyHandle, strong : Bool) -> UnitIslandManager3
pub struct IslandManager3 {
inner : IslandManager
}
fn IslandManager3::IslandManager3() -> IslandManager33D-flavored island manager.
IslandManager3::active_bodies
IslandManager3::interaction_started_or_stopped
fn IslandManager3::interaction_started_or_stopped(self : IslandManager3, bodies : RigidBodySet3, handle1 : RigidBodyHandle?, handle2 : RigidBodyHandle?, started : Bool, stop_on_same_island : Bool) -> UnitIslandManager3::rigid_body_removed_or_disabled
fn IslandManager3::rigid_body_removed_or_disabled(self : IslandManager3, handle : RigidBodyHandle, bodies : RigidBodySet3) -> UnitIslandManager3::rigid_body_updated
fn IslandManager3::rigid_body_updated(self : IslandManager3, handle : RigidBodyHandle, bodies : RigidBodySet3) -> UnitIslandManager3::update_islands
fn IslandManager3::update_islands(self : IslandManager3, dt : Float, length_unit : Float, bodies : RigidBodySet3, contacts : ContactGraph, impulse_joints : ImpulseJointSet3, multibody_joints : MultibodyJointSet3) -> UnitIslandManager3::wake_up
fn IslandManager3::wake_up(self : IslandManager3, bodies : RigidBodySet3, handle : RigidBodyHandle, strong : Bool) -> UnitIslandManager3D
pub struct IslandManager3D {
active_bodies : Array[RigidBodyHandle]
islands : Array[Array[RigidBodyHandle]]
island_solver_iterations : Array[Int]
island_nodes : Array[Island3D?]
awake_island_ids : Array[Int]
free_island_ids : Array[Int]
body_island_ids : Array[Int]
body_island_generations : Array[Int]
body_island_indices : Array[Int]
body_sleep_state_generations : Array[Int]
body_sleep_states : Array[Int]
body_traversal_timestamps : Array[Int]
stack : Array[RigidBodyHandle]
optimizer : IslandsOptimizer3D
traversal_timestamp : Int
}
fn IslandManager3D::IslandManager3D() -> IslandManager3DDim3 island manager aligned with Rapier's persistent island model:
- stable island ids
- awake island list
- incremental merge/split optimizer
- sleeping component extraction on the interaction graph
Public query methods (active_islands, island_bodies, island_additional_solver_iterations)
expose island-scoped data used by the solver pipeline.
IslandManager3D::active_bodies
IslandManager3D::active_islands
IslandManager3D::island_additional_solver_iterations
fn IslandManager3D::island_additional_solver_iterations(self : IslandManager3D, island_id : Int) -> IntIslandManager3D::island_bodies
fn IslandManager3D::island_bodies(self : IslandManager3D, island_id : Int) -> Array[RigidBodyHandle]IslandManager3D::update
fn IslandManager3D::update(self : IslandManager3D, bodies : RigidBodySet3D, interactions : Array[(RigidBodyHandle, RigidBodyHandle)]) -> UnitJacobian
type JacobianJacobian3
JointAxesMask
JointAxesMask::contains
JointAxesMask::intersection
JointAxesMask::locked_prismatic_axes
JointAxesMask::locked_prismatic_axes3
JointAxesMask::locked_revolute_axes3
JointAxesMask::locked_spherical_axes
JointAxesMask::or
JointAxesMask3DReal
pub struct JointAxesMask3DReal {
bits : Int
}
fn JointAxesMask3DReal::JointAxesMask3DReal(bits : Int) -> JointAxesMask3DRealJointAxesMask3DReal::contains
JointAxesMask3DReal::free_fixed_axes
JointAxesMask3DReal::free_prismatic_axes
JointAxesMask3DReal::free_revolute_axes
JointAxesMask3DReal::free_spherical_axes
JointAxesMask3DReal::intersection
fn JointAxesMask3DReal::intersection(self : JointAxesMask3DReal, other : JointAxesMask3DReal) -> JointAxesMask3DRealJointAxesMask3DReal::locked_fixed_axes
JointAxesMask3DReal::locked_prismatic_axes
JointAxesMask3DReal::locked_revolute_axes
JointAxesMask3DReal::locked_spherical_axes
JointAxesMask3DReal::or
fn JointAxesMask3DReal::or(self : JointAxesMask3DReal, other : JointAxesMask3DReal) -> JointAxesMask3DRealJointHandle3DReal
pub struct JointHandle3DReal {
index : Int
}A handle to a joint stored inside a JointSet3DReal.
This currently only references joints created via insert_generic and its helpers.
JointLimits
pub struct JointLimits {
min : Float
max : Float
impulse : Float
}
fn JointLimits::JointLimits(min : Float, max : Float) -> JointLimitsJointLimits::set_impulse
JointLimits3
pub struct JointLimits3 {
lin_x : JointLimits
lin_y : JointLimits
lin_z : JointLimits
ang_x : JointLimits
ang_y : JointLimits
ang_z : JointLimits
}JointMotor
pub struct JointMotor {
target_vel : Float
target_pos : Float
stiffness : Float
damping : Float
max_force : Float
impulse : Float
model : MotorModel
}JointMotor::set_damping
JointMotor::set_impulse
JointMotor::set_max_force
JointMotor::set_model
JointMotor::set_stiffness
JointMotor::set_target_pos
JointMotor::set_target_vel
JointMotors3
pub struct JointMotors3 {
lin_x : JointMotor
lin_y : JointMotor
lin_z : JointMotor
ang_x : JointMotor
ang_y : JointMotor
ang_z : JointMotor
}JointSet3DReal
pub struct JointSet3DReal {
spherical : Array[SphericalJoint3DReal]
prismatic : Array[PrismaticJoint3DReal]
spherical_motors : Array[SphericalMotor3DReal]
generic : Array[GenericJointConstraint3DReal]
springs : Array[SpringJoint3DReal]
spherical_impulses : Array[Vec3]
prismatic_lock_impulses : Array[Vec2]
prismatic_motor_impulses : Array[Float]
prismatic_angular_impulses : Array[Vec3]
spherical_motor_impulses : Array[Vec3]
generic_lock_impulses : Array[Array[Float]]
generic_limit_impulses : Array[Array[Float]]
generic_motor_impulses : Array[Array[Float]]
generic_coupled_impulses : Array[Float]
spring_impulses : Array[Float]
}
fn JointSet3DReal::JointSet3DReal() -> JointSet3DRealJointSet3DReal::disabled_contact_pairs
fn JointSet3DReal::disabled_contact_pairs(self : JointSet3DReal) -> Array[(RigidBodyHandle, RigidBodyHandle)]JointSet3DReal::insert_generic
fn JointSet3DReal::insert_generic(self : JointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle, data : GenericJoint3DReal, wake_up : Bool) -> JointHandle3DRealJointSet3DReal::insert_prismatic_motor_position
fn JointSet3DReal::insert_prismatic_motor_position(self : JointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle, local_axis1 : Vec3, local_anchor1 : Vec3, local_anchor2 : Vec3, target : Float, stiffness : Float, damping : Float) -> UnitJointSet3DReal::insert_revolute
fn JointSet3DReal::insert_revolute(self : JointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle, axis : Vec3, local_anchor1 : Vec3, local_anchor2 : Vec3, wake_up : Bool) -> JointHandle3DRealJointSet3DReal::insert_spherical
fn JointSet3DReal::insert_spherical(self : JointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle, local_anchor1 : Vec3, local_anchor2 : Vec3) -> UnitJointSet3DReal::insert_spherical_motor_rotation
fn JointSet3DReal::insert_spherical_motor_rotation(self : JointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle, target_rel_rotation : Quat, stiffness : Float, damping : Float) -> UnitJointSet3DReal::insert_spring
fn JointSet3DReal::insert_spring(self : JointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle, local_anchor1 : Vec3, local_anchor2 : Vec3, rest_length : Float, stiffness : Float, damping : Float, wake_up : Bool) -> UnitJointSet3DReal::interaction_pairs
fn JointSet3DReal::interaction_pairs(self : JointSet3DReal) -> Array[(RigidBodyHandle, RigidBodyHandle)]JointSet3DReal::set_motor_position
fn JointSet3DReal::set_motor_position(self : JointSet3DReal, handle : JointHandle3DReal, axis : JointAxis3DReal, target_pos : Float, stiffness : Float, damping : Float, max_force : Float) -> UnitJointSet3DReal::set_motor_velocity
fn JointSet3DReal::set_motor_velocity(self : JointSet3DReal, handle : JointHandle3DReal, axis : JointAxis3DReal, target_vel : Float, damping : Float, max_force : Float) -> UnitJointSet3DReal::solve
fn JointSet3DReal::solve(self : JointSet3DReal, bodies : RigidBodySet3D, dt : Float, iterations : Int) -> UnitJointSet3DReal::solve_with_island_stamp
fn JointSet3DReal::solve_with_island_stamp(self : JointSet3DReal, bodies : RigidBodySet3D, dt : Float, iterations : Int, island_stamps : Array[Int]?, island_stamp : Int) -> UnitJointSolverBody
A small "solver-body" view used by advanced joint-constraint builders.
LinkOrBodyRef
A reference to either a multibody link or a rigid-body solver slot.
This is part of Rapier's advanced joint-solver public surface. The MoonBit port
keeps it as a lightweight enum to satisfy pub parity, without tying it to a
particular solver implementation.
LockedAxes
Leaf-name shims for Rapier's LockedAxes bitflags.
This port's 2D rigid-body implementation currently uses coarse lock flags
(locked_translations / locked_rotations). We still expose LockedAxes
so the public surface matches Rapier's default-feature crates.
MotorModel
pub(all) enum MotorModel {
AccelerationBased
ForceBased
}MotorModel::combine_coefficients
fn MotorModel::combine_coefficients(self : MotorModel, dt : Float, stiffness : Float, damping : Float) -> (Float, Float, Float)MotorState3DReal
pub(all) enum MotorState3DReal {
Disabled
Velocity(Float, Float, Float)
Position(Float, Float, Float, Float)
}Multibody
Multibody::apply_displacements
Multibody::body_jacobian
Multibody::forward_kinematics
fn Multibody::forward_kinematics(self : Multibody, bodies : RigidBodySet, update_positions : Bool) -> UnitMultibody::forward_kinematics_single_branch
Multibody::forward_kinematics_single_link
Multibody::generalized_acceleration
Multibody::generalized_velocity
Multibody::generalized_velocity_mut
Multibody::inverse_kinematics
fn Multibody::inverse_kinematics(self : Multibody, bodies : RigidBodySet, link_id : LinkId, options : InverseKinematicsOption, target_pose : Isometry2, joint_can_move : (MultibodyLink) -> Bool, displacements : DVector) -> UnitMultibody::inverse_kinematics_delta
Multibody::inverse_kinematics_delta_with_jacobian
Multibody::joint_velocity
Multibody::kinematic_branch
Multibody::set_self_contacts_enabled
Multibody::update_rigid_bodies
Multibody3
Multibody3::apply_displacements
Multibody3::body_jacobian
Multibody3::forward_kinematics
fn Multibody3::forward_kinematics(self : Multibody3, bodies : RigidBodySet3, update_dofs : Bool) -> UnitMultibody3::forward_kinematics_single_link
fn Multibody3::forward_kinematics_single_link(self : Multibody3, bodies : RigidBodySet3, id : LinkId, displacements : Array[Float]?, jacobian : Jacobian3?) -> Isometry3Multibody3::inverse_kinematics
fn Multibody3::inverse_kinematics(self : Multibody3, bodies : RigidBodySet3, id : LinkId, options : InverseKinematicsOption, target : Isometry3, can_move : (MultibodyLink) -> Bool, displacements : DVector) -> UnitMultibody3DReal
Multibody3DReal::apply_displacements
fn Multibody3DReal::apply_displacements(self : Multibody3DReal, displacements : Array[Float]) -> UnitMultibody3DReal::body_jacobian
Multibody3DReal::forward_kinematics
fn Multibody3DReal::forward_kinematics(self : Multibody3DReal, bodies : RigidBodySet3D, update_dofs : Bool) -> UnitMultibody3DReal::forward_kinematics_single_link
fn Multibody3DReal::forward_kinematics_single_link(self : Multibody3DReal, bodies : RigidBodySet3D, id : LinkId, displacements : Array[Float]?, jacobian : Jacobian3?) -> Isometry3Multibody3DReal::inverse_kinematics
fn Multibody3DReal::inverse_kinematics(self : Multibody3DReal, bodies : RigidBodySet3D, id : LinkId, options : InverseKinematicsOption, target : Isometry3, can_move : (MultibodyLink) -> Bool, displacements : DVector) -> UnitMultibody3DReal::link_pose
MultibodyIndex
type MultibodyIndexMultibodyJoint
pub struct MultibodyJoint {
data : GenericJoint
kinematic : Bool
coords : Vec2
angle : Float
joint_rot : Rot2
lin_coords3 : Vec3
ang_coords3 : Vec3
joint_rot3 : Quat
axis3 : Vec3
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
local_frame1_rotation : Quat
local_frame2_rotation : Quat
solver_lin_impulses : Vec2
}
fn MultibodyJoint::MultibodyJoint(data : GenericJoint, kinematic : Bool) -> MultibodyJointAn joint attached to two bodies based on the reduced coordinates formalism.
This mirrors Rapier's MultibodyJoint public surface. The current MoonBit port
uses a constraint-based solver for articulated bodies; this type is provided as
a deterministic data container and for API parity.
MultibodyJoint::apply_displacement
MultibodyJoint::body_to_parent
MultibodyJoint::default_damping
MultibodyJoint::jacobian
MultibodyJoint::jacobian_mul_coordinates
fn MultibodyJoint::jacobian_mul_coordinates(self : MultibodyJoint, coords : Array[Float]) -> RigidBodyVelocityMultibodyJoint::num_velocity_constraints
MultibodyJoint::velocity_constraints
fn MultibodyJoint::velocity_constraints(self : MultibodyJoint, params : IntegrationParameters, multibody : Multibody, link : MultibodyLink, j_id : Int, jacobians : DVector, constraints : Array[GenericJointConstraint]) -> IntMultibodyJointHandle
type MultibodyJointHandleMultibodyJointHandle::from_raw_parts
MultibodyJointHandle::into_raw_parts
MultibodyJointSet
pub struct MultibodyJointSet {
// private fields
}
fn MultibodyJointSet::MultibodyJointSet() -> MultibodyJointSetMultibodyJointSet::attached_bodies
fn MultibodyJointSet::attached_bodies(self : MultibodyJointSet, handle : RigidBodyHandle) -> Array[RigidBodyHandle]MultibodyJointSet::attached_joints
fn MultibodyJointSet::attached_joints(self : MultibodyJointSet, handle : RigidBodyHandle) -> Array[(RigidBodyHandle, RigidBodyHandle, MultibodyJointHandle)]MultibodyJointSet::bodies_attached_with_enabled_joint
fn MultibodyJointSet::bodies_attached_with_enabled_joint(self : MultibodyJointSet, handle : RigidBodyHandle) -> Array[RigidBodyHandle]MultibodyJointSet::deserialize
MultibodyJointSet::get
fn MultibodyJointSet::get(self : MultibodyJointSet, handle : MultibodyJointHandle) -> (Multibody, LinkId)?MultibodyJointSet::get_multibody
MultibodyJointSet::get_multibody_mut
fn MultibodyJointSet::get_multibody_mut(self : MultibodyJointSet, index : MultibodyIndex) -> Multibody?MultibodyJointSet::get_multibody_mut_internal
fn MultibodyJointSet::get_multibody_mut_internal(self : MultibodyJointSet, index : MultibodyIndex) -> Multibody?MultibodyJointSet::get_mut
fn MultibodyJointSet::get_mut(self : MultibodyJointSet, handle : MultibodyJointHandle) -> (Multibody, LinkId)?MultibodyJointSet::get_mut_internal
fn MultibodyJointSet::get_mut_internal(self : MultibodyJointSet, handle : MultibodyJointHandle) -> (Multibody, LinkId)?MultibodyJointSet::get_unknown_gen
fn MultibodyJointSet::get_unknown_gen(self : MultibodyJointSet, id : Int) -> (Multibody, LinkId, MultibodyJointHandle)?MultibodyJointSet::insert
fn MultibodyJointSet::insert(self : MultibodyJointSet, parent : RigidBodyHandle, child : RigidBodyHandle, joint : GenericJoint, wake_up : Bool) -> MultibodyJointHandle?MultibodyJointSet::insert_kinematic
fn MultibodyJointSet::insert_kinematic(self : MultibodyJointSet, parent : RigidBodyHandle, child : RigidBodyHandle, joint : GenericJoint, wake_up : Bool) -> MultibodyJointHandle?MultibodyJointSet::iter
fn MultibodyJointSet::iter(self : MultibodyJointSet) -> Array[(MultibodyJointHandle, MultibodyLinkId, Multibody, MultibodyLink)]MultibodyJointSet::joint_between
fn MultibodyJointSet::joint_between(self : MultibodyJointSet, body1 : RigidBodyHandle, body2 : RigidBodyHandle) -> (MultibodyJointHandle, Multibody, MultibodyLink)?MultibodyJointSet::multibodies
MultibodyJointSet::remove
fn MultibodyJointSet::remove(self : MultibodyJointSet, handle : MultibodyJointHandle, wake_up : Bool) -> UnitMultibodyJointSet::remove_multibody_articulations
fn MultibodyJointSet::remove_multibody_articulations(self : MultibodyJointSet, handle : RigidBodyHandle, wake_up : Bool) -> UnitMultibodyJointSet::revolute_joint_descriptors
fn MultibodyJointSet::revolute_joint_descriptors(self : MultibodyJointSet) -> Array[MultibodyRevoluteJointDesc]MultibodyJointSet::rigid_body_link
fn MultibodyJointSet::rigid_body_link(self : MultibodyJointSet, handle : RigidBodyHandle) -> MultibodyLinkId?MultibodyJointSet::serialize
MultibodyJointSet::set_revolute_joint_solver_impulses
fn MultibodyJointSet::set_revolute_joint_solver_impulses(self : MultibodyJointSet, link : MultibodyLinkId, lin_impulses : Vec2, motor_impulse : Float, limit_impulse : Float) -> UnitMultibodyJointSet::sync_rigid_bodies_from_multibodies
fn MultibodyJointSet::sync_rigid_bodies_from_multibodies(self : MultibodyJointSet, bodies : RigidBodySet) -> UnitMultibodyJointSet::take_to_join
fn MultibodyJointSet::take_to_join(self : MultibodyJointSet) -> Array[(RigidBodyHandle, RigidBodyHandle)]MultibodyJointSet::take_wake_up
MultibodyJointSet3
pub struct MultibodyJointSet3 {
// private fields
}
fn MultibodyJointSet3::MultibodyJointSet3() -> MultibodyJointSet33D-flavored multibody joint set.
MultibodyJointSet3::as_2d
MultibodyJointSet3::attached_bodies
fn MultibodyJointSet3::attached_bodies(self : MultibodyJointSet3, handle : RigidBodyHandle) -> Array[RigidBodyHandle]MultibodyJointSet3::attached_joints
fn MultibodyJointSet3::attached_joints(self : MultibodyJointSet3, handle : RigidBodyHandle) -> Array[(RigidBodyHandle, RigidBodyHandle, MultibodyJointHandle)]MultibodyJointSet3::bodies_attached_with_enabled_joint
fn MultibodyJointSet3::bodies_attached_with_enabled_joint(self : MultibodyJointSet3, handle : RigidBodyHandle) -> Array[RigidBodyHandle]MultibodyJointSet3::disabled_contact_pairs
fn MultibodyJointSet3::disabled_contact_pairs(self : MultibodyJointSet3) -> Array[(RigidBodyHandle, RigidBodyHandle)]MultibodyJointSet3::get
fn MultibodyJointSet3::get(self : MultibodyJointSet3, handle : MultibodyJointHandle) -> (Multibody3, LinkId)?MultibodyJointSet3::get_multibody
fn MultibodyJointSet3::get_multibody(self : MultibodyJointSet3, index : MultibodyIndex) -> Multibody3?MultibodyJointSet3::get_multibody_mut
fn MultibodyJointSet3::get_multibody_mut(self : MultibodyJointSet3, index : MultibodyIndex) -> Multibody3?MultibodyJointSet3::get_multibody_mut_internal
fn MultibodyJointSet3::get_multibody_mut_internal(self : MultibodyJointSet3, index : MultibodyIndex) -> Multibody3?MultibodyJointSet3::get_mut
fn MultibodyJointSet3::get_mut(self : MultibodyJointSet3, handle : MultibodyJointHandle) -> (Multibody3, LinkId)?MultibodyJointSet3::get_mut_internal
fn MultibodyJointSet3::get_mut_internal(self : MultibodyJointSet3, handle : MultibodyJointHandle) -> (Multibody3, LinkId)?MultibodyJointSet3::get_unknown_gen
fn MultibodyJointSet3::get_unknown_gen(self : MultibodyJointSet3, id : Int) -> (Multibody3, LinkId, MultibodyJointHandle)?MultibodyJointSet3::insert
fn MultibodyJointSet3::insert(self : MultibodyJointSet3, parent : RigidBodyHandle, child : RigidBodyHandle, joint : GenericJoint, wake_up : Bool) -> MultibodyJointHandle?MultibodyJointSet3::insert_kinematic
fn MultibodyJointSet3::insert_kinematic(self : MultibodyJointSet3, parent : RigidBodyHandle, child : RigidBodyHandle, joint : GenericJoint, wake_up : Bool) -> MultibodyJointHandle?MultibodyJointSet3::interaction_pairs
fn MultibodyJointSet3::interaction_pairs(self : MultibodyJointSet3) -> Array[(RigidBodyHandle, RigidBodyHandle)]MultibodyJointSet3::iter
fn MultibodyJointSet3::iter(self : MultibodyJointSet3) -> Array[(MultibodyJointHandle, MultibodyLinkId, Multibody3, MultibodyLink)]MultibodyJointSet3::joint_between
fn MultibodyJointSet3::joint_between(self : MultibodyJointSet3, body1 : RigidBodyHandle, body2 : RigidBodyHandle) -> (MultibodyJointHandle, Multibody3, MultibodyLink)?MultibodyJointSet3::multibodies
MultibodyJointSet3::remove
fn MultibodyJointSet3::remove(self : MultibodyJointSet3, handle : MultibodyJointHandle, wake_up : Bool) -> UnitMultibodyJointSet3::remove_multibody_articulations
fn MultibodyJointSet3::remove_multibody_articulations(self : MultibodyJointSet3, handle : RigidBodyHandle, wake_up : Bool) -> UnitMultibodyJointSet3::revolute_joint_descriptors
fn MultibodyJointSet3::revolute_joint_descriptors(self : MultibodyJointSet3) -> Array[MultibodyRevoluteJointDesc]MultibodyJointSet3::rigid_body_link
fn MultibodyJointSet3::rigid_body_link(self : MultibodyJointSet3, handle : RigidBodyHandle) -> MultibodyLinkId?MultibodyJointSet3::set_revolute_joint_solver_impulses
fn MultibodyJointSet3::set_revolute_joint_solver_impulses(self : MultibodyJointSet3, link : MultibodyLinkId, lin_impulses : Vec2, motor_impulse : Float, limit_impulse : Float) -> UnitMultibodyJointSet3::sync_rigid_bodies_from_multibodies
fn MultibodyJointSet3::sync_rigid_bodies_from_multibodies(self : MultibodyJointSet3, bodies : RigidBodySet3) -> UnitMultibodyJointSet3::take_to_join
fn MultibodyJointSet3::take_to_join(self : MultibodyJointSet3) -> Array[(RigidBodyHandle, RigidBodyHandle)]MultibodyJointSet3::take_wake_up
MultibodyJointSet3DReal
pub struct MultibodyJointSet3DReal {
inner : MultibodyJointSet3
}
fn MultibodyJointSet3DReal::MultibodyJointSet3DReal() -> MultibodyJointSet3DRealMultibodyJointSet3DReal::attached_bodies
fn MultibodyJointSet3DReal::attached_bodies(self : MultibodyJointSet3DReal, handle : RigidBodyHandle) -> Array[RigidBodyHandle]MultibodyJointSet3DReal::attached_joints
fn MultibodyJointSet3DReal::attached_joints(self : MultibodyJointSet3DReal, handle : RigidBodyHandle) -> Array[(RigidBodyHandle, RigidBodyHandle, MultibodyJointHandle)]MultibodyJointSet3DReal::bodies_attached_with_enabled_joint
fn MultibodyJointSet3DReal::bodies_attached_with_enabled_joint(self : MultibodyJointSet3DReal, handle : RigidBodyHandle) -> Array[RigidBodyHandle]MultibodyJointSet3DReal::disabled_contact_pairs
fn MultibodyJointSet3DReal::disabled_contact_pairs(self : MultibodyJointSet3DReal) -> Array[(RigidBodyHandle, RigidBodyHandle)]MultibodyJointSet3DReal::get
fn MultibodyJointSet3DReal::get(self : MultibodyJointSet3DReal, handle : MultibodyJointHandle) -> (Multibody3DReal, LinkId)?MultibodyJointSet3DReal::get_multibody
fn MultibodyJointSet3DReal::get_multibody(self : MultibodyJointSet3DReal, index : MultibodyIndex) -> Multibody3DReal?MultibodyJointSet3DReal::get_multibody_mut
fn MultibodyJointSet3DReal::get_multibody_mut(self : MultibodyJointSet3DReal, index : MultibodyIndex) -> Multibody3DReal?MultibodyJointSet3DReal::get_mut
fn MultibodyJointSet3DReal::get_mut(self : MultibodyJointSet3DReal, handle : MultibodyJointHandle) -> (Multibody3DReal, LinkId)?MultibodyJointSet3DReal::get_unknown_gen
fn MultibodyJointSet3DReal::get_unknown_gen(self : MultibodyJointSet3DReal, id : Int) -> (Multibody3DReal, LinkId, MultibodyJointHandle)?MultibodyJointSet3DReal::insert
fn MultibodyJointSet3DReal::insert(self : MultibodyJointSet3DReal, parent : RigidBodyHandle, child : RigidBodyHandle, joint : GenericJoint3DReal, wake_up : Bool) -> MultibodyJointHandle?MultibodyJointSet3DReal::insert_kinematic
fn MultibodyJointSet3DReal::insert_kinematic(self : MultibodyJointSet3DReal, parent : RigidBodyHandle, child : RigidBodyHandle, joint : GenericJoint3DReal, wake_up : Bool) -> MultibodyJointHandle?MultibodyJointSet3DReal::interaction_pairs
fn MultibodyJointSet3DReal::interaction_pairs(self : MultibodyJointSet3DReal) -> Array[(RigidBodyHandle, RigidBodyHandle)]MultibodyJointSet3DReal::iter
fn MultibodyJointSet3DReal::iter(self : MultibodyJointSet3DReal) -> Array[(MultibodyJointHandle, MultibodyLinkId, Multibody3DReal, MultibodyLink)]MultibodyJointSet3DReal::joint_between
fn MultibodyJointSet3DReal::joint_between(self : MultibodyJointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle) -> (MultibodyJointHandle, Multibody3DReal, MultibodyLink)?MultibodyJointSet3DReal::multibodies
MultibodyJointSet3DReal::remove
fn MultibodyJointSet3DReal::remove(self : MultibodyJointSet3DReal, handle : MultibodyJointHandle, wake_up : Bool) -> UnitMultibodyJointSet3DReal::remove_multibody_articulations
fn MultibodyJointSet3DReal::remove_multibody_articulations(self : MultibodyJointSet3DReal, handle : RigidBodyHandle, wake_up : Bool) -> UnitMultibodyJointSet3DReal::revolute_joint_descriptors
fn MultibodyJointSet3DReal::revolute_joint_descriptors(self : MultibodyJointSet3DReal) -> Array[MultibodyRevoluteJointDesc]MultibodyJointSet3DReal::rigid_body_link
fn MultibodyJointSet3DReal::rigid_body_link(self : MultibodyJointSet3DReal, handle : RigidBodyHandle) -> MultibodyLinkId?MultibodyJointSet3DReal::set_revolute_joint_solver_impulses
fn MultibodyJointSet3DReal::set_revolute_joint_solver_impulses(self : MultibodyJointSet3DReal, link : MultibodyLinkId, lin_impulses : Vec2, motor_impulse : Float, limit_impulse : Float) -> UnitMultibodyJointSet3DReal::sync_rigid_bodies_from_multibodies
fn MultibodyJointSet3DReal::sync_rigid_bodies_from_multibodies(self : MultibodyJointSet3DReal, bodies : RigidBodySet3D) -> UnitMultibodyJointSet3DReal::take_to_join
fn MultibodyJointSet3DReal::take_to_join(self : MultibodyJointSet3DReal) -> Array[(RigidBodyHandle, RigidBodyHandle)]MultibodyJointSet3DReal::take_wake_up
MultibodyLink
pub struct MultibodyLink {
// private fields
}
fn MultibodyLink::MultibodyLink(rigid_body : RigidBodyHandle, internal_id : Int, assembly_id : Int, parent_internal_id : Int, joint : MultibodyJoint, local_to_world : Isometry2, local_to_parent : Isometry2) -> MultibodyLinkMultibodyLink::local_to_parent
MultibodyLink::local_to_world
MultibodyLink::rigid_body_handle
MultibodyLinkId
type MultibodyLinkIdMultibodyLinkId::multibody
MultibodyRevoluteJointDesc
pub struct MultibodyRevoluteJointDesc {
link : MultibodyLinkId
parent : RigidBodyHandle
child : RigidBodyHandle
joint : RevoluteJoint
solver_lin_impulses : Vec2
}A lightweight joint view used by the physics pipeline to build solver constraints.
This intentionally exposes only what the pipeline needs (parent/child rigid-bodies and the
revolute joint parameters + warmstart cache). The canonical storage remains inside the
multibody.
PdErrors3
Pose error between two isometries, expressed at the center of mass.
PinSlotJoint
pub struct PinSlotJoint {
axis : Vec2
local_anchor1 : Vec2
local_anchor2 : Vec2
limits : JointLimits
limits_enabled : Bool
}
fn PinSlotJoint::PinSlotJoint(axis : Vec2) -> PinSlotJointPinSlotJoint::set_local_axis1
PinSlotJoint::set_local_axis2
PinSlotJointBuilder
pub struct PinSlotJointBuilder {
axis : Vec2
local_anchor1 : Vec2
local_anchor2 : Vec2
limits : JointLimits
limits_enabled : Bool
}
fn PinSlotJointBuilder::PinSlotJointBuilder(axis : Vec2) -> PinSlotJointBuilderPinSlotJointBuilder::build
PinSlotJointBuilder::limits
fn PinSlotJointBuilder::limits(self : PinSlotJointBuilder, min : Float, max : Float) -> PinSlotJointBuilderPinSlotJointBuilder::local_anchor1
fn PinSlotJointBuilder::local_anchor1(self : PinSlotJointBuilder, anchor : Vec2) -> PinSlotJointBuilderPinSlotJointBuilder::local_anchor2
fn PinSlotJointBuilder::local_anchor2(self : PinSlotJointBuilder, anchor : Vec2) -> PinSlotJointBuilderPredictedImpacts
pub(all) enum PredictedImpacts {
Impacts(Array[(RigidBodyHandle, Float)])
ImpactsAfterEndTime(Float)
NoImpacts
}PrismaticJoint
pub struct PrismaticJoint {
axis : Vec2
local_anchor1 : Vec2
local_anchor2 : Vec2
axis3 : Vec3
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
local_frame1_rotation : Quat
local_frame2_rotation : Quat
is_spatial : Bool
softness : SpringCoefficients
motor : JointMotor
motor_enabled : Bool
limits : JointLimits
limits_enabled : Bool
}
fn PrismaticJoint::PrismaticJoint(axis : Vec2) -> PrismaticJointPrismaticJoint::set_local_axis1
PrismaticJoint::set_local_axis2
PrismaticJoint::softness
PrismaticJoint3DReal
pub struct PrismaticJoint3DReal {
body1 : RigidBodyHandle
body2 : RigidBodyHandle
local_anchor1 : Vec3
local_anchor2 : Vec3
local_axis1 : Vec3
motor_target : Float
motor_stiffness : Float
motor_damping : Float
motor_enabled : Bool
}PrismaticJoint3DRealBuilder
pub struct PrismaticJoint3DRealBuilder {
inner : GenericJoint3DRealBuilder
}
fn PrismaticJoint3DRealBuilder::PrismaticJoint3DRealBuilder(axis : Vec3) -> PrismaticJoint3DRealBuilderPrismaticJoint3DRealBuilder::build
PrismaticJoint3DRealBuilder::limits
fn PrismaticJoint3DRealBuilder::limits(self : PrismaticJoint3DRealBuilder, min : Float, max : Float) -> PrismaticJoint3DRealBuilderPrismaticJoint3DRealBuilder::local_anchor1
fn PrismaticJoint3DRealBuilder::local_anchor1(self : PrismaticJoint3DRealBuilder, a : Vec3) -> PrismaticJoint3DRealBuilderPrismaticJoint3DRealBuilder::local_anchor2
fn PrismaticJoint3DRealBuilder::local_anchor2(self : PrismaticJoint3DRealBuilder, a : Vec3) -> PrismaticJoint3DRealBuilderPrismaticJoint3DRealBuilder::motor_max_force
fn PrismaticJoint3DRealBuilder::motor_max_force(self : PrismaticJoint3DRealBuilder, max_force : Float) -> PrismaticJoint3DRealBuilderPrismaticJoint3DRealBuilder::motor_position
fn PrismaticJoint3DRealBuilder::motor_position(self : PrismaticJoint3DRealBuilder, target_pos : Float, stiffness : Float, damping : Float) -> PrismaticJoint3DRealBuilderPrismaticJoint3DRealBuilder::motor_velocity
fn PrismaticJoint3DRealBuilder::motor_velocity(self : PrismaticJoint3DRealBuilder, target_vel : Float, damping : Float) -> PrismaticJoint3DRealBuilderPrismaticJointBuilder
pub struct PrismaticJointBuilder {
// private fields
}
fn PrismaticJointBuilder::PrismaticJointBuilder(axis : Vec2) -> PrismaticJointBuilderPrismaticJointBuilder::build
PrismaticJointBuilder::limits
fn PrismaticJointBuilder::limits(self : PrismaticJointBuilder, min : Float, max : Float) -> PrismaticJointBuilderPrismaticJointBuilder::local_anchor1
fn PrismaticJointBuilder::local_anchor1(self : PrismaticJointBuilder, anchor : Vec2) -> PrismaticJointBuilderPrismaticJointBuilder::local_anchor2
fn PrismaticJointBuilder::local_anchor2(self : PrismaticJointBuilder, anchor : Vec2) -> PrismaticJointBuilderPrismaticJointBuilder::motor_max_force
fn PrismaticJointBuilder::motor_max_force(self : PrismaticJointBuilder, max_force : Float) -> PrismaticJointBuilderPrismaticJointBuilder::motor_model
fn PrismaticJointBuilder::motor_model(self : PrismaticJointBuilder, model : MotorModel) -> PrismaticJointBuilderPrismaticJointBuilder::motor_position
fn PrismaticJointBuilder::motor_position(self : PrismaticJointBuilder, target_pos : Float, stiffness : Float, damping : Float) -> PrismaticJointBuilderPrismaticJointBuilder::motor_velocity
fn PrismaticJointBuilder::motor_velocity(self : PrismaticJointBuilder, target_vel : Float, factor : Float) -> PrismaticJointBuilderPrismaticJointBuilder::softness
fn PrismaticJointBuilder::softness(self : PrismaticJointBuilder, softness : SpringCoefficients) -> PrismaticJointBuilderPrismaticJointBuilder3
pub struct PrismaticJointBuilder3 {
inner : PrismaticJointBuilder
axis : Vec3
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
}
fn PrismaticJointBuilder3::PrismaticJointBuilder3(axis : Vec3) -> PrismaticJointBuilder33D-flavored prismatic joint builder used by the rapier3d parity tests.
NOTE: This maps to the existing 2D prismatic joint builder by dropping the z coordinate.
PrismaticJointBuilder3::build
PrismaticJointBuilder3::limits
fn PrismaticJointBuilder3::limits(self : PrismaticJointBuilder3, min : Float, max : Float) -> PrismaticJointBuilder3PrismaticJointBuilder3::local_anchor1
fn PrismaticJointBuilder3::local_anchor1(self : PrismaticJointBuilder3, anchor1 : Vec3) -> PrismaticJointBuilder3PrismaticJointBuilder3::local_anchor2
fn PrismaticJointBuilder3::local_anchor2(self : PrismaticJointBuilder3, anchor2 : Vec3) -> PrismaticJointBuilder3PrismaticJointBuilder3::motor_max_force
fn PrismaticJointBuilder3::motor_max_force(self : PrismaticJointBuilder3, max_force : Float) -> PrismaticJointBuilder3PrismaticJointBuilder3::motor_model
fn PrismaticJointBuilder3::motor_model(self : PrismaticJointBuilder3, model : MotorModel) -> PrismaticJointBuilder3PrismaticJointBuilder3::motor_position
fn PrismaticJointBuilder3::motor_position(self : PrismaticJointBuilder3, target_pos : Float, stiffness : Float, damping : Float) -> PrismaticJointBuilder3PrismaticJointBuilder3::motor_velocity
fn PrismaticJointBuilder3::motor_velocity(self : PrismaticJointBuilder3, target_vel : Float, factor : Float) -> PrismaticJointBuilder3PrismaticJointBuilder3::softness
fn PrismaticJointBuilder3::softness(self : PrismaticJointBuilder3, softness : SpringCoefficients) -> PrismaticJointBuilder3RevoluteJoint
RevoluteJoint::angle
RevoluteJoint3
pub struct RevoluteJoint3 {
axis : Vec3
local_frame1_rotation : Quat
local_frame2_rotation : Quat
}
fn RevoluteJoint3::RevoluteJoint3(axis : Vec3) -> RevoluteJoint33D revolute joint. This is the dim3 counterpart of the 2D RevoluteJointBuilder/GenericJoint
path used in the rapier2d-aligned API.
RevoluteJoint3::angle
The angle along the free degree of freedom of this revolute joint in [-pi, pi].
RevoluteJoint3Builder
RevoluteJoint3Builder::build
RevoluteJoint3DRealBuilder
pub struct RevoluteJoint3DRealBuilder {
inner : GenericJoint3DRealBuilder
}
fn RevoluteJoint3DRealBuilder::RevoluteJoint3DRealBuilder(axis : Vec3) -> RevoluteJoint3DRealBuilderRevoluteJoint3DRealBuilder::build
RevoluteJoint3DRealBuilder::limits
fn RevoluteJoint3DRealBuilder::limits(self : RevoluteJoint3DRealBuilder, min : Float, max : Float) -> RevoluteJoint3DRealBuilderRevoluteJoint3DRealBuilder::local_anchor1
fn RevoluteJoint3DRealBuilder::local_anchor1(self : RevoluteJoint3DRealBuilder, a : Vec3) -> RevoluteJoint3DRealBuilderRevoluteJoint3DRealBuilder::local_anchor2
fn RevoluteJoint3DRealBuilder::local_anchor2(self : RevoluteJoint3DRealBuilder, a : Vec3) -> RevoluteJoint3DRealBuilderRevoluteJoint3DRealBuilder::motor_max_force
fn RevoluteJoint3DRealBuilder::motor_max_force(self : RevoluteJoint3DRealBuilder, max_force : Float) -> RevoluteJoint3DRealBuilderRevoluteJoint3DRealBuilder::motor_position
fn RevoluteJoint3DRealBuilder::motor_position(self : RevoluteJoint3DRealBuilder, target_pos : Float, stiffness : Float, damping : Float) -> RevoluteJoint3DRealBuilderRevoluteJoint3DRealBuilder::motor_velocity
fn RevoluteJoint3DRealBuilder::motor_velocity(self : RevoluteJoint3DRealBuilder, target_vel : Float, damping : Float) -> RevoluteJoint3DRealBuilderRevoluteJointBuilder
pub struct RevoluteJointBuilder {
// private fields
}
fn RevoluteJointBuilder::RevoluteJointBuilder() -> RevoluteJointBuilderRevoluteJointBuilder::build
RevoluteJointBuilder::limits
fn RevoluteJointBuilder::limits(self : RevoluteJointBuilder, min : Float, max : Float) -> RevoluteJointBuilderRevoluteJointBuilder::local_anchor1
fn RevoluteJointBuilder::local_anchor1(self : RevoluteJointBuilder, anchor : Vec2) -> RevoluteJointBuilderRevoluteJointBuilder::local_anchor2
fn RevoluteJointBuilder::local_anchor2(self : RevoluteJointBuilder, anchor : Vec2) -> RevoluteJointBuilderRevoluteJointBuilder::motor_max_force
fn RevoluteJointBuilder::motor_max_force(self : RevoluteJointBuilder, max_force : Float) -> RevoluteJointBuilderRevoluteJointBuilder::motor_model
fn RevoluteJointBuilder::motor_model(self : RevoluteJointBuilder, model : MotorModel) -> RevoluteJointBuilderRevoluteJointBuilder::motor_position
fn RevoluteJointBuilder::motor_position(self : RevoluteJointBuilder, target_pos : Float, stiffness : Float, damping : Float) -> RevoluteJointBuilderRevoluteJointBuilder::motor_velocity
fn RevoluteJointBuilder::motor_velocity(self : RevoluteJointBuilder, target_vel : Float, factor : Float) -> RevoluteJointBuilderRevoluteJointBuilder::softness
fn RevoluteJointBuilder::softness(self : RevoluteJointBuilder, softness : SpringCoefficients) -> RevoluteJointBuilderRevoluteJointBuilder3
pub struct RevoluteJointBuilder3 {
inner : RevoluteJointBuilder
axis : Vec3
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
}
fn RevoluteJointBuilder3::RevoluteJointBuilder3(axis : Vec3) -> RevoluteJointBuilder33D-flavored revolute joint builder used by the rapier3d parity tests.
RevoluteJointBuilder3::build
RevoluteJointBuilder3::limits
fn RevoluteJointBuilder3::limits(self : RevoluteJointBuilder3, min : Float, max : Float) -> RevoluteJointBuilder3RevoluteJointBuilder3::local_anchor1
fn RevoluteJointBuilder3::local_anchor1(self : RevoluteJointBuilder3, anchor1 : Vec3) -> RevoluteJointBuilder3RevoluteJointBuilder3::local_anchor2
fn RevoluteJointBuilder3::local_anchor2(self : RevoluteJointBuilder3, anchor2 : Vec3) -> RevoluteJointBuilder3RevoluteJointBuilder3::motor_max_force
fn RevoluteJointBuilder3::motor_max_force(self : RevoluteJointBuilder3, max_force : Float) -> RevoluteJointBuilder3RevoluteJointBuilder3::motor_model
fn RevoluteJointBuilder3::motor_model(self : RevoluteJointBuilder3, model : MotorModel) -> RevoluteJointBuilder3RevoluteJointBuilder3::motor_position
fn RevoluteJointBuilder3::motor_position(self : RevoluteJointBuilder3, target_pos : Float, stiffness : Float, damping : Float) -> RevoluteJointBuilder3RevoluteJointBuilder3::motor_velocity
fn RevoluteJointBuilder3::motor_velocity(self : RevoluteJointBuilder3, target_vel : Float, factor : Float) -> RevoluteJointBuilder3RevoluteJointBuilder3::softness
fn RevoluteJointBuilder3::softness(self : RevoluteJointBuilder3, softness : SpringCoefficients) -> RevoluteJointBuilder3RigidBody
pub struct RigidBody {
ids : RigidBodyIds
user_data : UserData128
position : RigidBodyPosition
body_type : RigidBodyType
locked_translations : Bool
locked_rotations : Bool
dominance : RigidBodyDominance
enabled : Bool
activation : RigidBodyActivation
damping : RigidBodyDamping
vels : RigidBodyVelocity
forces : RigidBodyForces
ccd : RigidBodyCcd
mass_props : RigidBodyMassProps
colliders : RigidBodyColliders
additional_mass : Float
additional_solver_iterations : Int
changes : RigidBodyChanges
}RigidBody::activation_mut
Rapier leaf-name shim: mutable accessor.
RigidBody::add_force
RigidBody::add_force_at_point
RigidBody::add_torque
RigidBody::additional_solver_iterations
RigidBody::angvel_with_gyroscopic_forces
Rapier 3D-only API, exposed as a no-op for pub parity on this 2D implementation.
RigidBody::apply_impulse
RigidBody::apply_impulse_at_point
RigidBody::apply_torque_impulse
RigidBody::attach_collider_raw
RigidBody::detach_collider_raw
RigidBody::effective_active_set_offset
RigidBody::effective_dominance_group
RigidBody::enable_gyroscopic_forces
Rapier 3D-only API, exposed as a no-op for pub parity on this 2D implementation.
RigidBody::gravitational_potential_energy
RigidBody::is_dynamic_or_kinematic
RigidBody::mark_local_mass_properties_changed
RigidBody::predict_position_using_velocity
RigidBody::predict_position_using_velocity_and_forces
RigidBody::recompute_mass_properties_from_colliders
RigidBody::reset_forces
RigidBody::reset_torques
RigidBody::restrict_rotations
RigidBody::restrict_translations
RigidBody::set_additional_mass
RigidBody::set_additional_mass_properties
fn RigidBody::set_additional_mass_properties(self : RigidBody, props : RigidBodyAdditionalMassProps, wake_up : Bool) -> RigidBodyRigidBody::set_additional_solver_iterations
RigidBody::set_angular_damping
RigidBody::set_angvel
RigidBody::set_body_type
fn RigidBody::set_body_type(self : RigidBody, body_type : RigidBodyType, wake_up : Bool) -> RigidBodyRigidBody::set_ccd_active
RigidBody::set_ccd_properties
RigidBody::set_dominance_group
RigidBody::set_enabled
RigidBody::set_enabled_rotations
RigidBody::set_enabled_translations
RigidBody::set_gravity_scale
RigidBody::set_kinematic_position_based_vels
fn RigidBody::set_kinematic_position_based_vels(self : RigidBody, vels : RigidBodyVelocity) -> RigidBodyRigidBody::set_linear_damping
RigidBody::set_linvel
RigidBody::set_local_mass_properties
RigidBody::set_locked_rotations
RigidBody::set_locked_translations
RigidBody::set_next_kinematic_position
RigidBody::set_next_kinematic_rotation
RigidBody::set_next_kinematic_translation
RigidBody::set_next_position_internal
RigidBody::set_position
RigidBody::set_rotation
RigidBody::set_soft_ccd_prediction
RigidBody::set_translation
RigidBody::set_user_data
RigidBody::set_user_data128
RigidBody::set_vels
RigidBody::update_effective_force_and_torque
Update the effective force/torque (gravity + accumulated user force/torque) stored on this body.
This matches Rapier's workflow where RigidBodyForces.force/torque are derived each step.
RigidBody::velocity_at_point
RigidBody3D
pub struct RigidBody3D {
body_type : RigidBodyType
user_data : UserData128
position : Isometry3
next_position : Isometry3
velocity : RigidBodyVelocity3D
locked_translations : Bool
trans_x_enabled : Bool
trans_y_enabled : Bool
trans_z_enabled : Bool
locked_rotations : Bool
rot_x_enabled : Bool
rot_y_enabled : Bool
rot_z_enabled : Bool
ccd_active : Bool
ccd_enabled : Bool
soft_ccd_prediction : Float
gyroscopic_forces_enabled : Bool
linear_damping : Float
angular_damping : Float
gravity_scale : Float
mass_properties : MassProperties3
additional_solver_iterations : Int
activation : RigidBodyActivation3D
can_sleep : Bool
dominance_group : Int
}RigidBody3D::additional_solver_iterations
RigidBody3D::advance_position
RigidBody3D::apply_damping
RigidBody3D::apply_gravity
RigidBody3D::apply_gyroscopic_forces
RigidBody3D::apply_impulse_at_point
fn RigidBody3D::apply_impulse_at_point(self : RigidBody3D, impulse : Vec3, point : Vec3, wake_up : Bool) -> UnitRigidBody3D::effective_dominance_group
RigidBody3D::gyroscopic_forces_enabled
RigidBody3D::integrate
RigidBody3D::locked_translations
RigidBody3D::mass_properties
RigidBody3D::restrict_rotations
fn RigidBody3D::restrict_rotations(self : RigidBody3D, allow_x : Bool, allow_y : Bool, allow_z : Bool, wake_up : Bool) -> UnitRigidBody3D::restrict_translations
fn RigidBody3D::restrict_translations(self : RigidBody3D, allow_x : Bool, allow_y : Bool, allow_z : Bool, wake_up : Bool) -> UnitRigidBody3D::set_additional_solver_iterations
fn RigidBody3D::set_additional_solver_iterations(self : RigidBody3D, additional_iterations : Int) -> UnitRigidBody3D::set_ccd_active
RigidBody3D::set_dominance_group
RigidBody3D::set_enabled_rotations
fn RigidBody3D::set_enabled_rotations(self : RigidBody3D, allow_x : Bool, allow_y : Bool, allow_z : Bool, wake_up : Bool) -> UnitRigidBody3D::set_enabled_translations
fn RigidBody3D::set_enabled_translations(self : RigidBody3D, allow_x : Bool, allow_y : Bool, allow_z : Bool, wake_up : Bool) -> UnitRigidBody3D::set_gravity_scale
RigidBody3D::set_locked_axes
fn RigidBody3D::set_locked_axes(self : RigidBody3D, locked_axes : LockedAxes, wake_up : Bool) -> UnitRigidBody3D::set_next_kinematic_rotation
RigidBody3D::set_next_kinematic_translation
RigidBody3D::set_translation
RigidBody3D::set_user_data
RigidBody3D::set_user_data128
RigidBody3D::soft_ccd_prediction
RigidBody3D::update_kinematic_velocities
RigidBody3D::update_sleep
RigidBodyActivation
pub struct RigidBodyActivation {
normalized_linear_threshold : Float
angular_threshold : Float
time_until_sleep : Float
time_since_can_sleep : Float
sleeping : Bool
sleep_root_state : SleepRootState
}RigidBodyActivation::cannot_sleep
RigidBodyActivation::default_angular_threshold
RigidBodyActivation::default_normalized_linear_threshold
RigidBodyActivation::default_time_until_sleep
RigidBodyActivation::is_active
RigidBodyActivation::is_eligible_for_sleep
RigidBodyActivation::sleep
RigidBodyActivation::update_energy
fn RigidBodyActivation::update_energy(self : RigidBodyActivation, body_type : RigidBodyType, length_unit : Float, sq_linvel : Float, sq_angvel : Float, dt : Float) -> RigidBodyActivationRigidBodyActivation::wake_up
RigidBodyActivation3D
pub struct RigidBodyActivation3D {
normalized_linear_threshold : Float
angular_threshold : Float
time_until_sleep : Float
time_since_can_sleep : Float
sleeping : Bool
}RigidBodyActivation3D::is_sleeping
RigidBodyActivation3D::update
fn RigidBodyActivation3D::update(self : RigidBodyActivation3D, dt : Float, length_unit : Float, body_type : RigidBodyType, vels : RigidBodyVelocity3D) -> RigidBodyActivation3DRigidBodyActivation3D::wake_up
RigidBodyAdditionalMassProps
pub enum RigidBodyAdditionalMassProps {
Mass(Float)
MassProps(MassProperties)
MassProperties(MassProperties)
}Rapier-style additional mass-properties.
RigidBodyAdditionalMassProps::mass
RigidBodyAdditionalMassProps::mass_properties
fn RigidBodyAdditionalMassProps::mass_properties(mass_properties : MassProperties) -> RigidBodyAdditionalMassPropsRigidBodyAdditionalMassProps::mass_props
fn RigidBodyAdditionalMassProps::mass_props(mass_props : MassProperties) -> RigidBodyAdditionalMassPropsRigidBodyBuilder
pub struct RigidBodyBuilder {
position : Isometry2
linvel : Vec2
angvel : Float
gravity_scale : Float
linear_damping : Float
angular_damping : Float
body_type : RigidBodyType
lock_translations : Bool
lock_rotations : Bool
additional_mass : Float
additional_local_mprops : MassProperties
additional_solver_iterations : Int
can_sleep : Bool
sleeping : Bool
enabled : Bool
ccd_enabled : Bool
soft_ccd_prediction : Float
dominance_group : Int
user_data : UserData128
}
fn RigidBodyBuilder::RigidBodyBuilder(body_type : RigidBodyType) -> RigidBodyBuilderRigidBodyBuilder::additional_mass
RigidBodyBuilder::additional_mass_properties
fn RigidBodyBuilder::additional_mass_properties(self : RigidBodyBuilder, props : RigidBodyAdditionalMassProps) -> RigidBodyBuilderRigidBodyBuilder::additional_solver_iterations
fn RigidBodyBuilder::additional_solver_iterations(self : RigidBodyBuilder, additional_iterations : Int) -> RigidBodyBuilderRigidBodyBuilder::angular_damping
RigidBodyBuilder::angvel
RigidBodyBuilder::can_sleep
RigidBodyBuilder::ccd_enabled
RigidBodyBuilder::dominance_group
RigidBodyBuilder::enabled
RigidBodyBuilder::enabled_translations
fn RigidBodyBuilder::enabled_translations(self : RigidBodyBuilder, allow_x : Bool, allow_y : Bool, allow_z : Bool) -> RigidBodyBuilderRigidBodyBuilder::gravity_scale
RigidBodyBuilder::kinematic_position_based
RigidBodyBuilder::kinematic_velocity_based
RigidBodyBuilder::linear_damping
RigidBodyBuilder::linvel
RigidBodyBuilder::lock_rotations
RigidBodyBuilder::lock_translations
RigidBodyBuilder::new_kinematic_position_based
RigidBodyBuilder::new_kinematic_velocity_based
RigidBodyBuilder::new_static
Rapier leaf-name shims.
RigidBodyBuilder::pose
RigidBodyBuilder::position
RigidBodyBuilder::restrict_rotations
fn RigidBodyBuilder::restrict_rotations(self : RigidBodyBuilder, allow_x : Bool, allow_y : Bool, allow_z : Bool) -> RigidBodyBuilderRigidBodyBuilder::restrict_translations
fn RigidBodyBuilder::restrict_translations(self : RigidBodyBuilder, allow_x : Bool, allow_y : Bool, allow_z : Bool) -> RigidBodyBuilderRigidBodyBuilder::rotation
RigidBodyBuilder::sleeping
RigidBodyBuilder::soft_ccd_prediction
fn RigidBodyBuilder::soft_ccd_prediction(self : RigidBodyBuilder, prediction_distance : Float) -> RigidBodyBuilderRigidBodyBuilder::translation
RigidBodyBuilder::user_data
RigidBodyBuilder::user_data128
RigidBodyBuilder3D
#alias(RigidBodyBuilder3Compat)
#alias(RigidBodyBuilder3)
pub struct RigidBodyBuilder3D {
body_type : RigidBodyType
translation : Vec3
rotation : Quat
linvel : Vec3
angvel : Vec3
locked_translations : Bool
trans_x_enabled : Bool
trans_y_enabled : Bool
trans_z_enabled : Bool
locked_rotations : Bool
rot_x_enabled : Bool
rot_y_enabled : Bool
rot_z_enabled : Bool
ccd_enabled : Bool
soft_ccd_prediction : Float
gyroscopic_forces_enabled : Bool
linear_damping : Float
angular_damping : Float
gravity_scale : Float
mass_properties : MassProperties3
additional_solver_iterations : Int
can_sleep : Bool
sleeping : Bool
user_data : UserData128
dominance_group : Int
}RigidBodyBuilder3D::additional_mass
fn RigidBodyBuilder3D::additional_mass(self : RigidBodyBuilder3D, mass : Float) -> RigidBodyBuilder3DRigidBodyBuilder3D::additional_mass_properties
fn RigidBodyBuilder3D::additional_mass_properties(self : RigidBodyBuilder3D, props : MassProperties3) -> RigidBodyBuilder3DRigidBodyBuilder3D::additional_solver_iterations
fn RigidBodyBuilder3D::additional_solver_iterations(self : RigidBodyBuilder3D, additional_iterations : Int) -> RigidBodyBuilder3DRigidBodyBuilder3D::angular_damping
fn RigidBodyBuilder3D::angular_damping(self : RigidBodyBuilder3D, damping : Float) -> RigidBodyBuilder3DRigidBodyBuilder3D::angvel
RigidBodyBuilder3D::build
RigidBodyBuilder3D::can_sleep
RigidBodyBuilder3D::ccd_enabled
RigidBodyBuilder3D::dominance_group
fn RigidBodyBuilder3D::dominance_group(self : RigidBodyBuilder3D, group : Int) -> RigidBodyBuilder3DRigidBodyBuilder3D::enabled_rotations
fn RigidBodyBuilder3D::enabled_rotations(self : RigidBodyBuilder3D, x : Bool, y : Bool, z : Bool) -> RigidBodyBuilder3DRigidBodyBuilder3D::enabled_translations
fn RigidBodyBuilder3D::enabled_translations(self : RigidBodyBuilder3D, x : Bool, y : Bool, z : Bool) -> RigidBodyBuilder3DRigidBodyBuilder3D::gravity_scale
fn RigidBodyBuilder3D::gravity_scale(self : RigidBodyBuilder3D, scale : Float) -> RigidBodyBuilder3DRigidBodyBuilder3D::gyroscopic_forces_enabled
fn RigidBodyBuilder3D::gyroscopic_forces_enabled(self : RigidBodyBuilder3D, enabled : Bool) -> RigidBodyBuilder3DRigidBodyBuilder3D::kinematic_position_based
RigidBodyBuilder3D::kinematic_velocity_based
RigidBodyBuilder3D::linear_damping
fn RigidBodyBuilder3D::linear_damping(self : RigidBodyBuilder3D, damping : Float) -> RigidBodyBuilder3DRigidBodyBuilder3D::linvel
RigidBodyBuilder3D::lock_rotations
RigidBodyBuilder3D::lock_translations
RigidBodyBuilder3D::locked_axes
fn RigidBodyBuilder3D::locked_axes(self : RigidBodyBuilder3D, locked_axes : LockedAxes) -> RigidBodyBuilder3DRigidBodyBuilder3D::mass_properties
fn RigidBodyBuilder3D::mass_properties(self : RigidBodyBuilder3D, props : MassProperties3) -> RigidBodyBuilder3DRigidBodyBuilder3D::new_kinematic_position_based
RigidBodyBuilder3D::new_kinematic_velocity_based
RigidBodyBuilder3D::pose
RigidBodyBuilder3D::position
RigidBodyBuilder3D::restrict_rotations
fn RigidBodyBuilder3D::restrict_rotations(self : RigidBodyBuilder3D, x : Bool, y : Bool, z : Bool) -> RigidBodyBuilder3DRigidBodyBuilder3D::restrict_translations
fn RigidBodyBuilder3D::restrict_translations(self : RigidBodyBuilder3D, x : Bool, y : Bool, z : Bool) -> RigidBodyBuilder3DRigidBodyBuilder3D::rotation
RigidBodyBuilder3D::rotation_scaled_axis
fn RigidBodyBuilder3D::rotation_scaled_axis(self : RigidBodyBuilder3D, scaled_axis : Vec3) -> RigidBodyBuilder3DRigidBodyBuilder3D::sleeping
RigidBodyBuilder3D::soft_ccd_prediction
fn RigidBodyBuilder3D::soft_ccd_prediction(self : RigidBodyBuilder3D, prediction : Float) -> RigidBodyBuilder3DRigidBodyBuilder3D::translation
RigidBodyBuilder3D::user_data
RigidBodyBuilder3D::user_data128
fn RigidBodyBuilder3D::user_data128(self : RigidBodyBuilder3D, data : UserData128) -> RigidBodyBuilder3DRigidBodyCcd
pub struct RigidBodyCcd {
ccd_thickness : Float
ccd_max_dist : Float
ccd_active : Bool
ccd_enabled : Bool
soft_ccd_prediction : Float
}RigidBodyCcd::is_moving_fast
fn RigidBodyCcd::is_moving_fast(self : RigidBodyCcd, dt : Float, vels : RigidBodyVelocity, forces : RigidBodyForces?) -> BoolRigidBodyCcd::max_point_velocity
RigidBodyChanges
pub struct RigidBodyChanges {
bits : Int
}RigidBodyChanges::contains
RigidBodyChanges::insert
RigidBodyChanges::remove
RigidBodyChanges::sleep_flag
Flag value helpers used by the pub-parity audit mapping.
RigidBodyColliders
pub struct RigidBodyColliders {
colliders : Array[(Int, Int)]
}
fn RigidBodyColliders::RigidBodyColliders() -> RigidBodyCollidersPublic-surface parity for Rapier's RigidBodyColliders component.
We store collider handles as (id, generation) raw parts so this package stays
independent from collision::ColliderHandle while preserving full handle identity.
RigidBodyColliders::attach_collider
fn RigidBodyColliders::attach_collider(self : RigidBodyColliders, handle : Int) -> RigidBodyCollidersBackward-compatible helper that attaches a raw collider id with generation 0.
RigidBodyColliders::attach_collider_raw
fn RigidBodyColliders::attach_collider_raw(self : RigidBodyColliders, id : Int, generation : Int) -> RigidBodyCollidersRigidBodyColliders::detach_collider
fn RigidBodyColliders::detach_collider(self : RigidBodyColliders, handle : Int) -> RigidBodyCollidersBackward-compatible helper that detaches a raw collider id with generation 0.
RigidBodyColliders::detach_collider_raw
fn RigidBodyColliders::detach_collider_raw(self : RigidBodyColliders, id : Int, generation : Int) -> RigidBodyCollidersRigidBodyColliders::handles
RigidBodyDamping
pub struct RigidBodyDamping {
linear_damping : Float
angular_damping : Float
}RigidBodyDominance
pub struct RigidBodyDominance {
group : Int
}
fn RigidBodyDominance::RigidBodyDominance(group : Int) -> RigidBodyDominanceRigidBodyDominance::effective_group
RigidBodyForces
RigidBodyForces::apply_force_at_point
fn RigidBodyForces::apply_force_at_point(self : RigidBodyForces, rb_mprops : RigidBodyMassProps, force : Vec2, point : Vec2) -> RigidBodyForcesRigidBodyForces::compute_effective_force_and_torque
fn RigidBodyForces::compute_effective_force_and_torque(self : RigidBodyForces, gravity : Vec2, mass : Vec2) -> RigidBodyForcesRigidBodyForces::integrate
fn RigidBodyForces::integrate(self : RigidBodyForces, dt : Float, init_vels : RigidBodyVelocity, mprops : RigidBodyMassProps) -> RigidBodyVelocityRigidBodyHandle
pub struct RigidBodyHandle {
id : Int
generation : Int
}RigidBodyHandle::equals
RigidBodyHandle::from_raw_parts
RigidBodyHandle::into_raw_parts
RigidBodyIds
pub struct RigidBodyIds {
active_island_id : Int
active_set_id : Int
active_set_timestamp : Int
}RigidBodyMassProps
pub struct RigidBodyMassProps {
world_com : Vec2
effective_inv_mass : Vec2
effective_world_inv_inertia : Float
collider_local_mprops : MassProperties
local_mprops : MassProperties
additional_local_mprops : MassProperties
}RigidBodyMassProps::effective_angular_inertia
RigidBodyMassProps::effective_mass
RigidBodyMassProps::recompute_mass_properties_from_colliders
fn RigidBodyMassProps::recompute_mass_properties_from_colliders(self : RigidBodyMassProps) -> RigidBodyMassPropsPlaceholder for pub parity with Rapier.
This port currently recomputes mass-properties from colliders at a higher level.
RigidBodyMassProps::set_effective_inv_mass
fn RigidBodyMassProps::set_effective_inv_mass(self : RigidBodyMassProps, inv_mass : Vec2) -> RigidBodyMassPropsRigidBodyMassProps::set_effective_world_inv_inertia
fn RigidBodyMassProps::set_effective_world_inv_inertia(self : RigidBodyMassProps, inv_inertia : Float) -> RigidBodyMassPropsRigidBodyMassProps::update_world_mass_properties
fn RigidBodyMassProps::update_world_mass_properties(self : RigidBodyMassProps, body_type : RigidBodyType, position : Isometry2) -> RigidBodyMassPropsRigidBodyPosition
pub struct RigidBodyPosition {
position : Isometry2
next_position : Isometry2
}
fn RigidBodyPosition::RigidBodyPosition(position : Isometry2, next_position : Isometry2) -> RigidBodyPositionRigidBodyPosition::integrate_forces_and_velocities
fn RigidBodyPosition::integrate_forces_and_velocities(self : RigidBodyPosition, dt : Float, forces : RigidBodyForces, vels : RigidBodyVelocity, mprops : RigidBodyMassProps) -> Isometry2RigidBodyPosition::interpolate_velocity
fn RigidBodyPosition::interpolate_velocity(self : RigidBodyPosition, inv_dt : Float, local_com : Vec2) -> RigidBodyVelocityRigidBodyPosition3
pub struct RigidBodyPosition3 {
position : Isometry3
next_position : Isometry3
}
fn RigidBodyPosition3::RigidBodyPosition3(position : Isometry3, next_position : Isometry3) -> RigidBodyPosition3RigidBodyPosition3::interpolate_velocity
fn RigidBodyPosition3::interpolate_velocity(self : RigidBodyPosition3, inv_dt : Float, local_com : Vec3) -> RigidBodyVelocity3Computes the velocity needed to travel from position to next_position in a time 1.0 / inv_dt.
RigidBodyPosition3::pose_errors
Computes the difference between next_position and position, expressed at the center of mass.
RigidBodyPosition3D
pub struct RigidBodyPosition3D {
position : Isometry3
next_position : Isometry3
}
fn RigidBodyPosition3D::RigidBodyPosition3D(position : Isometry3, next_position : Isometry3) -> RigidBodyPosition3D3D rigid-body position state with interpolation support.
RigidBodyPosition3D::interpolate_velocity
fn RigidBodyPosition3D::interpolate_velocity(self : RigidBodyPosition3D, inv_dt : Float, local_com : Vec3) -> RigidBodyVelocity3DRigidBodySet
pub struct RigidBodySet {
bodies : Array[RigidBody?]
generations : Array[Int]
free_list : Array[Int]
modified_bodies : Array[RigidBodyHandle]
pending_collider_position_updates : Array[(Int, Int, Isometry2)]
}
fn RigidBodySet::RigidBodySet() -> RigidBodySetRigidBodySet::contains
RigidBodySet::get
RigidBodySet::get_mut
RigidBodySet::get_mut_internal
RigidBodySet::get_mut_internal_with_modification_tracking
fn RigidBodySet::get_mut_internal_with_modification_tracking(self : RigidBodySet, handle : RigidBodyHandle) -> RigidBody?RigidBodySet::get_pair_mut
fn RigidBodySet::get_pair_mut(self : RigidBodySet, handle1 : RigidBodyHandle, handle2 : RigidBodyHandle) -> (RigidBody?, RigidBody?)RigidBodySet::get_unknown_gen
RigidBodySet::get_unknown_gen_mut
fn RigidBodySet::get_unknown_gen_mut(self : RigidBodySet, id : Int) -> (RigidBody, RigidBodyHandle)?RigidBodySet::insert
RigidBodySet::iter
RigidBodySet::iter_mut
RigidBodySet::propagate_modified_body_positions_to_colliders
Queue collider position propagation commands for all modified bodies whose position changed.
Because dynamics cannot depend on collision, this method records propagation commands
that can later be consumed by collision through
RigidBodySet::take_pending_collider_position_updates.
RigidBodySet::remove
fn RigidBodySet::remove(self : RigidBodySet, handle : RigidBodyHandle, islands : IslandManager, colliders : Unit, impulse_joints : ImpulseJointSet, multibody_joints : MultibodyJointSet, remove_attached_colliders : Bool) -> RigidBody?RigidBodySet::take_modified
RigidBodySet::take_pending_collider_position_updates
fn RigidBodySet::take_pending_collider_position_updates(self : RigidBodySet) -> Array[(Int, Int, Isometry2)]RigidBodySet3
3D-flavored rigid-body set.
RigidBodySet3::get
RigidBodySet3::get_mut
RigidBodySet3::insert
RigidBodySet3::iter
RigidBodySet3::iter_mut
RigidBodySet3::remove
fn RigidBodySet3::remove(self : RigidBodySet3, handle : RigidBodyHandle, islands : IslandManager3, colliders : Unit, impulse_joints : ImpulseJointSet3, multibody_joints : MultibodyJointSet3, wake_up : Bool) -> RigidBody?RigidBodySet3::rotation
RigidBodySet3::take_modified
RigidBodySet3::translation
RigidBodySet3D
pub struct RigidBodySet3D {
bodies : Array[RigidBody3D?]
generations : Array[Int]
free_list : Array[Int]
}
fn RigidBodySet3D::RigidBodySet3D() -> RigidBodySet3DRigidBodySet3D::advance_positions_all
RigidBodySet3D::all_handles
RigidBodySet3D::apply_damping_all
RigidBodySet3D::apply_gravity_all
RigidBodySet3D::apply_gyroscopic_forces_all
RigidBodySet3D::get
RigidBodySet3D::get_mut
RigidBodySet3D::has_ccd_enabled
RigidBodySet3D::insert
RigidBodySet3D::integrate_all
RigidBodySet3D::max_linvel_len
RigidBodySet3D::remove
RigidBodySet3D::update_kinematic_velocities_all
RigidBodySet3D::update_sleep_all
RigidBodyType
#alias(BodyStatus)
pub(all) enum RigidBodyType {
Dynamic
Fixed
KinematicPositionBased
KinematicVelocityBased
}RigidBodyType::is_dynamic_or_kinematic
RigidBodyVelocity
pub struct RigidBodyVelocity {
linvel : Vec2
angvel : Float
}
fn RigidBodyVelocity::RigidBodyVelocity(linvel : Vec2, angvel : Float) -> RigidBodyVelocityRigidBodyVelocity::apply_damping
fn RigidBodyVelocity::apply_damping(self : RigidBodyVelocity, dt : Float, damping : RigidBodyDamping) -> RigidBodyVelocityRigidBodyVelocity::as_mut_slice
RigidBodyVelocity::as_slice
RigidBodyVelocity::as_vector_mut
RigidBodyVelocity::from_slice
RigidBodyVelocity::integrate
fn RigidBodyVelocity::integrate(self : RigidBodyVelocity, dt : Float, curr_pos : Isometry2, local_com : Vec2) -> Isometry2RigidBodyVelocity::kinetic_energy
fn RigidBodyVelocity::kinetic_energy(self : RigidBodyVelocity, rb_mprops : RigidBodyMassProps) -> FloatRigidBodyVelocity::pseudo_kinetic_energy
RigidBodyVelocity::transformed
RigidBodyVelocity::velocity_at_point
fn RigidBodyVelocity::velocity_at_point(self : RigidBodyVelocity, point : Vec2, world_com : Vec2) -> Vec2RigidBodyVelocity3
RigidBodyVelocity3::integrate
fn RigidBodyVelocity3::integrate(self : RigidBodyVelocity3, dt : Float, curr_pos : Isometry3, local_com : Vec3) -> Isometry3RigidBodyVelocity3D
3D rigid-body velocity: linear and angular.
RigidBodyVelocity3D::apply_damping
fn RigidBodyVelocity3D::apply_damping(self : RigidBodyVelocity3D, dt : Float, linear_damping : Float, angular_damping : Float) -> RigidBodyVelocity3DRigidBodyVelocity3D::integrate
fn RigidBodyVelocity3D::integrate(self : RigidBodyVelocity3D, dt : Float, curr_pos : Isometry3, local_com : Vec3) -> Isometry3RopeJoint
pub struct RopeJoint {
max_length : Float
local_anchor1 : Vec2
local_anchor2 : Vec2
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
is_spatial : Bool
softness : SpringCoefficients
motor : JointMotor
motor_enabled : Bool
}
fn RopeJoint::RopeJoint(max_length : Float) -> RopeJointRopeJoint::set_max_distance
RopeJoint3DReal
RopeJointBuilder
pub struct RopeJointBuilder {
max_length : Float
local_anchor1 : Vec2
local_anchor2 : Vec2
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
is_spatial : Bool
softness : SpringCoefficients
motor : JointMotor
motor_enabled : Bool
}
fn RopeJointBuilder::RopeJointBuilder(max_length : Float) -> RopeJointBuilderRopeJointBuilder::local_anchor1
RopeJointBuilder::local_anchor2
RopeJointBuilder::max_distance
RopeJointBuilder::motor_max_force
fn RopeJointBuilder::motor_max_force(self : RopeJointBuilder, max_force : Float) -> RopeJointBuilderRopeJointBuilder::motor_model
RopeJointBuilder::motor_position
fn RopeJointBuilder::motor_position(self : RopeJointBuilder, target_pos : Float, stiffness : Float, damping : Float) -> RopeJointBuilderRopeJointBuilder::motor_velocity
fn RopeJointBuilder::motor_velocity(self : RopeJointBuilder, target_vel : Float, factor : Float) -> RopeJointBuilderRopeJointBuilder::softness
fn RopeJointBuilder::softness(self : RopeJointBuilder, softness : SpringCoefficients) -> RopeJointBuilderRopeJointBuilder3
pub struct RopeJointBuilder3 {
inner : RopeJointBuilder
local_anchor1_3 : Vec3
local_anchor2_3 : Vec3
}
fn RopeJointBuilder3::RopeJointBuilder3(max_length : Float) -> RopeJointBuilder33D-flavored rope joint builder used by the rapier3d parity tests.
NOTE: This maps to the existing 2D rope joint builder by dropping the z coordinate.
RopeJointBuilder3::local_anchor1
RopeJointBuilder3::local_anchor2
RopeJointBuilder3::max_distance
fn RopeJointBuilder3::max_distance(self : RopeJointBuilder3, max_distance : Float) -> RopeJointBuilder3RopeJointBuilder3::motor_max_force
fn RopeJointBuilder3::motor_max_force(self : RopeJointBuilder3, max_force : Float) -> RopeJointBuilder3RopeJointBuilder3::motor_model
fn RopeJointBuilder3::motor_model(self : RopeJointBuilder3, model : MotorModel) -> RopeJointBuilder3RopeJointBuilder3::motor_position
fn RopeJointBuilder3::motor_position(self : RopeJointBuilder3, target_pos : Float, stiffness : Float, damping : Float) -> RopeJointBuilder3RopeJointBuilder3::motor_velocity
fn RopeJointBuilder3::motor_velocity(self : RopeJointBuilder3, target_vel : Float, factor : Float) -> RopeJointBuilder3RopeJointBuilder3::softness
fn RopeJointBuilder3::softness(self : RopeJointBuilder3, softness : SpringCoefficients) -> RopeJointBuilder3RopeJointSet3DReal
pub struct RopeJointSet3DReal {
joints : Array[RopeJoint3DReal]
}
fn RopeJointSet3DReal::RopeJointSet3DReal() -> RopeJointSet3DRealRopeJointSet3DReal::insert
fn RopeJointSet3DReal::insert(self : RopeJointSet3DReal, body1 : RigidBodyHandle, body2 : RigidBodyHandle, max_length : Float) -> UnitRopeJointSet3DReal::interaction_pairs
fn RopeJointSet3DReal::interaction_pairs(self : RopeJointSet3DReal) -> Array[(RigidBodyHandle, RigidBodyHandle)]RopeJointSet3DReal::solve
fn RopeJointSet3DReal::solve(self : RopeJointSet3DReal, bodies : RigidBodySet3D, dt : Float) -> UnitRopeJointSet3DReal::solve_with_island_stamp
fn RopeJointSet3DReal::solve_with_island_stamp(self : RopeJointSet3DReal, bodies : RigidBodySet3D, dt : Float, island_stamps : Array[Int]?, island_stamp : Int) -> UnitRowDVector
type RowDVectorSphericalJoint3DReal
pub struct SphericalJoint3DReal {
body1 : RigidBodyHandle
body2 : RigidBodyHandle
local_anchor1 : Vec3
local_anchor2 : Vec3
}Joint constraints for the real dim3 backend.
This is intentionally much smaller than Rapier's impulse-based joint solver and is used to
migrate 3D scenes to the PhysicsPipeline3DReal backend incrementally.
SphericalJoint3DRealBuilder
pub struct SphericalJoint3DRealBuilder {
inner : GenericJoint3DRealBuilder
}
fn SphericalJoint3DRealBuilder::SphericalJoint3DRealBuilder() -> SphericalJoint3DRealBuilderSphericalJoint3DRealBuilder::build
SphericalJoint3DRealBuilder::limits
fn SphericalJoint3DRealBuilder::limits(self : SphericalJoint3DRealBuilder, axis : JointAxis3DReal, min : Float, max : Float) -> SphericalJoint3DRealBuilderSphericalJoint3DRealBuilder::local_anchor1
fn SphericalJoint3DRealBuilder::local_anchor1(self : SphericalJoint3DRealBuilder, a : Vec3) -> SphericalJoint3DRealBuilderSphericalJoint3DRealBuilder::local_anchor2
fn SphericalJoint3DRealBuilder::local_anchor2(self : SphericalJoint3DRealBuilder, a : Vec3) -> SphericalJoint3DRealBuilderSphericalJoint3DRealBuilder::motor_max_force
fn SphericalJoint3DRealBuilder::motor_max_force(self : SphericalJoint3DRealBuilder, axis : JointAxis3DReal, max_force : Float) -> SphericalJoint3DRealBuilderSphericalJoint3DRealBuilder::motor_position
fn SphericalJoint3DRealBuilder::motor_position(self : SphericalJoint3DRealBuilder, axis : JointAxis3DReal, target_pos : Float, stiffness : Float, damping : Float) -> SphericalJoint3DRealBuilderSphericalJoint3DRealBuilder::motor_velocity
fn SphericalJoint3DRealBuilder::motor_velocity(self : SphericalJoint3DRealBuilder, axis : JointAxis3DReal, target_vel : Float, damping : Float) -> SphericalJoint3DRealBuilderSphericalMotor3DReal
pub struct SphericalMotor3DReal {
body1 : RigidBodyHandle
body2 : RigidBodyHandle
target_rel_rotation : Quat
stiffness : Float
damping : Float
}SpringCoefficients
pub struct SpringCoefficients {
natural_frequency : Float
damping_ratio : Float
}
fn SpringCoefficients::SpringCoefficients(natural_frequency : Float, damping_ratio : Float) -> SpringCoefficientsSpringCoefficients::angular_frequency
SpringCoefficients::cfm_coeff
SpringCoefficients::cfm_factor
SpringCoefficients::contact_defaults
SpringCoefficients::erp
SpringCoefficients::erp_inv_dt
SpringCoefficients::joint_defaults
SpringJoint
pub struct SpringJoint {
data : GenericJoint
}
fn SpringJoint::SpringJoint(rest_length : Float, stiffness : Float, damping : Float) -> SpringJointA spring joint that pulls/pushes two bodies toward a target distance.
This is a thin wrapper around GenericJoint, matching Rapier's public surface
(capability-wise) for default features.
SpringJoint::set_contacts_enabled
SpringJoint::set_local_anchor1
SpringJoint::set_local_anchor2
SpringJoint::set_spring_model
SpringJoint3DReal
pub struct SpringJoint3DReal {
body1 : RigidBodyHandle
body2 : RigidBodyHandle
local_anchor1 : Vec3
local_anchor2 : Vec3
rest_length : Float
stiffness : Float
damping : Float
}SpringJointBuilder
pub struct SpringJointBuilder {
inner : SpringJoint
}
fn SpringJointBuilder::SpringJointBuilder(rest_length : Float, stiffness : Float, damping : Float) -> SpringJointBuilderSpringJointBuilder::build
SpringJointBuilder::contacts_enabled
fn SpringJointBuilder::contacts_enabled(self : SpringJointBuilder, enabled : Bool) -> SpringJointBuilderSpringJointBuilder::local_anchor1
fn SpringJointBuilder::local_anchor1(self : SpringJointBuilder, anchor : Vec2) -> SpringJointBuilderSpringJointBuilder::local_anchor2
fn SpringJointBuilder::local_anchor2(self : SpringJointBuilder, anchor : Vec2) -> SpringJointBuilderSpringJointBuilder::spring_model
fn SpringJointBuilder::spring_model(self : SpringJointBuilder, model : MotorModel) -> SpringJointBuilderWritebackId
pub(all) enum WritebackId {
Dof(Int)
Limit(Int)
Motor(Int)
}Identifies the kind of impulse to write back for a joint constraint.
unit_joint_limit_constraint
fn unit_joint_limit_constraint(params : IntegrationParameters, multibody : Multibody, link : MultibodyLink, limits : (Float, Float), curr_pos : Float, dof_id : Int, j_id : Int, jacobians : DVector, constraints : Array[GenericJointConstraint], insert_at : Int) -> UnitInitialize and generate velocity constraints applicable to a unit (1-DOF) joint limit.
unit_joint_motor_constraint
fn unit_joint_motor_constraint(params : IntegrationParameters, multibody : Multibody, link : MultibodyLink, motor : JointMotor, curr_pos : Float, limits : (Float, Float)?, dof_id : Int, j_id : Int, jacobians : DVector, constraints : Array[GenericJointConstraint], insert_at : Int) -> UnitInitialize and generate velocity constraints applicable to a unit (1-DOF) joint motor.
Source Files
- axes_mask.mbt
- ccd_solver.mbt
- coefficient_combine_rule.mbt
- integration_parameters.mbt
- interaction_groups.mbt
- island_manager3d.mbt
- joint_builders.mbt
- joint_builders3d_real.mbt
- joint_constraint_pub_parity.mbt
- joint_set3d_real.mbt
- joint_types.mbt
- joint_types3d_real.mbt
- joint_wrappers3d_real.mbt
- joints3.mbt
- linear_algebra.mbt
- locked_axes.mbt
- multibody.mbt
- multibody_joint_pub_parity.mbt
- placeholders.mbt
- prismatic_joint_builder3.mbt
- revolute_joint3.mbt
- revolute_joint_builder3.mbt
- rigid_body.mbt
- rigid_body3d.mbt
- rigid_body_builder3.mbt
- rigid_body_colliders_pub_parity.mbt
- rigid_body_components3.mbt
- rigid_body_set_pub_parity.mbt
- rope_joint3d_real.mbt
- rope_joint_builder3.mbt
- sets3.mbt
- spec.mbt
- spring_joint.mbt
Install
Download zipA Physics library in MoonBit.
physics
Apache-2.0
Updated 4 months ago
14K downloads