Thank you!

Hey, does anyone know why WiseKodama had to multiply the animation duration by 0.5f here?

I find that if i do not do this, the animation scrubs through twice as fast as it should and its on its final frame by t = trackEntry.Animation.Duration / 2.

But i don't understand why that would be the case? Is Animation.Duration reporting a duration that's twice as long as the actual duration? What's going on there?

Awesome, thanks Harald!

You're welcome, thanks for reporting.

Harald Thanks for the fix

Inspired by these articles, I created a script 'EditorSkeletonPlayer' that supports SkeletonAnimation and SkeletonGraphic. I hope you find this useful.
(If possible, I think it would be great if this feature could be officially adopted into the Spine Unity Runtime )

#if UNITY_EDITOR
using Spine;
using Spine.Unity;
using UnityEditor;
using UnityEditor.Callbacks;
using UnityEngine;

[ExecuteInEditMode]
public class EditorSkeletonPlayer : MonoBehaviour
{
    private IEditorSkeletonWrapper _skeletonWrapper;
    private TrackEntry _trackEntry;
    private string _oldAnimationName;
    private bool _oldLoop;
    private double _oldTime;

    [DidReloadScripts]
    private static void OnReloaded()
    {
        //force awake when scripts are reloaded
        var editorSpineAnimations = FindObjectsOfType<EditorSkeletonPlayer>();

        foreach (var editorSpineAnimation in editorSpineAnimations)
        {
            editorSpineAnimation.Awake();
        }
    }

    private void Awake()
    {
        if (Application.isPlaying) return;

        if (_skeletonWrapper == null)
        {
            if (TryGetComponent<SkeletonAnimation>(out var skeletonAnimation))
            {
                _skeletonWrapper = new SkeletonAnimationWrapper(skeletonAnimation);
            }
            else if (TryGetComponent<SkeletonGraphic>(out var skeletonGraphic))
            {
                _skeletonWrapper = new SkeletonGraphicWrapper(skeletonGraphic);
            }
        }

        _oldTime = EditorApplication.timeSinceStartup;
        EditorApplication.update += EditorUpdate;
    }

    private void OnDestroy()
    {
        EditorApplication.update -= EditorUpdate;
    }

    private void EditorUpdate()
    {
        if (Application.isPlaying) return;
        if (_skeletonWrapper == null) return;
        if (_skeletonWrapper.State == null) return;

        if (_oldAnimationName != _skeletonWrapper.AnimationName || _oldLoop != _skeletonWrapper.Loop)
        {
            _trackEntry = _skeletonWrapper.State.SetAnimation(0, _skeletonWrapper.AnimationName, _skeletonWrapper.Loop);
            _oldAnimationName = _skeletonWrapper.AnimationName;
            _oldLoop = _skeletonWrapper.Loop;
        }

        if (_trackEntry != null)
        {
            _trackEntry.TimeScale = _skeletonWrapper.Speed;
        }

        float deltaTime = (float)(EditorApplication.timeSinceStartup - _oldTime);
        _skeletonWrapper.Update(deltaTime);
        _oldTime = EditorApplication.timeSinceStartup;

        //force repaint to update animation
        EditorApplication.QueuePlayerLoopUpdate();
    }

    private class SkeletonAnimationWrapper : IEditorSkeletonWrapper
    {
        private SkeletonAnimation _skeletonAnimation;

        public SkeletonAnimationWrapper(SkeletonAnimation skeletonAnimation)
        {
            _skeletonAnimation = skeletonAnimation;
        }

        public string AnimationName
        {
            get { return _skeletonAnimation.AnimationName; }
        }

        public bool Loop
        {
            get { return _skeletonAnimation.loop; }
        }

        public float Speed
        {
            get { return _skeletonAnimation.timeScale; }
        }

        public Spine.AnimationState State
        {
            get { return _skeletonAnimation.state; }
        }

        public void Update(float deltaTime)
        {
            _skeletonAnimation.Update(deltaTime);

        }
    }

    private class SkeletonGraphicWrapper : IEditorSkeletonWrapper
    {
        private SkeletonGraphic _skeletonGraphic;

        public SkeletonGraphicWrapper(SkeletonGraphic skeletonGraphic)
        {
            _skeletonGraphic = skeletonGraphic;
        }

        public string AnimationName
        {
            get { return _skeletonGraphic.startingAnimation; }
        }

        public bool Loop
        {
            get { return _skeletonGraphic.startingLoop; }
        }

        public float Speed
        {
            get { return _skeletonGraphic.timeScale; }
        }

        public Spine.AnimationState State
        {
            get { return _skeletonGraphic.AnimationState; }
        }

        public void Update(float deltaTime)
        {
            _skeletonGraphic.Update(deltaTime);
        }
    }

    private interface IEditorSkeletonWrapper
    {
        string AnimationName { get; }

        bool Loop { get; }

        float Speed { get; }

        Spine.AnimationState State { get; }

        void Update(float deltaTime);
    }
}
#endif

@Sekomu Awesome, thanks very much for sharing!

Sekomu (If possible, I think it would be great if this feature could be officially adopted into the Spine Unity Runtime )

We would be happy to include such a component in the spine-runtimes officially (potentially with some slight modifications)! Could you please send us a signed contributor license agreement (CLA) to contact@esotericsoftware.com as listed in the Contributing section here:
https://github.com/EsotericSoftware/spine-runtimes/tree/4.1/#contributing

Harald
https://esotericsoftware.com/forum/d/11476-unity-nested-prefab-overrides/11
I've written a CLA in the past, please let me know if I need to rewrite it.
Here is the Pull Request. I would appreciate a review.

EsotericSoftware/spine-runtimes2351

No need to resend the CLA! @Harald will have a look at the pull request.