Angular Motor

Standalone 1-DOF angular velocity drive around an axis, with a torque-bounded impulse. Used without any other rotational constraint to spin one body relative to another (e.g. a turret, a powered wheel around a hinge-free axis).

Same row shape as the hinge motor in hinge_axis.md, but used on its own (not composed into a hinge). No alignment, no limit -- just a velocity target with a cap.

Setup

• a -- world-frame axis to spin around (attached to one of the bodies, or shared after alignment)
• v_target -- desired scalar angular velocity (wB - wA) . a
• T_max -- maximum torque the motor can apply; impulse cap per step is T_max * dt

Derivation

Relative angular velocity projected onto a:

C* = a . (wB - wA) = -a . wA + a . wB

Jacobian:

J = [0, -a, 0, a]

Bias and bounds are the only thing that differ from a plain 1-DOF equality row:

b = -v_target
lo = -T_max * dt
hi = +T_max * dt

Effective Mass

Scalar:

A = a . (IA^-1 + IB^-1) . a

Impulse Application

Angular only:

wA <- wA - Δλ * IA^-1 . a
wB <- wB + Δλ * IB^-1 . a

Example Code

Angular motor joint

typedef struct AngularMotorJoint
{
      Body *A, *B;
      v3 a;
      float v_target;
      float T_max;
      Row row;
} AngularMotorJoint;

static void angular_motor_setup(AngularMotorJoint *j, World *w, float beta, float dt)
{
      // Refresh j->a (if attached to a body) from orientation (not shown).
      Setup s = { w, j->A, j->B, (v3){0,0,0}, (v3){0,0,0}, beta, dt };

      Row *r = &j->row;
      r->A = s.A;  r->B = s.B;
      r->JvA = (v3){0,0,0};
      r->JwA = neg(j->a);
      r->JvB = (v3){0,0,0};
      r->JwB = j->a;
      m3 I_sum = add(s.A->inv_I, s.B->inv_I);
      r->inv_A = 1.0f / dot(j->a, mul(I_sum, j->a));
      r->bias  = -j->v_target;
      float cap = j->T_max * dt;
      r->lo = -cap;
      r->hi = cap;
      push_row(&s, r);
}

Hook into world_step

for (int i = 0; i < w->n_angular_motor; i++) angular_motor_setup(&w->angular_motor[i], w, beta, dt);

Use cases

• Turret spinning around a vertical axis.
• Wheel driven around its own rotation axis with a coexisting hinge (hinge handles alignment + limits; angular motor handles torque drive).
• Ragdoll / character rigging: proportional damping of relative angular velocity between bones, with v_target = 0 and a small T_max.