For animation overriding, we have a more complicated way to do that. First, we built a animator controller system similar to Mecanim. In the animator controller, we have several layers, and each layer has several states, and each state can be a plain animation, a blend tree 1D, or a blend tree 2D. A layer can either be additive or override, and we also support weighted override and additive. For a simpler example, let's think about the following case:

Layer 0: Base Layer, plays animation 'idle'
Layer 1: Shooting Layer, Override (weight = 1), plays animation 'aim' (only has keyframes on upper body)

First, we introduce the mask concept. A mask keeps tracking the current weight of all bones in a skeleton. We update the layers like the following:

// In Animator.Update()
skeleton.SetToSetupPose();
mask.Reset(); // Reset weights of all bones to 0.
for( int i = this.layers.Count - 1; i >= 0; i

---

 )
{
    layer[i].Update();
}

// In Layer.Update()
currentState.Update();
currentState.UpdateMask();
mask.ApplyAffectedBoneWeights( layerWeight ); // Weights of all marked bones *= 1 - layerWeight, unmark those bones

// In State.Update()
foreach( timeline in timelines )
{
    timeline.Apply( alpha );
}

// In RotateTimeline.Apply( alpha )
alpha *= mask.GetBoneWeight( boneIndex );

// In RotateTimeline.UpdateMask()
mask.MarkAffectedBone( boneIndex ); // Mark the bone for later 'ApplyAffectedBoneWeights'

So, the idea is to reversely update layers, and for each layer, update the mask so that later layers can apply the bone weight.
I don't know if it is enough for you to understand our practice, just tell me your thought. I kinda like the discussion right now

Nate написал

1. Apply A (rotation = 20) at 100%. Rotation = 20.

2. Apply B (rotation = 40) at 50%, mixed with current pose. Rotation = 20 + (40 - 20) * 0.5 = 30.

The Spine way of doing this does not end up with the sum of alpha equals to 100%, right? In this case, one of the animations is biased to 100%. I know that if A is 50% and B is 100%, the result is also correct. But what if we blend 3 animations together? Which one is the biased one? Or only one animation is not biased? Not having the sum of alpha 100% is kinda weird cuz it does not serve as the meaning of 'alpha' I think.

I've not seen animations blending working this way in other tools. Is there a strong reason for you to do that? If you do, please let me know cuz this should be something to care about.

Nate написал

Care to explain?

Hi there, I'm the programmer working on the Code: HARECORE project.

There are several problems in the Spine runtime, it becomes really long as I wrote, so I will post them one by one as I complete them one by one

The most important of all, the method of updating animation timelines are wrong.

Think of the following case. A bone has a rotation of 0 degree in setup pose. We now play animation A and B at the same time, both with weight (or call it 'alpha') of 50%. In one frame, if the bone has a rotation of 20 degree in A, and a rotation of 40 degree in B (as the illustration below), what is expected to happen? After all the updates, the bone should have a rotation of 30 degree, right?

A 

---

 [Bone] 

---

 B
20        30         40

However, check out the code in RotateTimeline.Apply(), which does the following:

float delta = frames[frame + VALUE] - prevFrameValue;
float amount = bone.data.rotation + (prevFrameValue + delta * percent) - bone.rotation;
bone.rotation = bone.rotation + amount * alpha;

In our case, we don't consider interpolation for now, so 'delta' will be 0. OK, then we start updating the rotation timeline of A:

float amount = 0 + (20 + 0 * percent) - 0 = 20;
bone.rotation = 0 + 20 * 0.5 = 10;

Exactly what we want, right? But, when we start updating B:

float amount = 0 + (40 + 0 * percent) - 10 = 30;
bone.rotation = 10 + 30 * 0.5 = 25;

25, not 30. This is exactly where things gone wrong.

Typically, you set your rig to setup pose at the start of each update, and when you updating a timeline, YOU DON'T READ THE CURRENT DATA OF THE BONE. YOU JUST WRITE TO THE CURRENT DATA OF THE BONE.

We modified the update of timeline as the following:

float amount = prevFrameValue + delta * percent;
bone.rotation = bone.rotation + amount * alpha;

We think about the case again.

// Updating A
float amount = 20 + 0 * percent = 20;
bone.rotation = 0 + 20 * 0.5 = 10;

// Updating B
float amount = 40 + 0 * percent = 40;
bone.rotation = 10 + 40 * 0.5 = 30;

We do our aiming animation using a blend tree 1D, like aim-90, aim-45, aim_0, aim_45 and aim_90. We have to care about precision you know