Add support for bone constraints

[ghost]

Describe the project you are working on:
Bone-heavy RPG

Describe the problem or limitation you are having in your project:
I have a model created in Blender and exported with GLTF2 which makes use of disconnected hands and feet to make animating them simple (they're parented to the IK target bones, so they won't rotate when the legs/arms do); the bones also have constraints which keep them connected to the legs or arms. Given the way Godot imports these animations, it seems to work out fine, and they do play just as they were made in Blender (after some modifications to the optimizer.)

I assume those yellow lines are the foot IK targets way off from the model, but the feet remain attached to the legs anyway, which does match what's going on in Blender.

From there, I created a BlendSpace1D in an AnimationTree and hooked up this animation to her walking animation, depicted below:

However, once any sort of blending occurs, the feet or hands will detach and rely on the IK targets for where they should be in-between the two animations, resulting in this:

This is a contrived example, but it is noticeable with any blended animation that's at least a little different from where it's coming from, even if the IK targets are at a reasonable distance.

This poses a big problem: for now, the only way to ensure the blending works appropriately is to keep the hands and feet attached to the arms or legs, such that the bone hierarchy matches up with how Godot expects it.

Unfortunately, this also means that IK can't be very useful, as you must constantly readjust how the hands or feet are rotated for any little change made to the arms or legs if they are directly parented to them in any capacity. You can make a bone not follow its parent's rotation in Blender, but Godot will not respect this setting, and you wind up with an animation that does not match up with the animation made in Blender:

The result is the same for any other configuration which attempts to make the hand or feet bones obey a different rotation from their parent, presumably due to Godot's FK.

So it seems that the animator is stuck either tediously readjusting the hands and feet every keyframe, or they must forego animation blending, or they must devise some system to make an arbitrary number of bones disregard its parent's rotation and follow another in Godot itself.

Describe how this feature / enhancement will help you overcome this problem or limitation:
It seems that what's needed in this regard is to expand the behavior of bones. Right now, settings for bones are simple: you can disable them, or enable them, which seems to prevent them from being animated. A bone will transform relative to its parents. You can override a bone's transform in code. I don't believe there's anything more to them at the moment.

In this particular instance, my problem would be solved if I could specify that a bone should copy the rotation of another bone, similarly to how the RemoteTransform node works; this would allow the hierarchy to be preserved such that blendspaces work as intended, while the animation matches up between Blender and Godot. But having other constraints, such as to limit rotations or copy location and scale, would be very useful in a variety of different situations, particularly for use with SkeletonIK.

Show a mock up screenshots/video or a flow diagram explaining how your proposal will work:
Here's how Blender's Copy Rotation constraint looks like:

If there was a way to directly import certain Blender constraints along with the model, that'd be most ideal, as no further setup would be necessary. But I suppose that would boil down to what GLTF2 supports.

Describe implementation detail for your proposal (in code), if possible:
One option would be having an array of BoneConstraint resources on each bone, and a variety of constraints extending from it. In some manner, these resources are populated in the array. I assume the order in which the resource appears is how the skeleton constrains the bone. Godot would preserve these constraints upon reimport.

Another option is to have a BoneConstraint node added to a skeleton. You would select which bone to constrain, and select whatever constraints you want. I don't believe this should be made a part of SkeletonIK, as you may want to constrain a bone without wanting to use Godot's IK.

If this enhancement will not be used often, can it be worked around with a few lines of script?:
It is possible to override a bone's transform in code, and with a tool script, it can be done in the editor.

Is there a reason why this should be core and not an add-on in the asset library?:
Modifies the Godot core.

[fire]

My current work is based on skeleton IK. We started work in December. The current status is nothing works at all.

https://github.com/fire/godot/tree/ik-cmdd-kusudama

The UI looks like this:

Notice that per bone we have the ability to constraint twist and direction. Direction is constrained with control points on a sphere.

We use specific terminology which is different from Godot Engine's:

Target = “Thing I want bone to try to reach”
Effector = “Bone meant to try to reach a target”
Pinning = “Associate a Bone with a Target.”

This work is based on a new IK algorithm, we're calling CMDD. CMDD is a multi-effector / multi-goal solver.

[Edited]
Scale cannot be constrained. Prismatic joints cannot be used.

[fire]

#3712 supersedes this.

[fire]

You can see my slow work on this at https://github.com/fire/ewbik.