Struct JointMotor 

pub struct JointMotor {
    pub target_vel: f32,
    pub target_pos: f32,
    pub stiffness: f32,
    pub damping: f32,
    pub max_force: f32,
    pub impulse: f32,
    pub model: MotorModel,
}

A powered motor that drives a joint toward a target position/velocity.

Motors add actuation to joints - they apply forces to make the joint move toward a desired state. Think of them as servos, electric motors, or hydraulic actuators.

Two control modes

1. Velocity control: Set target_vel to make the motor spin/slide at constant speed
2. Position control: Set target_pos with stiffness/damping to reach a target angle/position

You can combine both for precise control.

Parameters

• stiffness: How strongly to pull toward target (spring constant)
• damping: Resistance to motion (prevents oscillation)
• max_force: Maximum force/torque the motor can apply

Example

// Motor that spins a wheel at 10 rad/s
revolute_joint.set_motor_velocity(10.0, 0.8);

// Motor that moves to position 5.0
prismatic_joint.set_motor_position(5.0, 100.0, 10.0);  // stiffness=100, damping=10

Fields

target_vel: f32

Target velocity (units/sec for prismatic, rad/sec for revolute).

target_pos: f32

Target position (units for prismatic, radians for revolute).

stiffness: f32

Spring constant - how strongly to pull toward target position.

damping: f32

Damping coefficient - resistance to motion (prevents oscillation).

max_force: f32

Maximum force the motor can apply (Newtons for prismatic, Nm for revolute).

impulse: f32

Internal: current impulse being applied.

model: MotorModel

Force-based or acceleration-based motor model.

Trait Implementations

impl Clone for JointMotor

fn clone(&self) -> JointMotor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JointMotor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for JointMotor

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for JointMotor

fn eq(&self, other: &JointMotor) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for JointMotor

impl StructuralPartialEq for JointMotor