360 lines
15 KiB
C#
360 lines
15 KiB
C#
/******************************************************************************
|
|
* Spine Runtimes License Agreement
|
|
* Last updated April 5, 2025. Replaces all prior versions.
|
|
*
|
|
* Copyright (c) 2013-2026, Esoteric Software LLC
|
|
*
|
|
* Integration of the Spine Runtimes into software or otherwise creating
|
|
* derivative works of the Spine Runtimes is permitted under the terms and
|
|
* conditions of Section 2 of the Spine Editor License Agreement:
|
|
* http://esotericsoftware.com/spine-editor-license
|
|
*
|
|
* Otherwise, it is permitted to integrate the Spine Runtimes into software
|
|
* or otherwise create derivative works of the Spine Runtimes (collectively,
|
|
* "Products"), provided that each user of the Products must obtain their own
|
|
* Spine Editor license and redistribution of the Products in any form must
|
|
* include this license and copyright notice.
|
|
*
|
|
* THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
|
|
* BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*****************************************************************************/
|
|
|
|
#if UNITY_2018_3 || UNITY_2019 || UNITY_2018_3_OR_NEWER
|
|
#define NEW_PREFAB_SYSTEM
|
|
#endif
|
|
|
|
#if UNITY_2017_1_OR_NEWER
|
|
#define BUILT_IN_SPRITE_MASK_COMPONENT
|
|
#endif
|
|
|
|
#if !SPINE_DISABLE_THREADING
|
|
#define USE_THREADED_ANIMATION_UPDATE
|
|
#endif
|
|
|
|
#if !SPINE_AUTO_UPGRADE_COMPONENTS_OFF
|
|
#define AUTO_UPGRADE_TO_43_COMPONENTS
|
|
#endif
|
|
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
|
|
namespace Spine.Unity {
|
|
|
|
#if NEW_PREFAB_SYSTEM
|
|
[ExecuteAlways]
|
|
#else
|
|
[ExecuteInEditMode]
|
|
#endif
|
|
[AddComponentMenu("Spine/SkeletonAnimation")]
|
|
[HelpURL("http://esotericsoftware.com/spine-unity#SkeletonAnimation-Component")]
|
|
public class SkeletonAnimation : SkeletonAnimationBase, IAnimationStateComponent, IUpgradable {
|
|
|
|
#region Serialized state and Beginner API
|
|
[FormerlySerializedAs("_animationName")] [SerializeField] [SpineAnimation] protected string animationName = "";
|
|
|
|
/// <summary>Whether or not <see cref="AnimationName"/> should loop. This only applies to the initial animation specified in the inspector, or any subsequent Animations played through .AnimationName. Animations set through state.SetAnimation are unaffected.</summary>
|
|
public bool loop;
|
|
|
|
/// <summary>
|
|
/// The rate at which animations progress over time. 1 means 100%. 0.5 means 50%.</summary>
|
|
/// <remarks>AnimationState and TrackEntry also have their own timeScale. These are combined multiplicatively.</remarks>
|
|
public float timeScale = 1;
|
|
|
|
/// <summary>If enabled, AnimationState time is advanced by Unscaled Game Time
|
|
/// (<c>Time.unscaledDeltaTime</c> instead of the default Game Time(<c>Time.deltaTime</c>).
|
|
/// to animate independent of game <c>Time.timeScale</c>.
|
|
/// Instance timeScale will still be applied.</summary>
|
|
public bool unscaledTime;
|
|
#endregion
|
|
|
|
public override void MainThreadBeforeUpdateInternal () {
|
|
base.MainThreadBeforeUpdateInternal();
|
|
#if USE_THREADED_ANIMATION_UPDATE
|
|
if (isUpdatedExternally) {
|
|
if (state != null) state.DelayListenerNotifications();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
public override void MainThreadAfterUpdateInternal () {
|
|
base.MainThreadAfterUpdateInternal();
|
|
|
|
#if USE_THREADED_ANIMATION_UPDATE
|
|
if (isUpdatedExternally) {
|
|
if (state != null) state.IssueDelayedListenerNotifications();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
protected Spine.AnimationState state;
|
|
|
|
/// <summary>
|
|
/// This is the Spine.AnimationState object of this SkeletonAnimation. You can control animations through it.
|
|
/// Note that this object, like .skeleton, is not guaranteed to exist in Awake. Do all accesses and caching to it in Start</summary>
|
|
public Spine.AnimationState AnimationState {
|
|
get {
|
|
Initialize(false);
|
|
return state;
|
|
}
|
|
set { state = value; }
|
|
}
|
|
|
|
public override bool IsValid {
|
|
get { return skeletonRenderer != null && skeletonRenderer.IsValid && state != null; }
|
|
}
|
|
|
|
public bool UnscaledTime { get { return unscaledTime; } set { unscaledTime = value; } }
|
|
|
|
#region Serialized state and Beginner API
|
|
/// <summary>
|
|
/// Setting this property sets the animation of the skeleton. If invalid, it will store the animation name for the next time the skeleton is properly initialized.
|
|
/// Getting this property gets the name of the currently playing animation. If invalid, it will return the last stored animation name set through this property.</summary>
|
|
public string AnimationName {
|
|
get {
|
|
if (!this.IsValid) {
|
|
return animationName;
|
|
} else {
|
|
TrackEntry entry = state.GetTrack(0);
|
|
return entry == null ? null : entry.Animation.Name;
|
|
}
|
|
}
|
|
set {
|
|
Initialize(false);
|
|
if (!IsValid) {
|
|
animationName = value;
|
|
return;
|
|
}
|
|
|
|
if (animationName == value) {
|
|
TrackEntry entry = state.GetTrack(0);
|
|
if (entry != null && entry.Loop == loop)
|
|
return;
|
|
}
|
|
animationName = value;
|
|
|
|
if (string.IsNullOrEmpty(value)) {
|
|
state.ClearTrack(0);
|
|
} else {
|
|
SkeletonData skeletonData = skeletonRenderer.SkeletonDataAsset.GetSkeletonData(false);
|
|
if (skeletonData == null)
|
|
return;
|
|
Spine.Animation animationObject = skeletonData.FindAnimation(value);
|
|
if (animationObject != null)
|
|
state.SetAnimation(0, animationObject, loop);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Clears the previously generated mesh, resets the skeleton's pose, and clears all previously active animations.</summary>
|
|
public override void ClearAnimationState () {
|
|
if (state != null) state.ClearTracks();
|
|
}
|
|
|
|
public override void InitializeAnimationComponent () {
|
|
base.InitializeAnimationComponent();
|
|
if (!skeletonRenderer.IsValid)
|
|
return;
|
|
|
|
AnimationStateData data = skeletonRenderer.SkeletonDataAsset.GetAnimationStateData();
|
|
|
|
#if UNITY_EDITOR
|
|
AnimationState oldAnimationState = state;
|
|
#endif
|
|
state = new Spine.AnimationState(data);
|
|
state.Dispose += OnAnimationDisposed;
|
|
if (state == null)
|
|
return;
|
|
#if UNITY_EDITOR
|
|
if (oldAnimationState != null)
|
|
state.AssignEventSubscribersFrom(oldAnimationState);
|
|
#endif
|
|
UpdateInitialAnimation();
|
|
}
|
|
|
|
protected virtual void OnAnimationDisposed (TrackEntry entry) {
|
|
// when updateMode disables applying animations, still ensure animations are mixed out
|
|
UpdateMode updateMode = skeletonRenderer.UpdateMode;
|
|
if (updateMode != UpdateMode.FullUpdate &&
|
|
updateMode != UpdateMode.EverythingExceptMesh) {
|
|
entry.Animation.Apply(skeleton, 0, 0, false, null, 0f, true, false, true, false);
|
|
}
|
|
}
|
|
|
|
public virtual void UpdateInitialAnimation () {
|
|
state.ClearTrack(0);
|
|
if (!string.IsNullOrEmpty(animationName)) {
|
|
SkeletonData skeletonData = skeletonRenderer.SkeletonDataAsset.GetSkeletonData(false);
|
|
if (skeletonData == null)
|
|
return;
|
|
Spine.Animation animation = skeletonData.FindAnimation(animationName);
|
|
if (animation != null) {
|
|
state.SetAnimation(0, animation, loop);
|
|
#if UNITY_EDITOR
|
|
if (!ApplicationIsPlaying)
|
|
Update(0f);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#if USE_THREADED_ANIMATION_UPDATE
|
|
public override float UsedExternalDeltaTime {
|
|
get {
|
|
return unscaledTime ? ExternalUnscaledDeltaTime : ExternalDeltaTime;
|
|
}
|
|
}
|
|
#endif
|
|
protected override float DeltaTime {
|
|
get {
|
|
return unscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
|
|
}
|
|
}
|
|
|
|
protected override void UpdateAnimationStatus (float deltaTime) {
|
|
deltaTime *= timeScale;
|
|
if (state != null) {
|
|
state.Update(deltaTime);
|
|
skeleton.Update(deltaTime);
|
|
#if UNITY_EDITOR
|
|
if (ApplicationIsPlaying)
|
|
UpdatePropertyToCurrentAnimationEditor();
|
|
#endif
|
|
if (skeletonRenderer.UpdateMode == UpdateMode.OnlyAnimationStatus) {
|
|
state.ApplyEventTimelinesOnly(skeleton, issueEvents: false);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void ApplyStateToSkeleton (bool calledFromMainThread) {
|
|
if (skeletonRenderer.UpdateMode != UpdateMode.OnlyEventTimelines)
|
|
state.Apply(skeletonRenderer.Skeleton);
|
|
else
|
|
state.ApplyEventTimelinesOnly(skeletonRenderer.Skeleton, issueEvents: true);
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
protected void UpdatePropertyToCurrentAnimationEditor () {
|
|
if (state.Tracks.Count == 0 || state.Tracks.Items[0] == null)
|
|
return;
|
|
Animation currentAnimation = state.Tracks.Items[0].Animation;
|
|
animationName = currentAnimation == null ? "<None>" : currentAnimation.Name;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
#region Runtime Instantiation
|
|
/// <summary>Adds and prepares SkeletonAnimation and SkeletonRenderer components to a GameObject at runtime.</summary>
|
|
/// <returns>A struct referencing the newly instantiated SkeletonAnimation and SkeletonRenderer components.</returns>
|
|
public static SkeletonComponents<SkeletonRenderer, SkeletonAnimation> AddToGameObject (
|
|
GameObject gameObject, SkeletonDataAsset skeletonDataAsset, bool quiet = false) {
|
|
|
|
return Spine.Unity.SkeletonRenderer.AddSpineComponents<SkeletonRenderer, SkeletonAnimation>(
|
|
gameObject, skeletonDataAsset, quiet);
|
|
}
|
|
|
|
/// <summary>Instantiates a new UnityEngine.GameObject and adds SkeletonAnimation and SkeletonRenderer components to it.</summary>
|
|
/// <returns>A struct referencing the newly instantiated SkeletonAnimation and SkeletonRenderer components.</returns>
|
|
public static SkeletonComponents<SkeletonRenderer, SkeletonAnimation> NewSkeletonAnimationGameObject (SkeletonDataAsset skeletonDataAsset,
|
|
bool quiet = false) {
|
|
return Spine.Unity.SkeletonRenderer.NewSpineGameObject<SkeletonRenderer, SkeletonAnimation>(
|
|
skeletonDataAsset, quiet);
|
|
}
|
|
#endregion
|
|
|
|
#region Transfer of Deprecated Fields
|
|
#if UNITY_EDITOR && AUTO_UPGRADE_TO_43_COMPONENTS
|
|
// compatibility layer between 4.1 and 4.2, automatically transfer serialized attributes.
|
|
public override void UpgradeTo43 () {
|
|
if (!Application.isPlaying && !wasDeprecatedTransferred) {
|
|
UpgradeTo43Components();
|
|
TransferDeprecatedFields();
|
|
InitializeAnimationComponent();
|
|
}
|
|
}
|
|
|
|
protected void UpgradeTo43Components () {
|
|
if (gameObject.GetComponent<SkeletonRenderer>() == null &&
|
|
gameObject.GetComponent<SkeletonGraphic>() == null) {
|
|
gameObject.AddComponent<SkeletonRenderer>();
|
|
EditorBridge.RequestMarkDirty(gameObject);
|
|
Debug.Log(string.Format("{0}: Auto-migrated old SkeletonAnimation component to split SkeletonAnimation + SkeletonRenderer components.",
|
|
gameObject.name), gameObject);
|
|
}
|
|
}
|
|
|
|
/// <summary>Transfer of former base class SkeletonRenderer parameters.</summary>
|
|
protected void TransferDeprecatedFields () {
|
|
wasDeprecatedTransferred = true;
|
|
|
|
SkeletonRenderer skeletonRenderer = gameObject.GetComponent<SkeletonRenderer>();
|
|
if (skeletonRenderer == null)
|
|
return;
|
|
|
|
skeletonRenderer.skeletonDataAsset = this.skeletonDataAssetDeprecated;
|
|
skeletonRenderer.initialSkinName = this.initialSkinNameDeprecated;
|
|
skeletonRenderer.EditorSkipSkinSync = this.editorSkipSkinSyncDeprecated;
|
|
skeletonRenderer.initialFlipX = this.initialFlipXDeprecated;
|
|
skeletonRenderer.initialFlipY = this.initialFlipYDeprecated;
|
|
skeletonRenderer.UpdateMode = this.updateModeDeprecated;
|
|
skeletonRenderer.updateWhenInvisible = this.updateWhenInvisibleDeprecated;
|
|
skeletonRenderer.separatorSlotNames = this.separatorSlotNamesDeprecated;
|
|
|
|
skeletonRenderer.MeshSettings.zSpacing = this.zSpacingDeprecated;
|
|
skeletonRenderer.MeshSettings.useClipping = this.useClippingDeprecated;
|
|
skeletonRenderer.MeshSettings.immutableTriangles = this.immutableTrianglesDeprecated;
|
|
skeletonRenderer.MeshSettings.pmaVertexColors = this.pmaVertexColorsDeprecated;
|
|
skeletonRenderer.MeshSettings.tintBlack = this.tintBlackDeprecated;
|
|
skeletonRenderer.MeshSettings.addNormals = this.addNormalsDeprecated;
|
|
skeletonRenderer.MeshSettings.calculateTangents = this.calculateTangentsDeprecated;
|
|
|
|
skeletonRenderer.clearStateOnDisable = this.clearStateOnDisableDeprecated;
|
|
skeletonRenderer.singleSubmesh = this.singleSubmeshDeprecated;
|
|
skeletonRenderer.MaskInteraction = this.maskInteractionDeprecated;
|
|
}
|
|
|
|
[SerializeField] protected bool wasDeprecatedTransferred = false;
|
|
// SkeletonRenderer former base class parameters
|
|
[FormerlySerializedAs("skeletonDataAsset")] [SerializeField] private SkeletonDataAsset skeletonDataAssetDeprecated;
|
|
|
|
[FormerlySerializedAs("initialSkinName")] [SpineSkin(defaultAsEmptyString: true)] [SerializeField] private string initialSkinNameDeprecated;
|
|
[FormerlySerializedAs("editorSkipSkinSync")] [SerializeField] private bool editorSkipSkinSyncDeprecated = false;
|
|
[FormerlySerializedAs("initialFlipX")] [SerializeField] private bool initialFlipXDeprecated = false;
|
|
[FormerlySerializedAs("initialFlipY")] [SerializeField] private bool initialFlipYDeprecated = false;
|
|
[FormerlySerializedAs("updateMode")] [SerializeField] private UpdateMode updateModeDeprecated = UpdateMode.FullUpdate;
|
|
[FormerlySerializedAs("updateWhenInvisible")] [SerializeField] private UpdateMode updateWhenInvisibleDeprecated = UpdateMode.FullUpdate;
|
|
[UnityEngine.Serialization.FormerlySerializedAs("submeshSeparators"),
|
|
UnityEngine.Serialization.FormerlySerializedAs("separatorSlotNames")]
|
|
[SerializeField] private string[] separatorSlotNamesDeprecated = new string[0];
|
|
|
|
[FormerlySerializedAs("zSpacing")] [SerializeField] private float zSpacingDeprecated = 0f;
|
|
[FormerlySerializedAs("useClipping")] [SerializeField] private bool useClippingDeprecated = true;
|
|
[FormerlySerializedAs("immutableTriangles")] [SerializeField] private bool immutableTrianglesDeprecated = false;
|
|
[FormerlySerializedAs("pmaVertexColors")] [SerializeField] private bool pmaVertexColorsDeprecated = true;
|
|
[FormerlySerializedAs("clearStateOnDisable")] [SerializeField] private bool clearStateOnDisableDeprecated = false;
|
|
[FormerlySerializedAs("tintBlack")] [SerializeField] private bool tintBlackDeprecated = false;
|
|
[FormerlySerializedAs("singleSubmesh")] [SerializeField] private bool singleSubmeshDeprecated = false;
|
|
[FormerlySerializedAs("calculateNormals"),
|
|
FormerlySerializedAs("addNormals")]
|
|
[SerializeField] private bool addNormalsDeprecated = false;
|
|
[FormerlySerializedAs("calculateTangents")] [SerializeField] private bool calculateTangentsDeprecated = false;
|
|
|
|
#if BUILT_IN_SPRITE_MASK_COMPONENT
|
|
[FormerlySerializedAs("maskInteraction")] [SerializeField] private SpriteMaskInteraction maskInteractionDeprecated = SpriteMaskInteraction.None;
|
|
#endif // BUILT_IN_SPRITE_MASK_COMPONENT
|
|
#endif // UNITY_EDITOR && AUTO_UPGRADE_TO_43_COMPONENTS
|
|
#endregion
|
|
}
|
|
}
|