UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-03-06 18:56:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

[unity] Improved upon pull request #2351, commit 01273670. Coding style adaptations, added robustness and configurability.

Browse Source
This commit is contained in:
Harald Csaszar 2023-08-28 18:57:01 +02:00
parent 012736700e
commit c0db9fb91f
1 changed files with 114 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
spine-unity/Assets/Spine/Runtime/spine-unity/Components/EditorSkeletonPlayer.cs
View File

@ -28,141 +28,146 @@
*****************************************************************************/ *****************************************************************************/
#if UNITY_EDITOR #if UNITY_EDITOR
using Spine;
using Spine.Unity;
using UnityEditor; using UnityEditor;
using UnityEditor.Callbacks; using UnityEditor.Callbacks;
using UnityEngine; using UnityEngine;
namespace Spine.Unity { namespace Spine.Unity {
[ExecuteInEditMode]
[AddComponentMenu("Spine/EditorSkeletonPlayer")]
[RequireComponent(typeof(ISkeletonAnimation))]
public class EditorSkeletonPlayer : MonoBehaviour {
private IEditorSkeletonWrapper skeletonWrapper;
private TrackEntry trackEntry;
private string oldAnimationName;
private bool oldLoop;
private double oldTime;
[DidReloadScripts] /// <summary>
private static void OnReloaded() { /// Experimental Editor Skeleton Player component enabling Editor playback of the
// Force start when scripts are reloaded /// selected animation outside of Play mode for SkeletonAnimation and SkeletonGraphic.
EditorSkeletonPlayer[] editorSpineAnimations = FindObjectsOfType<EditorSkeletonPlayer>(); /// </summary>
[ExecuteInEditMode]
[AddComponentMenu("Spine/EditorSkeletonPlayer")]
[RequireComponent(typeof(ISkeletonAnimation))]
public class EditorSkeletonPlayer : MonoBehaviour {
public bool playWhenSelected = true;
public bool playWhenDeselected = true;
private IEditorSkeletonWrapper skeletonWrapper;
private TrackEntry trackEntry;
private string oldAnimationName;
private bool oldLoop;
private double oldTime;
foreach (EditorSkeletonPlayer editorSpineAnimation in editorSpineAnimations) [DidReloadScripts]
editorSpineAnimation.Start(); private static void OnReloaded () {
} // Force start when scripts are reloaded
EditorSkeletonPlayer[] editorSpineAnimations = FindObjectsOfType<EditorSkeletonPlayer>();
private void Start() { foreach (EditorSkeletonPlayer editorSpineAnimation in editorSpineAnimations)
if (Application.isPlaying) return; editorSpineAnimation.Start();
}
if (skeletonWrapper == null) { private void Reset () {
if (TryGetComponent(out SkeletonAnimation skeletonAnimation)) // Note: when a skeleton has a varying number of active materials,
skeletonWrapper = new SkeletonAnimationWrapper(skeletonAnimation); // we're moving this component first in the hierarchy to still be
else if (TryGetComponent(out SkeletonGraphic skeletonGraphic)) // able to disable this component.
skeletonWrapper = new SkeletonGraphicWrapper(skeletonGraphic); for (int i = 0; i < 10; ++i)
} UnityEditorInternal.ComponentUtility.MoveComponentUp(this);
}
oldTime = EditorApplication.timeSinceStartup; private void Start () {
EditorApplication.update += EditorUpdate; if (Application.isPlaying) return;
}
private void OnDestroy() { if (skeletonWrapper == null) {
EditorApplication.update -= EditorUpdate; if (TryGetComponent(out SkeletonAnimation skeletonAnimation))
} skeletonWrapper = new SkeletonAnimationWrapper(skeletonAnimation);
else if (TryGetComponent(out SkeletonGraphic skeletonGraphic))
skeletonWrapper = new SkeletonGraphicWrapper(skeletonGraphic);
}
private void EditorUpdate() { oldTime = EditorApplication.timeSinceStartup;
if (enabled == false || Application.isPlaying) return; EditorApplication.update += EditorUpdate;
if (skeletonWrapper == null) return; }
if (skeletonWrapper.State == null) return;
// Update animation private void OnDestroy () {
if (oldAnimationName != skeletonWrapper.AnimationName || oldLoop != skeletonWrapper.Loop) { EditorApplication.update -= EditorUpdate;
trackEntry = skeletonWrapper.State.SetAnimation(0, skeletonWrapper.AnimationName, skeletonWrapper.Loop); }
oldAnimationName = skeletonWrapper.AnimationName;
oldLoop = skeletonWrapper.Loop;
}
// Update speed private void EditorUpdate () {
if (trackEntry != null) if (enabled == false || Application.isPlaying) return;
trackEntry.TimeScale = skeletonWrapper.Speed; if (skeletonWrapper == null) return;
if (skeletonWrapper.State == null) return;
bool isSelected = Selection.Contains(this.gameObject);
if (!this.playWhenSelected && isSelected) return;
if (!this.playWhenDeselected && !isSelected) return;
float deltaTime = (float)(EditorApplication.timeSinceStartup - oldTime); // Update animation
skeletonWrapper.Update(deltaTime); if (oldAnimationName != skeletonWrapper.AnimationName || oldLoop != skeletonWrapper.Loop) {
oldTime = EditorApplication.timeSinceStartup; SkeletonData skeletonData = skeletonWrapper.SkeletonData;
Spine.Animation animation = (skeletonData == null || skeletonWrapper.AnimationName == null) ?
null : skeletonData.FindAnimation(skeletonWrapper.AnimationName);
if (animation != null)
trackEntry = skeletonWrapper.State.SetAnimation(0, skeletonWrapper.AnimationName, skeletonWrapper.Loop);
else
trackEntry = skeletonWrapper.State.SetEmptyAnimation(0, 0);
oldAnimationName = skeletonWrapper.AnimationName;
oldLoop = skeletonWrapper.Loop;
}
// Force repaint to update animation smoothly // Update speed
EditorApplication.QueuePlayerLoopUpdate(); if (trackEntry != null)
} trackEntry.TimeScale = skeletonWrapper.Speed;
private class SkeletonAnimationWrapper : IEditorSkeletonWrapper { float deltaTime = (float)(EditorApplication.timeSinceStartup - oldTime);
private SkeletonAnimation _skeletonAnimation; skeletonWrapper.Update(deltaTime);
oldTime = EditorApplication.timeSinceStartup;
public SkeletonAnimationWrapper(SkeletonAnimation skeletonAnimation) { // Force repaint to update animation smoothly
_skeletonAnimation = skeletonAnimation; EditorApplication.QueuePlayerLoopUpdate();
} }
public string AnimationName { private class SkeletonAnimationWrapper : IEditorSkeletonWrapper {
get { return _skeletonAnimation.AnimationName; } private SkeletonAnimation skeletonAnimation;
}
public bool Loop { public SkeletonAnimationWrapper (SkeletonAnimation skeletonAnimation) {
get { return _skeletonAnimation.loop; } this.skeletonAnimation = skeletonAnimation;
} }
public float Speed { public Spine.SkeletonData SkeletonData {
get { return _skeletonAnimation.timeScale; } get {
} if (!skeletonAnimation.SkeletonDataAsset) return null;
return skeletonAnimation.SkeletonDataAsset.GetSkeletonData(true);
}
}
public Spine.AnimationState State { public string AnimationName { get { return skeletonAnimation.AnimationName; } }
get { return _skeletonAnimation.state; } 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) { public void Update (float deltaTime) {
_skeletonAnimation.Update(deltaTime); skeletonAnimation.Update(deltaTime);
} }
} }
private class SkeletonGraphicWrapper : IEditorSkeletonWrapper { private class SkeletonGraphicWrapper : IEditorSkeletonWrapper {
private SkeletonGraphic _skeletonGraphic; private SkeletonGraphic skeletonGraphic;
public SkeletonGraphicWrapper(SkeletonGraphic skeletonGraphic) { public SkeletonGraphicWrapper (SkeletonGraphic skeletonGraphic) {
_skeletonGraphic = skeletonGraphic; this.skeletonGraphic = skeletonGraphic;
} }
public string AnimationName { public Spine.SkeletonData SkeletonData { get { return skeletonGraphic.SkeletonData; } }
get { return _skeletonGraphic.startingAnimation; } 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 bool Loop { public void Update (float deltaTime) {
get { return _skeletonGraphic.startingLoop; } skeletonGraphic.Update(deltaTime);
} }
}
public float Speed { private interface IEditorSkeletonWrapper {
get { return _skeletonGraphic.timeScale; } string AnimationName { get; }
} Spine.SkeletonData SkeletonData { get; }
bool Loop { get; }
public Spine.AnimationState State { float Speed { get; }
get { return _skeletonGraphic.AnimationState; } Spine.AnimationState State { get; }
} void Update (float deltaTime);
}
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 #endif