fix：1、添加项目

2026-04-22 09:52:55 +08:00
commit 173cfb2dc9
5871 changed files with 600870 additions and 0 deletions
@@ -0,0 +1,92 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, 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.
+ *****************************************************************************/
+
+using UnityEngine;
+
+namespace Spine.Unity {
+
+	/// <summary>
+	/// Utility component to support flipping of 2D hinge chains (chains of HingeJoint2D objects) along
+	/// with the parent skeleton by activating the respective mirrored versions of the hinge chain.
+	/// Note: This component is automatically attached when calling "Create Hinge Chain 2D" at <see cref="SkeletonUtilityBone"/>,
+	/// do not attempt to use this component for other purposes.
+	/// </summary>
+	public class ActivateBasedOnFlipDirection : MonoBehaviour {
+
+		public SkeletonRenderer skeletonRenderer;
+		public SkeletonGraphic skeletonGraphic;
+		public GameObject activeOnNormalX;
+		public GameObject activeOnFlippedX;
+		HingeJoint2D[] jointsNormalX;
+		HingeJoint2D[] jointsFlippedX;
+		ISkeletonComponent skeletonComponent;
+
+		bool wasFlippedXBefore = false;
+
+		private void Start () {
+			jointsNormalX = activeOnNormalX.GetComponentsInChildren<HingeJoint2D>();
+			jointsFlippedX = activeOnFlippedX.GetComponentsInChildren<HingeJoint2D>();
+			skeletonComponent = skeletonRenderer != null ? (ISkeletonComponent)skeletonRenderer : (ISkeletonComponent)skeletonGraphic;
+		}
+
+		private void FixedUpdate () {
+			bool isFlippedX = (skeletonComponent.Skeleton.ScaleX < 0);
+			if (isFlippedX != wasFlippedXBefore) {
+				HandleFlip(isFlippedX);
+			}
+			wasFlippedXBefore = isFlippedX;
+		}
+
+		void HandleFlip (bool isFlippedX) {
+			GameObject gameObjectToActivate = isFlippedX ? activeOnFlippedX : activeOnNormalX;
+			GameObject gameObjectToDeactivate = isFlippedX ? activeOnNormalX : activeOnFlippedX;
+
+			gameObjectToActivate.SetActive(true);
+			gameObjectToDeactivate.SetActive(false);
+
+			ResetJointPositions(isFlippedX ? jointsFlippedX : jointsNormalX);
+			ResetJointPositions(isFlippedX ? jointsNormalX : jointsFlippedX);
+			CompensateMovementAfterFlipX(gameObjectToActivate.transform, gameObjectToDeactivate.transform);
+		}
+
+		void ResetJointPositions (HingeJoint2D[] joints) {
+			for (int i = 0; i < joints.Length; ++i) {
+				var joint = joints[i];
+				var parent = joint.connectedBody.transform;
+				joint.transform.position = parent.TransformPoint(joint.connectedAnchor);
+			}
+		}
+
+		void CompensateMovementAfterFlipX (Transform toActivate, Transform toDeactivate) {
+			Transform targetLocation = toDeactivate.GetChild(0);
+			Transform currentLocation = toActivate.GetChild(0);
+			toActivate.position += targetLocation.position - currentLocation.position;
+		}
+	}
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 70ae96e4f2feb654681a2f16e4effeec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,54 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, 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.
+ *****************************************************************************/
+
+using UnityEngine;
+
+namespace Spine.Unity {
+
+	/// <summary>
+	/// Utility component to support flipping of hinge chains (chains of HingeJoint objects) along with the parent skeleton.
+	/// 
+	/// Note: This component is automatically attached when calling "Create Hinge Chain" at <see cref="SkeletonUtilityBone"/>.
+	/// </summary>
+	[RequireComponent(typeof(Rigidbody))]
+	public class FollowLocationRigidbody : MonoBehaviour {
+	
+		public Transform reference;
+		Rigidbody ownRigidbody;
+
+		private void Awake () {
+			ownRigidbody = this.GetComponent<Rigidbody>();
+		}
+
+		void FixedUpdate () {
+			ownRigidbody.rotation = reference.rotation;
+			ownRigidbody.position = reference.position;
+		}
+	}
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9fc20d5e917562341a5007777a9d0db2
+timeCreated: 1571763023
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,59 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, 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.
+ *****************************************************************************/
+
+using UnityEngine;
+
+namespace Spine.Unity {
+
+	/// <summary>
+	/// Utility component to support flipping of hinge chains (chains of HingeJoint objects) along with the parent skeleton.
+	/// 
+	/// Note: This component is automatically attached when calling "Create Hinge Chain" at <see cref="SkeletonUtilityBone"/>.
+	/// </summary>
+	[RequireComponent(typeof(Rigidbody2D))]
+	public class FollowLocationRigidbody2D : MonoBehaviour {
+	
+		public Transform reference;
+		public bool followFlippedX;
+		Rigidbody2D ownRigidbody;
+
+		private void Awake () {
+			ownRigidbody = this.GetComponent<Rigidbody2D>();
+		}
+
+		void FixedUpdate () {
+			if (followFlippedX) {
+				ownRigidbody.rotation = ((-reference.rotation.eulerAngles.z + 270f) % 360f) - 90f;
+			}
+			else
+				ownRigidbody.rotation = reference.rotation.eulerAngles.z;
+			ownRigidbody.position = reference.position;
+		}
+	}
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 02aae87c39b869548a9051fbdb1975e6
+timeCreated: 1572012493
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,86 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, 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.
+ *****************************************************************************/
+
+using UnityEngine;
+
+namespace Spine.Unity {
+
+	/// <summary>
+	/// Utility component to support flipping of hinge chains (chains of HingeJoint objects) along with the parent skeleton.
+	/// Note that flipping needs to be performed by 180 degree rotation at <see cref="SkeletonUtility"/>,
+	/// by setting <see cref="SkeletonUtility.flipBy180DegreeRotation"/> to true, not via negative scale.
+	///
+	/// Note: This component is automatically attached when calling "Create Hinge Chain" at <see cref="SkeletonUtilityBone"/>,
+	/// do not attempt to use this component for other purposes.
+	/// </summary>
+	public class FollowSkeletonUtilityRootRotation : MonoBehaviour {
+	
+		const float FLIP_ANGLE_THRESHOLD = 100.0f;
+
+		public Transform reference;
+		Vector3 prevLocalEulerAngles;
+
+		private void Start () {
+			prevLocalEulerAngles = this.transform.localEulerAngles;
+		}
+
+		void FixedUpdate () {
+			this.transform.rotation = reference.rotation;
+
+			bool wasFlippedAroundY = Mathf.Abs(this.transform.localEulerAngles.y - prevLocalEulerAngles.y) > FLIP_ANGLE_THRESHOLD;
+			bool wasFlippedAroundX = Mathf.Abs(this.transform.localEulerAngles.x - prevLocalEulerAngles.x) > FLIP_ANGLE_THRESHOLD;
+			if (wasFlippedAroundY)
+				CompensatePositionToYRotation();
+			if (wasFlippedAroundX)
+				CompensatePositionToXRotation();
+
+			prevLocalEulerAngles = this.transform.localEulerAngles;
+		}
+
+		/// <summary>
+		/// Compensates the position so that a child at the reference position remains in the same place,
+		/// to counter any movement that occurred by rotation.
+		/// </summary>
+		void CompensatePositionToYRotation () {
+			Vector3 newPosition = reference.position + (reference.position - this.transform.position);
+			newPosition.y = this.transform.position.y;
+			this.transform.position = newPosition;
+		}
+
+		/// <summary>
+		/// Compensates the position so that a child at the reference position remains in the same place,
+		/// to counter any movement that occurred by rotation.
+		/// </summary>
+		void CompensatePositionToXRotation () {
+			Vector3 newPosition = reference.position + (reference.position - this.transform.position);
+			newPosition.x = this.transform.position.x;
+			this.transform.position = newPosition;
+		}
+	}
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 456a736ebb92ebf4b959fa9c4b704427
+timeCreated: 1571763206
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,469 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, 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
+
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Spine.Unity {
+
+	#if NEW_PREFAB_SYSTEM
+	[ExecuteAlways]
+	#else
+	[ExecuteInEditMode]
+	#endif
+	[RequireComponent(typeof(ISkeletonAnimation))]
+	[HelpURL("http://esotericsoftware.com/spine-unity#SkeletonUtility")]
+	public sealed class SkeletonUtility : MonoBehaviour {
+
+		#region BoundingBoxAttachment
+		public static PolygonCollider2D AddBoundingBoxGameObject (Skeleton skeleton, string skinName, string slotName, string attachmentName, Transform parent, bool isTrigger = true) {
+			Skin skin = string.IsNullOrEmpty(skinName) ? skeleton.data.defaultSkin : skeleton.data.FindSkin(skinName);
+			if (skin == null) {
+				Debug.LogError("Skin " + skinName + " not found!");
+				return null;
+			}
+
+			var attachment = skin.GetAttachment(skeleton.FindSlotIndex(slotName), attachmentName);
+			if (attachment == null) {
+				Debug.LogFormat("Attachment in slot '{0}' named '{1}' not found in skin '{2}'.", slotName, attachmentName, skin.name);
+				return null;
+			}
+
+			var box = attachment as BoundingBoxAttachment;
+			if (box != null) {
+				var slot = skeleton.FindSlot(slotName);
+				return AddBoundingBoxGameObject(box.Name, box, slot, parent, isTrigger);
+			} else {
+				Debug.LogFormat("Attachment '{0}' was not a Bounding Box.", attachmentName);
+				return null;
+			}
+		}
+
+		public static PolygonCollider2D AddBoundingBoxGameObject (string name, BoundingBoxAttachment box, Slot slot, Transform parent, bool isTrigger = true) {
+			var go = new GameObject("[BoundingBox]" + (string.IsNullOrEmpty(name) ? box.Name : name));
+#if UNITY_EDITOR
+			if (!Application.isPlaying)
+				UnityEditor.Undo.RegisterCreatedObjectUndo(go, "Spawn BoundingBox");
+# endif
+			var got = go.transform;
+			got.parent = parent;
+			got.localPosition = Vector3.zero;
+			got.localRotation = Quaternion.identity;
+			got.localScale = Vector3.one;
+			return AddBoundingBoxAsComponent(box, slot, go, isTrigger);
+		}
+
+		public static PolygonCollider2D AddBoundingBoxAsComponent (BoundingBoxAttachment box, Slot slot, GameObject gameObject, bool isTrigger = true) {
+			if (box == null) return null;
+			var collider = gameObject.AddComponent<PolygonCollider2D>();
+			collider.isTrigger = isTrigger;
+			SetColliderPointsLocal(collider, slot, box);
+			return collider;
+		}
+
+		public static void SetColliderPointsLocal (PolygonCollider2D collider, Slot slot, BoundingBoxAttachment box, float scale = 1.0f) {
+			if (box == null) return;
+			if (box.IsWeighted()) Debug.LogWarning("UnityEngine.PolygonCollider2D does not support weighted or animated points. Collider points will not be animated and may have incorrect orientation. If you want to use it as a collider, please remove weights and animations from the bounding box in Spine editor.");
+			var verts = box.GetLocalVertices(slot, null);
+			if (scale != 1.0f) {
+				for (int i = 0, n = verts.Length; i < n; ++i)
+					verts[i] *= scale;
+			}
+			collider.SetPath(0, verts);
+		}
+
+		public static Bounds GetBoundingBoxBounds (BoundingBoxAttachment boundingBox, float depth = 0) {
+			float[] floats = boundingBox.Vertices;
+			int floatCount = floats.Length;
+
+			Bounds bounds = new Bounds();
+
+			bounds.center = new Vector3(floats[0], floats[1], 0);
+			for (int i = 2; i < floatCount; i += 2)
+				bounds.Encapsulate(new Vector3(floats[i], floats[i + 1], 0));
+
+			Vector3 size = bounds.size;
+			size.z = depth;
+			bounds.size = size;
+
+			return bounds;
+		}
+
+		public static Rigidbody2D AddBoneRigidbody2D (GameObject gameObject, bool isKinematic = true, float gravityScale = 0f) {
+			var rb = gameObject.GetComponent<Rigidbody2D>();
+			if (rb == null) {
+				rb = gameObject.AddComponent<Rigidbody2D>();
+				rb.isKinematic = isKinematic;
+				rb.gravityScale = gravityScale;
+			}
+			return rb;
+		}
+		#endregion
+
+		public delegate void SkeletonUtilityDelegate ();
+		public event SkeletonUtilityDelegate OnReset;
+		public Transform boneRoot;
+		/// <summary>
+		/// If true, <see cref="Skeleton.ScaleX"/> and <see cref="Skeleton.ScaleY"/> are followed
+		/// by 180 degree rotation. If false, negative Transform scale is used.
+		/// Note that using negative scale is consistent with previous behaviour (hence the default),
+		/// however causes serious problems with rigidbodies and physics. Therefore, it is recommended to
+		/// enable this parameter where possible. When creating hinge chains for a chain of skeleton bones
+		/// via <see cref="SkeletonUtilityBone"/>, it is mandatory to have <c>flipBy180DegreeRotation</c> enabled.
+		/// </summary>
+		public bool flipBy180DegreeRotation = false;
+
+		void Update () {
+			var skeleton = skeletonComponent.Skeleton;
+			if (skeleton != null && boneRoot != null) {
+
+				if (flipBy180DegreeRotation) {
+					boneRoot.localScale = new Vector3(Mathf.Abs(skeleton.ScaleX), Mathf.Abs(skeleton.ScaleY), 1f);
+					boneRoot.eulerAngles = new Vector3(skeleton.ScaleY > 0 ? 0 : 180,
+																	skeleton.ScaleX > 0 ? 0 : 180,
+																	0);
+				}
+				else {
+					boneRoot.localScale = new Vector3(skeleton.ScaleX, skeleton.ScaleY, 1f);
+				}
+			}
+
+			if (canvas != null) {
+				positionScale = canvas.referencePixelsPerUnit;
+			}
+		}
+
+		[HideInInspector] public SkeletonRenderer skeletonRenderer;
+		[HideInInspector] public SkeletonGraphic skeletonGraphic;
+		private Canvas canvas;
+		[System.NonSerialized] public ISkeletonAnimation skeletonAnimation;
+
+		private ISkeletonComponent skeletonComponent;
+		[System.NonSerialized] public List<SkeletonUtilityBone> boneComponents = new List<SkeletonUtilityBone>();
+		[System.NonSerialized] public List<SkeletonUtilityConstraint> constraintComponents = new List<SkeletonUtilityConstraint>();
+
+
+		public ISkeletonComponent SkeletonComponent {
+			get {
+				if (skeletonComponent == null) {
+					skeletonComponent = skeletonRenderer != null ? skeletonRenderer.GetComponent<ISkeletonComponent>() :
+										skeletonGraphic != null ? skeletonGraphic.GetComponent<ISkeletonComponent>() :
+										GetComponent<ISkeletonComponent>();
+				}
+				return skeletonComponent;
+			}
+		}
+		public Skeleton Skeleton {
+			get {
+				if (SkeletonComponent == null)
+					return null;
+				return skeletonComponent.Skeleton;
+			}
+		}
+
+		public bool IsValid {
+			get {
+				return (skeletonRenderer != null && skeletonRenderer.valid) ||
+					(skeletonGraphic != null && skeletonGraphic.IsValid);
+			}
+		}
+
+		public float PositionScale { get { return positionScale; } }
+
+		float positionScale = 1.0f;
+		bool hasOverrideBones;
+		bool hasConstraints;
+		bool needToReprocessBones;
+
+		public void ResubscribeEvents () {
+			OnDisable();
+			OnEnable();
+		}
+
+		void OnEnable () {
+			if (skeletonRenderer == null) {
+				skeletonRenderer = GetComponent<SkeletonRenderer>();
+			}
+			if (skeletonGraphic == null) {
+				skeletonGraphic = GetComponent<SkeletonGraphic>();
+			}
+			if (skeletonAnimation == null) {
+				skeletonAnimation = skeletonRenderer != null ? skeletonRenderer.GetComponent<ISkeletonAnimation>() :
+									skeletonGraphic != null ? skeletonGraphic.GetComponent<ISkeletonAnimation>() :
+									GetComponent<ISkeletonAnimation>();
+			}
+			if (skeletonComponent == null) {
+				skeletonComponent = skeletonRenderer != null ? skeletonRenderer.GetComponent<ISkeletonComponent>() :
+									skeletonGraphic != null ? skeletonGraphic.GetComponent<ISkeletonComponent>() :
+									GetComponent<ISkeletonComponent>();
+			}
+
+			if (skeletonRenderer != null) {
+				skeletonRenderer.OnRebuild -= HandleRendererReset;
+				skeletonRenderer.OnRebuild += HandleRendererReset;
+			}
+			else if (skeletonGraphic != null) {
+				skeletonGraphic.OnRebuild -= HandleRendererReset;
+				skeletonGraphic.OnRebuild += HandleRendererReset;
+				canvas = skeletonGraphic.canvas;
+				if (canvas == null)
+					canvas = skeletonGraphic.GetComponentInParent<Canvas>();
+				if (canvas == null)
+					positionScale = 100.0f;
+			}
+
+			if (skeletonAnimation != null) {
+				skeletonAnimation.UpdateLocal -= UpdateLocal;
+				skeletonAnimation.UpdateLocal += UpdateLocal;
+			}
+
+			CollectBones();
+		}
+
+		void Start () {
+			//recollect because order of operations failure when switching between game mode and edit mode...
+			CollectBones();
+		}
+
+		void OnDisable () {
+			if (skeletonRenderer != null)
+				skeletonRenderer.OnRebuild -= HandleRendererReset;
+			if (skeletonGraphic != null)
+				skeletonGraphic.OnRebuild -= HandleRendererReset;
+
+			if (skeletonAnimation != null) {
+				skeletonAnimation.UpdateLocal -= UpdateLocal;
+				skeletonAnimation.UpdateWorld -= UpdateWorld;
+				skeletonAnimation.UpdateComplete -= UpdateComplete;
+			}
+		}
+
+		void HandleRendererReset (SkeletonRenderer r) {
+			if (OnReset != null) OnReset();
+			CollectBones();
+		}
+
+		void HandleRendererReset (SkeletonGraphic g) {
+			if (OnReset != null) OnReset();
+			CollectBones();
+		}
+
+		public void RegisterBone (SkeletonUtilityBone bone) {
+			if (boneComponents.Contains(bone)) {
+				return;
+			} else {
+				boneComponents.Add(bone);
+				needToReprocessBones = true;
+			}
+		}
+
+		public void UnregisterBone (SkeletonUtilityBone bone) {
+			boneComponents.Remove(bone);
+		}
+
+		public void RegisterConstraint (SkeletonUtilityConstraint constraint) {
+			if (constraintComponents.Contains(constraint))
+				return;
+			else {
+				constraintComponents.Add(constraint);
+				needToReprocessBones = true;
+			}
+		}
+
+		public void UnregisterConstraint (SkeletonUtilityConstraint constraint) {
+			constraintComponents.Remove(constraint);
+		}
+
+		public void CollectBones () {
+			var skeleton = skeletonComponent.Skeleton;
+			if (skeleton == null) return;
+
+			if (boneRoot != null) {
+				var constraintTargets = new List<System.Object>();
+				var ikConstraints = skeleton.IkConstraints;
+				for (int i = 0, n = ikConstraints.Count; i < n; i++)
+					constraintTargets.Add(ikConstraints.Items[i].target);
+
+				var transformConstraints = skeleton.TransformConstraints;
+				for (int i = 0, n = transformConstraints.Count; i < n; i++)
+					constraintTargets.Add(transformConstraints.Items[i].target);
+
+				var boneComponents = this.boneComponents;
+				for (int i = 0, n = boneComponents.Count; i < n; i++) {
+					var b = boneComponents[i];
+					if (b.bone == null) {
+						b.DoUpdate(SkeletonUtilityBone.UpdatePhase.Local);
+						if (b.bone == null) continue;
+					}
+					hasOverrideBones |= (b.mode == SkeletonUtilityBone.Mode.Override);
+					hasConstraints |= constraintTargets.Contains(b.bone);
+				}
+
+				hasConstraints |= constraintComponents.Count > 0;
+
+				if (skeletonAnimation != null) {
+					skeletonAnimation.UpdateWorld -= UpdateWorld;
+					skeletonAnimation.UpdateComplete -= UpdateComplete;
+
+					if (hasOverrideBones || hasConstraints)
+						skeletonAnimation.UpdateWorld += UpdateWorld;
+
+					if (hasConstraints)
+						skeletonAnimation.UpdateComplete += UpdateComplete;
+				}
+
+				needToReprocessBones = false;
+			} else {
+				boneComponents.Clear();
+				constraintComponents.Clear();
+			}
+		}
+
+		void UpdateLocal (ISkeletonAnimation anim) {
+			if (needToReprocessBones)
+				CollectBones();
+
+			var boneComponents = this.boneComponents;
+			if (boneComponents == null) return;
+			for (int i = 0, n = boneComponents.Count; i < n; i++)
+				boneComponents[i].transformLerpComplete = false;
+
+			UpdateAllBones(SkeletonUtilityBone.UpdatePhase.Local);
+		}
+
+		void UpdateWorld (ISkeletonAnimation anim) {
+			UpdateAllBones(SkeletonUtilityBone.UpdatePhase.World);
+			for (int i = 0, n = constraintComponents.Count; i < n; i++)
+				constraintComponents[i].DoUpdate();
+		}
+
+		void UpdateComplete (ISkeletonAnimation anim) {
+			UpdateAllBones(SkeletonUtilityBone.UpdatePhase.Complete);
+		}
+
+		void UpdateAllBones (SkeletonUtilityBone.UpdatePhase phase) {
+			if (boneRoot == null)
+				CollectBones();
+
+			var boneComponents = this.boneComponents;
+			if (boneComponents == null) return;
+			for (int i = 0, n = boneComponents.Count; i < n; i++)
+				boneComponents[i].DoUpdate(phase);
+		}
+
+		public Transform GetBoneRoot () {
+			if (boneRoot != null)
+				return boneRoot;
+
+			var boneRootObject = new GameObject("SkeletonUtility-SkeletonRoot");
+#if UNITY_EDITOR
+			if (!Application.isPlaying)
+				UnityEditor.Undo.RegisterCreatedObjectUndo(boneRootObject, "Spawn Bone");
+#endif
+			if (skeletonGraphic != null)
+				boneRootObject.AddComponent<RectTransform>();
+
+			boneRoot = boneRootObject.transform;
+			boneRoot.SetParent(transform);
+			boneRoot.localPosition = Vector3.zero;
+			boneRoot.localRotation = Quaternion.identity;
+			boneRoot.localScale = Vector3.one;
+
+			return boneRoot;
+		}
+
+		public GameObject SpawnRoot (SkeletonUtilityBone.Mode mode, bool pos, bool rot, bool sca) {
+			GetBoneRoot();
+			Skeleton skeleton = this.skeletonComponent.Skeleton;
+
+			GameObject go = SpawnBone(skeleton.RootBone, boneRoot, mode, pos, rot, sca);
+			CollectBones();
+			return go;
+		}
+
+		public GameObject SpawnHierarchy (SkeletonUtilityBone.Mode mode, bool pos, bool rot, bool sca) {
+			GetBoneRoot();
+			Skeleton skeleton = this.skeletonComponent.Skeleton;
+			GameObject go = SpawnBoneRecursively(skeleton.RootBone, boneRoot, mode, pos, rot, sca);
+			CollectBones();
+			return go;
+		}
+
+		public GameObject SpawnBoneRecursively (Bone bone, Transform parent, SkeletonUtilityBone.Mode mode, bool pos, bool rot, bool sca) {
+			GameObject go = SpawnBone(bone, parent, mode, pos, rot, sca);
+
+			ExposedList<Bone> childrenBones = bone.Children;
+			for (int i = 0, n = childrenBones.Count; i < n; i++) {
+				Bone child = childrenBones.Items[i];
+				SpawnBoneRecursively(child, go.transform, mode, pos, rot, sca);
+			}
+
+			return go;
+		}
+
+		public GameObject SpawnBone (Bone bone, Transform parent, SkeletonUtilityBone.Mode mode, bool pos, bool rot, bool sca) {
+			GameObject go = new GameObject(bone.Data.Name);
+		#if UNITY_EDITOR
+			if (!Application.isPlaying)
+				UnityEditor.Undo.RegisterCreatedObjectUndo(go, "Spawn Bone");
+		#endif
+			if (skeletonGraphic != null)
+				go.AddComponent<RectTransform>();
+
+			var goTransform = go.transform;
+			goTransform.SetParent(parent);
+
+			SkeletonUtilityBone b = go.AddComponent<SkeletonUtilityBone>();
+			b.hierarchy = this;
+			b.position = pos;
+			b.rotation = rot;
+			b.scale = sca;
+			b.mode = mode;
+			b.zPosition = true;
+			b.Reset();
+			b.bone = bone;
+			b.boneName = bone.Data.Name;
+			b.valid = true;
+
+			if (mode == SkeletonUtilityBone.Mode.Override) {
+				if (rot) goTransform.localRotation = Quaternion.Euler(0, 0, b.bone.AppliedRotation);
+				if (pos) goTransform.localPosition = new Vector3(b.bone.X * positionScale, b.bone.Y * positionScale, 0);
+				goTransform.localScale = new Vector3(b.bone.scaleX, b.bone.scaleY, 0);
+			}
+
+			return go;
+		}
+
+	}
+
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7f726fb798ad621458c431cb9966d91d
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,243 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, 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
+
+using UnityEngine;
+
+namespace Spine.Unity {
+	/// <summary>Sets a GameObject's transform to match a bone on a Spine skeleton.</summary>
+	#if NEW_PREFAB_SYSTEM
+	[ExecuteAlways]
+	#else
+	[ExecuteInEditMode]
+	#endif
+	[AddComponentMenu("Spine/SkeletonUtilityBone")]
+	[HelpURL("http://esotericsoftware.com/spine-unity#SkeletonUtilityBone")]
+	public class SkeletonUtilityBone : MonoBehaviour {
+		public enum Mode {
+			Follow,
+			Override
+		}
+
+		public enum UpdatePhase {
+			Local,
+			World,
+			Complete
+		}
+
+		#region Inspector
+		/// <summary>If a bone isn't set, boneName is used to find the bone.</summary>
+		public string boneName;
+		public Transform parentReference;
+		public Mode mode;
+		public bool position, rotation, scale, zPosition = true;
+		[Range(0f, 1f)]
+		public float overrideAlpha = 1;
+		#endregion
+
+		public SkeletonUtility hierarchy;
+		[System.NonSerialized] public Bone bone;
+		[System.NonSerialized] public bool transformLerpComplete;
+		[System.NonSerialized] public bool valid;
+		Transform cachedTransform;
+		Transform skeletonTransform;
+		bool incompatibleTransformMode;
+		public bool IncompatibleTransformMode { get { return incompatibleTransformMode; } }
+
+		public void Reset () {
+			bone = null;
+			cachedTransform = transform;
+			valid = hierarchy != null && hierarchy.IsValid;
+			if (!valid)
+				return;
+			skeletonTransform = hierarchy.transform;
+			hierarchy.OnReset -= HandleOnReset;
+			hierarchy.OnReset += HandleOnReset;
+			DoUpdate(UpdatePhase.Local);
+		}
+
+		void OnEnable () {
+			if (hierarchy == null) hierarchy = transform.GetComponentInParent<SkeletonUtility>();
+			if (hierarchy == null) return;
+
+			hierarchy.RegisterBone(this);
+			hierarchy.OnReset += HandleOnReset;
+		}
+
+		void HandleOnReset () {
+			Reset();
+		}
+
+		void OnDisable () {
+			if (hierarchy != null) {
+				hierarchy.OnReset -= HandleOnReset;
+				hierarchy.UnregisterBone(this);
+			}
+		}
+
+		public void DoUpdate (UpdatePhase phase) {
+			if (!valid) {
+				Reset();
+				return;
+			}
+
+			var skeleton = hierarchy.Skeleton;
+
+			if (bone == null) {
+				if (string.IsNullOrEmpty(boneName)) return;
+				bone = skeleton.FindBone(boneName);
+				if (bone == null) {
+					Debug.LogError("Bone not found: " + boneName, this);
+					return;
+				}
+			}
+			if (!bone.Active) return;
+
+			float positionScale = hierarchy.PositionScale;
+
+			var thisTransform = cachedTransform;
+			float skeletonFlipRotation = Mathf.Sign(skeleton.ScaleX * skeleton.ScaleY);
+			if (mode == Mode.Follow) {
+				switch (phase) {
+					case UpdatePhase.Local:
+						if (position)
+							thisTransform.localPosition = new Vector3(bone.x * positionScale, bone.y * positionScale, 0);
+
+						if (rotation) {
+							if (bone.data.transformMode.InheritsRotation()) {
+								thisTransform.localRotation = Quaternion.Euler(0, 0, bone.rotation);
+							} else {
+								Vector3 euler = skeletonTransform.rotation.eulerAngles;
+								thisTransform.rotation = Quaternion.Euler(euler.x, euler.y, euler.z + (bone.WorldRotationX * skeletonFlipRotation));
+							}
+						}
+
+						if (scale) {
+							thisTransform.localScale = new Vector3(bone.scaleX, bone.scaleY, 1f);
+							incompatibleTransformMode = BoneTransformModeIncompatible(bone);
+						}
+						break;
+					case UpdatePhase.World:
+					case UpdatePhase.Complete:
+						// Use Applied transform values (ax, ay, AppliedRotation, ascale) if world values were modified by constraints.
+						if (!bone.appliedValid) {
+							bone.UpdateAppliedTransform();
+						}
+
+						if (position)
+							thisTransform.localPosition = new Vector3(bone.ax * positionScale, bone.ay * positionScale, 0);
+
+						if (rotation) {
+							if (bone.data.transformMode.InheritsRotation()) {
+								thisTransform.localRotation = Quaternion.Euler(0, 0, bone.AppliedRotation);
+							} else {
+								Vector3 euler = skeletonTransform.rotation.eulerAngles;
+								thisTransform.rotation = Quaternion.Euler(euler.x, euler.y, euler.z + (bone.WorldRotationX * skeletonFlipRotation));
+							}
+						}
+
+						if (scale) {
+							thisTransform.localScale = new Vector3(bone.ascaleX, bone.ascaleY, 1f);
+							incompatibleTransformMode = BoneTransformModeIncompatible(bone);
+						}
+						break;
+				}
+
+			} else if (mode == Mode.Override) {
+				if (transformLerpComplete)
+					return;
+
+				if (parentReference == null) {
+					if (position) {
+						Vector3 clp = thisTransform.localPosition / positionScale;
+						bone.x = Mathf.Lerp(bone.x, clp.x, overrideAlpha);
+						bone.y = Mathf.Lerp(bone.y, clp.y, overrideAlpha);
+					}
+
+					if (rotation) {
+						float angle = Mathf.LerpAngle(bone.Rotation, thisTransform.localRotation.eulerAngles.z, overrideAlpha);
+						bone.Rotation = angle;
+						bone.AppliedRotation = angle;
+					}
+
+					if (scale) {
+						Vector3 cls = thisTransform.localScale;
+						bone.scaleX = Mathf.Lerp(bone.scaleX, cls.x, overrideAlpha);
+						bone.scaleY = Mathf.Lerp(bone.scaleY, cls.y, overrideAlpha);
+					}
+
+				} else {
+					if (transformLerpComplete)
+						return;
+
+					if (position) {
+						Vector3 pos = parentReference.InverseTransformPoint(thisTransform.position) / positionScale;
+						bone.x = Mathf.Lerp(bone.x, pos.x, overrideAlpha);
+						bone.y = Mathf.Lerp(bone.y, pos.y, overrideAlpha);
+					}
+
+					if (rotation) {
+						float angle = Mathf.LerpAngle(bone.Rotation, Quaternion.LookRotation(Vector3.forward, parentReference.InverseTransformDirection(thisTransform.up)).eulerAngles.z, overrideAlpha);
+						bone.Rotation = angle;
+						bone.AppliedRotation = angle;
+					}
+
+					if (scale) {
+						Vector3 cls = thisTransform.localScale;
+						bone.scaleX = Mathf.Lerp(bone.scaleX, cls.x, overrideAlpha);
+						bone.scaleY = Mathf.Lerp(bone.scaleY, cls.y, overrideAlpha);
+					}
+
+					incompatibleTransformMode = BoneTransformModeIncompatible(bone);
+				}
+
+				transformLerpComplete = true;
+			}
+		}
+
+		public static bool BoneTransformModeIncompatible (Bone bone) {
+			return !bone.data.transformMode.InheritsScale();
+		}
+
+		public void AddBoundingBox (string skinName, string slotName, string attachmentName) {
+			SkeletonUtility.AddBoneRigidbody2D(transform.gameObject);
+			SkeletonUtility.AddBoundingBoxGameObject(bone.skeleton, skinName, slotName, attachmentName, transform);
+		}
+
+#if UNITY_EDITOR
+		void OnDrawGizmos () {
+			if (IncompatibleTransformMode)
+				Gizmos.DrawIcon(transform.position + new Vector3(0, 0.128f, 0), "icon-warning");
+		}
+		#endif
+	}
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: b238dfcde8209044b97d23f62bcaadf6
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,62 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, 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
+
+using UnityEngine;
+
+namespace Spine.Unity {
+
+	#if NEW_PREFAB_SYSTEM
+	[ExecuteAlways]
+	#else
+	[ExecuteInEditMode]
+	#endif
+	[RequireComponent(typeof(SkeletonUtilityBone))]
+	[HelpURL("http://esotericsoftware.com/spine-unity#SkeletonUtilityConstraint")]
+	public abstract class SkeletonUtilityConstraint : MonoBehaviour {
+
+		protected SkeletonUtilityBone bone;
+		protected SkeletonUtility hierarchy;
+
+		protected virtual void OnEnable () {
+			bone = GetComponent<SkeletonUtilityBone>();
+			hierarchy = transform.GetComponentInParent<SkeletonUtility>();
+			hierarchy.RegisterConstraint(this);
+		}
+
+		protected virtual void OnDisable () {
+			hierarchy.UnregisterConstraint(this);
+		}
+
+		public abstract void DoUpdate ();
+	}
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 522dbfcc6c916df4396f14f35048d185
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: