Soft limit rotation constraint using springs

[ds84182]

I have two bodies with a SixDOF constraint between them. Rotation X and Y have limits (pi / 8), and the rest are fixed. But unlike #1840, I would like to have the bodies smoothly bounce (or even slightly sag over) the rotation limit rather than keep a specific orientation.

Here's what I currently have:

2026-09-23.18-56-07.remuxed.mp4

I considered modifying SixDOFConstraint to add rotation limit springs, but I would like to avoid editing more constraints q_q

[ds84182]

I toyed around with forwarding limit spring settings from SixDOF through SwingTwistConstraintPart into AngleConstraintPart. Problem is, I don't know what the inC (constraint equation) parameter should be. HingeConstraint seems to use the smallest angle to its limit, but I don't think that generalizes to 3 axes.

[jrouwe]

Typically that is what people use. So you calculate the smallest angle to the limit, decompose into Euler angles and then drive the 3 axis independently. This ignores the fact that the axis are not independent, but it works. A way to do it using quaternions can be seen here:

JoltPhysics/Jolt/Physics/Constraints/SixDOFConstraint.cpp

Lines 481 to 549 in 439c2b6

	// The definition of the constraint rotation q:
	// R2 * ConstraintToBody2 = R1 * ConstraintToBody1 * q (1)
	//
	// R2' is the rotation of body 2 when reaching the target_orientation:
	// R2' * ConstraintToBody2 = R1 * ConstraintToBody1 * target_orientation (2)
	//
	// The difference in body 2 space:
	// R2' = R2 * diff_body2 (3)
	//
	// We want to specify the difference in the constraint space of body 2:
	// diff_body2 = ConstraintToBody2 * diff * ConstraintToBody2^* (4)
	//
	// Extracting R2' from 2: R2' = R1 * ConstraintToBody1 * target_orientation * ConstraintToBody2^* (5)
	// Combining 3 & 4: R2' = R2 * ConstraintToBody2 * diff * ConstraintToBody2^* (6)
	// Combining 1 & 6: R2' = R1 * ConstraintToBody1 * q * diff * ConstraintToBody2^* (7)
	// Combining 5 & 7: R1 * ConstraintToBody1 * target_orientation * ConstraintToBody2^* = R1 * ConstraintToBody1 * q * diff * ConstraintToBody2^*
	// <=> target_orientation = q * diff
	// <=> diff = q^* * target_orientation
	Quat diff = q.Conjugated() * target_orientation;
	// Project diff so that only rotation around axis that have a position motor are remaining
	Quat projected_diff;
	switch (mRotationPositionMotorActive)
	{
	case 0b001:
	// Keep only rotation around X
	projected_diff = diff.GetTwist(Vec3::sAxisX());
	break;
	case 0b010:
	// Keep only rotation around Y
	projected_diff = diff.GetTwist(Vec3::sAxisY());
	break;
	case 0b100:
	// Keep only rotation around Z
	projected_diff = diff.GetTwist(Vec3::sAxisZ());
	break;
	case 0b011:
	// Remove rotation around Z
	// q = swing_xy * twist_z <=> swing_xy = q * twist_z^*
	projected_diff = diff * diff.GetTwist(Vec3::sAxisZ()).Conjugated();
	break;
	case 0b101:
	// Remove rotation around Y
	// q = swing_xz * twist_y <=> swing_xz = q * twist_y^*
	projected_diff = diff * diff.GetTwist(Vec3::sAxisY()).Conjugated();
	break;
	case 0b110:
	// Remove rotation around X
	// q = swing_yz * twist_x <=> swing_yz = q * twist_x^*
	projected_diff = diff * diff.GetTwist(Vec3::sAxisX()).Conjugated();
	break;
	case 0b111:
	default: // All motors off is handled here but the results are unused
	// Keep entire rotation
	projected_diff = diff;
	break;
	}
	// Approximate error angles
	// The imaginary part of a quaternion is rotation_axis * sin(angle / 2)
	// If angle is small, sin(x) = x so angle[i] ~ 2.0f * rotation_axis[i]
	// We'll be making small time steps, so if the angle is not small at least the sign will be correct and we'll move in the right direction
	Vec3 rotation_error = -2.0f * projected_diff.GetXYZ();

Note that you can also create poor man's soft limits without modifying Jolt code:

• Disable rotation limits on the constraint
• Every update detect if the rotation limits are violated
• Set the motor target to the closest rotation within the limits (or off when inside the limits)
• Set the motor torque limits so that it can only push toward the limit and not away from the limit

[ds84182]

I ended up using distance constraint with a spring to emulate a soft rotation constraint. I placed the distance constraint between the first and second body in a position that effectively stops all rotation. Here's a visualization of it in Blender with a rotation limit of 45deg:

[jrouwe]

That's clever! A much simpler solution than what I proposed and it should even work if the body you're attaching to is not static.