SixDOFConstraint: support mLimitsSpringSettings for rotations

[zkrx]

I am applying a SixDOFConstraint to my bodies in order to limit the extent of the rotation among the X and Z axis. I would also like for my bodies to come back to their original rotation (0°) automatically with the help of a spring.

Unfortunately, mLimitsSpringSettings is not supported for rotations on 6DOF, only translations:

When enabled, this makes the limits soft. When the constraint exceeds the limits, a spring force will pull it back. Only soft translation limits are supported, soft rotation limits are not currently supported. 

Are there any plans for supporting this? Or how can I work around this? I tried using a HingeConstraint. I could have exactly what I want one axis at a time, but not on both axis at the same time (or the body gets overconstrained and won't rotate anymore). I also tried using a SwingTwistConstraint, but it does not appear to support soft limits at all.

Cheers!

[jrouwe]

The best way to achieve this is to use a motor. Supply the spring frequency and damping to the MotorSettings object associated with the X and Z axis. Activate the motor with SetMotorState. Drive it to your 0 degree target using SetTargetOrientationCS.

[zkrx]

Thank you for the advice. I managed to implement what I want with a SixDOFConstraint and its associated Motor. When I advance the helicopter, it tilts 20° forward. Same when I move backwards or sideways. It comes back to neutral when I stop. I can freely rotate around Y (yaw) as well.

It runs fine. Here the helicopter starts with an identity rotation:
https://github.com/user-attachments/assets/85c1251b-24ef-47ef-a148-09bdac8f2155

But I start having issues when I want to limit the X or Z rotation axis (with SetLimitedAxis). More precisely when crossing a yaw rotation of 180° around the Y axis. When the helicopter is perfectly flat, I can rotate past the 180° point freely. When the helicopter has a small tilt (X) or roll (Z) angle, then I have hiccups or even cannot cross the 180° point:
https://github.com/user-attachments/assets/ca00e58b-cf01-427c-8c95-141c013efcdc

Could this be a problem within the limits code or am I just doing something silly?

I am using SetTargetOrientationBS to tilt around X and Z, SetTargetAngularVelocityCS to rotate around Y.

Code:

BodyCreationSettings creation_settings(new SphereShape(sphere_radius),
				    position,
				    rotation,
				    EMotionType::Dynamic,
				    layer);

creation_settings.mOverrideMassProperties = EOverrideMassProperties::CalculateInertia;
creation_settings.mMassPropertiesOverride.mMass = 10000;
creation_settings.mLinearDamping = 10.0f;
creation_settings.mAngularDamping = 10.0f;

Body *body = body_interface.CreateBody(creation_settings);

BodyCreationSettings creation_settings2(new SphereShape(0.001f),
				       body->GetPosition(),
				       body->GetRotation(),
				       EMotionType::Dynamic,
				       Layers::IGNORE);
creation_settings2.mAllowedDOFs = EAllowedDOFs::TranslationX | EAllowedDOFs::TranslationY | EAllowedDOFs::TranslationZ;
Body *base = body_interface.CreateBody(creation_settings2);
body_interface.AddBody(base->GetID(), EActivation::Activate);

SixDOFConstraintSettings settings;

settings.SetLimitedAxis(SixDOFConstraintSettings::EAxis::RotationX, DegreesToRadians(-80.0f), DegreesToRadians(80.0f)); // <------ this line creates the issue

settings.mMotorSettings[SixDOFConstraintSettings::EAxis::RotationX] = MotorSettings(1.0f, 0.5f);
settings.mMotorSettings[SixDOFConstraintSettings::EAxis::RotationY] = MotorSettings(1.0f, 0.5f);
settings.mMotorSettings[SixDOFConstraintSettings::EAxis::RotationZ] = MotorSettings(1.0f, 0.5f);

SixDOFConstraint *constraint = static_cast<SixDOFConstraint *>(settings.Create(*base, *body));
constraint->SetMotorState(SixDOFConstraintSettings::EAxis::RotationX, EMotorState::Position);
constraint->SetMotorState(SixDOFConstraintSettings::EAxis::RotationY, EMotorState::Velocity);
constraint->SetMotorState(SixDOFConstraintSettings::EAxis::RotationZ, EMotorState::Position);
constraint->SetTargetOrientationBS(Quat::sIdentity());

physics_system.AddConstraint(constraint);

[jrouwe]

I'm not sure what body and base means in your example (which is the helicopter and which are the blades)?

• If you create a constraint, make it settings.Create(helicopter, blades) and not the other way around (otherwise your limits will be rotating and that usually means the result is incomprehensible)
• Have you read the documentation for SixDOFConstraintSettings::mLimitMin? There are very particular requirements for the limits. If you break the rules, you break the constraint. E.g. Y and Z need to be in the range [-PI, PI] (equivalent to -180 to 180 degrees).
• Note that not all axis are equal. The X axis is called the twist axis. The other two axis are the swing axis. If you limit 2 axis and want the 3rd to be free, pick the X axis to be the free axis (and not the Y as you've currently done). The reasons for this are a bit difficult to explain. You decide the orientation of the constraint (through SixDOFConstraintSettings::mAxisX1 and friends) so you can always pick the X axis to be the axis around which the blades revolve.
• Are you running a Debug build? If you do it wrong, it should assert. In a Release build it will just silently fail.
• You're limiting the rotation of base through mAllowedDOFs. This is almost never a good idea in combination with constraints as the constraints operate in some arbitrary space and mAllowedDOFs is always in world space. This often results in the constraint not being able to operate anymore as it needs to push things in a direction that's not allowed. At that point it just gives up and does nothing.

[zkrx]

I am using a debug build. I have read a lot of documentation about the fields and grepped through the code base quite a bit.

The helicopter is a single rigged mesh (that's how the blades move, through skinning). The blades don't matter here. I see how using a base body can be confusing. I've switched to sFixedToWorld which better reflects my intention, works as before and still has that exact same problem. See code in [1].

My goal is simply to prevent my helicopter from toppling over (e.g. because of a collision with another body).

Note that not all axis are equal. The X axis is called the twist axis. The other two axis are the swing axis. If you limit 2 axis and want the 3rd to be free, pick the X axis to be the free axis (and not the Y as you've currently done). The reasons for this are a bit difficult to explain. You decide the orientation of the constraint (through SixDOFConstraintSettings::mAxisX1 and friends) so you can always pick the X axis to be the axis around which the blades revolve.

That could be the culprit. I can try this.

[1]

BodyInterface &body_interface = physics_system.GetBodyInterfaceNoLock();
SixDOFConstraintSettings settings;

settings.mPosition2 = body->GetPosition();

settings.SetLimitedAxis(SixDOFConstraintSettings::EAxis::RotationX, DegreesToRadians(-20.0f), DegreesToRadians(20.0f));
settings.SetLimitedAxis(SixDOFConstraintSettings::EAxis::RotationZ, DegreesToRadians(-20.0f), DegreesToRadians(20.0f));

settings.mMotorSettings[SixDOFConstraintSettings::EAxis::TranslationX] = MotorSettings(1.0f, 0.5f);
settings.mMotorSettings[SixDOFConstraintSettings::EAxis::TranslationY] = MotorSettings(1.0f, 0.5f);
settings.mMotorSettings[SixDOFConstraintSettings::EAxis::TranslationZ] = MotorSettings(1.0f, 0.5f);
settings.mMotorSettings[SixDOFConstraintSettings::EAxis::RotationX] = MotorSettings(1.0f, 0.5f);
settings.mMotorSettings[SixDOFConstraintSettings::EAxis::RotationY] = MotorSettings(1.0f, 0.5f);
settings.mMotorSettings[SixDOFConstraintSettings::EAxis::RotationZ] = MotorSettings(1.0f, 0.5f);

SixDOFConstraint *constraint = static_cast<SixDOFConstraint *>(settings.Create(Body::sFixedToWorld, *body));

physics_system.AddConstraint(constraint);

[zkrx]

So I tried this (and many other combinations):

settings.mAxisX1 = Vec3::sAxisY();
settings.mAxisY1 = Vec3::sAxisX();
settings.mAxisX2 = Vec3::sAxisY();
settings.mAxisY2 = Vec3::sAxisX();

And now my controls are completely wrong. Am I supposed to adapt all the vectors and quaternions that I feed to SetTargetOrientationCS, SetTargetVelocityCS and SetTargetAngularVelocityCS? Or is there a trick to avoid doing so?

[jrouwe]

Yes, those are supplied in constraint space. You can use SetTargetOrientationBS to supply them in body space. If you look at the implementation of the function you can easily see how you can do the same for velocity.