Custom blend trees

AdvancedProgrammer

The AnimationComponent has the property AnimationComponent.BlendTreeBuilder. If you want absolute control over which animations are played, how are they blended and what weights they have, you can create a script which inherits from IBlendTreeBuilder and assign it to the BlendTreeBuilder under your animation component.

When the animation component is updated, it calls void BuildBlendTree(FastList<AnimationOperation> animationList) on your script instead of updating the animations itself. This allows you to choose any combination of animation clips, speeds and blends, but is also more difficult, as all the heavy lifting is now on the script side.

The templates First-person shooter, Third-person platformer and Top-down RPG, included with Xenko, are examples of how to use custom blend trees.

Code sample

  1. public class AnimationBlendTree : SyncScript, IBlendTreeBuilder
  2. {
  3.     /// <summary>
  4.     /// The animation component is required
  5.     /// </summary>
  6.     [Display("Animation Component")]
  7.     public AnimationComponent AnimationComponent { get; set; }
  9.     [Display("Walk")]
  10.     public AnimationClip AnimationWalk { get; set; }
  12.     [Display("Run")]
  13.     public AnimationClip AnimationRun { get; set; }
  15.     [Display("Lerp Factor")]
  16.     public float LerpFactor = 0.5f;
  18.     private AnimationClipEvaluator animEvaluatorWalk;
  19.     private AnimationClipEvaluator animEvaluatorRun;
  20.     private double currentTime = 0;
  22.     public override void Start()
  23.     {
  24.         base.Start();
  26.         // IMPORTANT STEP
  27.         // By setting a custom blend tree builder we can override the default behavior of the animation system.
  28.         // Instead, BuildBlendTree(FastList<AnimationOperation> blendStack) will be called each frame.
  29.         // We need to update the animation state in Update() and then
  30.         // pass the new animation state (stack = blend tree) to the animation system.
  31.         AnimationComponent.BlendTreeBuilder = this;
  33.         // As we override the animation system, we need to create an AnimationClipEvaluator for each clip we want to use.
  34.         animEvaluatorWalk = AnimationComponent.Blender.CreateEvaluator(AnimationWalk);
  35.         animEvaluatorRun = AnimationComponent.Blender.CreateEvaluator(AnimationRun);
  36.     }
  38.     public override void Cancel()
  39.     {
  40.         // When the script is cancelled, don't forget to release all animation resources created in Start() - AnimationClipEvaluators
  41.         AnimationComponent.Blender.ReleaseEvaluator(animEvaluatorWalk);
  42.         AnimationComponent.Blender.ReleaseEvaluator(animEvaluatorRun);
  43.     }
  45.     public override void Update()
  46.     {
  47.         // Use DrawTime rather than UpdateTime because the animations are updated only when they are drawn.
  48.         var time = Game.DrawTime;
  50.         // This update function accounts for animation with different durations,
  51.         // keeping a current time relative to the blended maximum duration.
  52.         long blendedMaxDuration = (long)MathUtil.Lerp(AnimationWalk.Duration.Ticks, AnimationRun.Duration.Ticks, LerpFactor);
  54.         var currentTicks = TimeSpan.FromTicks((long)(currentTime * blendedMaxDuration));
  56.         currentTicks = blendedMaxDuration == 0
  57.             ? TimeSpan.Zero
  58.             : TimeSpan.FromTicks((currentTicks.Ticks + (long)(time.Elapsed.Ticks)) % blendedMaxDuration);
  60.         currentTime = ((double)currentTicks.Ticks / (double)blendedMaxDuration);
  61.     }
  63.     /// BuildBlendTree is called every frame from the animation system when the AnimationComponent needs to be evaluated.
  64.     /// It overrides the default behavior of the AnimationComponent by setting a custom blend tree.
  65.     public void BuildBlendTree(FastList<AnimationOperation> blendStack)
  66.     {
  67.         var timeWalk = TimeSpan.FromTicks((long) (currentTime * AnimationWalk.Duration.Ticks));
  68.         var timeRun  = TimeSpan.FromTicks((long) (currentTime * AnimationRun.Duration.Ticks));
  70.         // Build the animation blend tree (stack)
  71.         blendStack.Add(AnimationOperation.NewPush(animEvaluatorWalk, timeWalk));    // Will PUSH animation state to be evaluated at the specified Time.
  72.         blendStack.Add(AnimationOperation.NewPush(animEvaluatorRun, timeRun));      // Will PUSH another animation state to be evaluated at the specified Time.
  73.         blendStack.Add(AnimationOperation.NewBlend(AnimationBlendOperation.LinearBlend, LerpFactor));   // Will POP the last two states, blend them with the factor and PUSH back the result.
  75.         // NOTE
  76.         // Because the blending operations are laid out in a stack you have to pack the operations in this manner.
  77.         // In general, traversing a binary tree depth-first and adding operations as you *leave* precessed nodes should be sufficient.
  78.         // For non-binary trees, you have to properly weight the blending factors as well
  80.         // DONE
  81.         // The top of the stack now contains the final state used for the animated model
  82.     }
  83. }

See also