Synchronized AnimationTree

[elementbound]

Godot recently introduced Skeleton Modifiers which can be used to modify skeleton poses outside of an AnimationMixer. This way we can snapshot the skeleton's state at any point in time, and even possibly interpolate it.

Not sure of feasibility yet, but creating this ticket to investigate.

• https://docs.godotengine.org/en/4.4/classes/class_skeleton3d.html
• https://docs.godotengine.org/en/stable/classes/class_skeletonmodifier3d.html
• https://youtu.be/J4N_MH89z6c?si=msGZ3HIrv3gl_qT8&t=286

Refs #464

[Archists-dev]

Very exciting! Should solve a key area currently unclear

[ZeEndy]

Ok since I'm developing A solution I might as well do a quick write up on a semi proper way to do this. Synchronizing the skeleton is not the way to go about this because the most optimized version of this would be 32 bytes per bone with 2 vec4s (1 to represent quaternion rotation,2 to represent translation + uniform scale). and the average skeleton humanoid has from ~20-80 bones depending on the detail of the skeleton. So in worst case scenario a single skeleton pose can be 2560 bytes which would max out the MTU way too quickly, and considering most of the time bones move all in unison delta compression would be pointless. (it would also not syncrhonize any of the non skeleton values that might be in the animation so there would be a lot of missing data)
A better solution is to do pose task replication as that can reduce the total cost to approximately ~60 bytes (n) animation (or less if stictly integrated with the animation tree) without any delta compression depending on how its captured. There is a good talk about this from Bobby Anguelov a principle programmer at valve
https://www.youtube.com/watch?v=mKBDhC6-t4s

Here is how I've personally implemented it and fair warning its far from perfect. The host runs the all the necessary code to create the internal animation instances in the void AnimationMixer::_process_animation(double p_delta, bool p_update_only) function, be it from an AnimationPlayer or an AnimationTree. Then before the engine calls clear_animation_instances() in the mixer, they get captured. Note there is an issue with how godot handles filters in that all the tracks are represented as vector of floats and are preblended in the AnimationTree, so to take care of filtering the best solution I've found would be to group them by weight and in a PackeByteArray with each bit representing a track on the filter with 0 saying "this track is not affected by this weight" and 1 being "this track is". Of course any animation with a weight of 0.0 can be safely discarded for that capture as if its 0.0 then it wont be needed for that frame.

For the application of the capture it would just be the matter of stopping the tree processing since we're driving the animations by the capture, unpacking the weights and applying them via animation_instances.push_back(ai); in the same function we captured them from being void AnimationMixer::_process_animation(double p_delta, bool p_update_only) to finally output. The current version of this modification can be found here https://github.com/ZeEndy/godot/tree/BeautifulWorld-4.6

Now is there a better way to do this ? Yes, but it requires a lot more work than I've described as it would probably require a way to capture the tree in the most minimal way possible and to reconstruct how the animation nodes were linked together and with what nodes (so your blend2s sub2s add2s and oneshots). Its not impossible but so far I've yet have any luck of figuring out a way to inject this logic relatively easily and more importantly cleanly in the animation tree's current structure.

This is all in scope of an engine modification. I am not a 100% sure if its possible to do this in a gdextension. I would safely assume that there are some internal functions that are straight up not exposed (for "reasons") so I would not expect there to be a way to do this at an extension level. I personally might look into this as this is a very relevant topic to me.