1

unity/Assets/Spine Examples/Scripts/AttackSpineboy.cs

@@ -0,0 +1,71 @@
+/******************************************************************************
+ * 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;
+using UnityEngine.UI;
+
+namespace Spine.Unity.Examples {
+	public class AttackSpineboy : MonoBehaviour {
+
+		public SkeletonAnimation spineboy;
+		public SkeletonAnimation attackerSpineboy;
+		public SpineGauge gauge;
+		public Text healthText;
+
+		int currentHealth = 100;
+		const int maxHealth = 100;
+
+		public AnimationReferenceAsset shoot, hit, idle, death;
+
+		public UnityEngine.Events.UnityEvent onAttack;
+
+		void Update () {
+			if (Input.GetKeyDown(KeyCode.Space)) {
+				currentHealth -= 10;
+				healthText.text = currentHealth + "/" + maxHealth;
+
+				attackerSpineboy.AnimationState.SetAnimation(1, shoot, false);
+				attackerSpineboy.AnimationState.AddEmptyAnimation(1, 0.5f, 2f);
+
+				if (currentHealth > 0) {
+					spineboy.AnimationState.SetAnimation(0, hit, false);
+					spineboy.AnimationState.AddAnimation(0, idle, true, 0);
+					gauge.fillPercent = (float)currentHealth/(float)maxHealth;
+					onAttack.Invoke();
+				} else {
+					if (currentHealth >= 0) {
+						gauge.fillPercent = 0;
+						spineboy.AnimationState.SetAnimation(0, death, false).TrackEnd = float.PositiveInfinity;
+					}
+				}
+			}
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/AttackSpineboy.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7eab8e63d650dc74c80d142cd4b9fe4b
+timeCreated: 1480095094
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/DataAssetsFromExportsExample.cs

@@ -0,0 +1,73 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class DataAssetsFromExportsExample : MonoBehaviour {
+
+		public TextAsset skeletonJson;
+		public TextAsset atlasText;
+		public Texture2D[] textures;
+		public Material materialPropertySource;
+
+		SpineAtlasAsset runtimeAtlasAsset;
+		SkeletonDataAsset runtimeSkeletonDataAsset;
+		SkeletonAnimation runtimeSkeletonAnimation;
+
+		void CreateRuntimeAssetsAndGameObject () {
+			// 1. Create the AtlasAsset (needs atlas text asset and textures, and materials/shader);
+			// 2. Create SkeletonDataAsset (needs json or binary asset file, and an AtlasAsset)
+			// 3. Create SkeletonAnimation (needs a valid SkeletonDataAsset)
+
+			runtimeAtlasAsset = SpineAtlasAsset.CreateRuntimeInstance(atlasText, textures, materialPropertySource, true);
+			runtimeSkeletonDataAsset = SkeletonDataAsset.CreateRuntimeInstance(skeletonJson, runtimeAtlasAsset, true);
+		}
+
+		IEnumerator Start () {
+			CreateRuntimeAssetsAndGameObject();
+			runtimeSkeletonDataAsset.GetSkeletonData(false); // preload.
+			yield return new WaitForSeconds(0.5f);
+
+			runtimeSkeletonAnimation = SkeletonAnimation.NewSkeletonAnimationGameObject(runtimeSkeletonDataAsset);
+
+			// Extra Stuff
+			runtimeSkeletonAnimation.Initialize(false);
+			runtimeSkeletonAnimation.Skeleton.SetSkin("base");
+			runtimeSkeletonAnimation.Skeleton.SetSlotsToSetupPose();
+			runtimeSkeletonAnimation.AnimationState.SetAnimation(0, "run", true);
+			runtimeSkeletonAnimation.GetComponent<MeshRenderer>().sortingOrder = 10;
+			runtimeSkeletonAnimation.transform.Translate(Vector3.down * 2);
+
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/DataAssetsFromExportsExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bb0837af7345d504db63d0c662fd12dc
+timeCreated: 1500249349
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/DraggableTransform.cs

@@ -0,0 +1,56 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class DraggableTransform : MonoBehaviour {
+
+		Vector2 mousePreviousWorld, mouseDeltaWorld;
+		Camera mainCamera;
+
+		void Start () {
+			mainCamera = Camera.main;
+		}
+
+		void Update () {
+			Vector2 mouseCurrent = Input.mousePosition;
+			Vector2 mouseCurrentWorld = mainCamera.ScreenToWorldPoint(new Vector3(mouseCurrent.x, mouseCurrent.y, -mainCamera.transform.position.z));
+
+			mouseDeltaWorld = mouseCurrentWorld - mousePreviousWorld;
+			mousePreviousWorld = mouseCurrentWorld;
+		}
+
+		void OnMouseDrag () {
+			transform.Translate(mouseDeltaWorld);
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/DraggableTransform.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ac0a69923492d1b4aa7ca656033ec6a3
+timeCreated: 1520587078
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/FootSoldierExample.cs

@@ -0,0 +1,103 @@
+/******************************************************************************
+ * 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.
+ *****************************************************************************/
+
+// Contributed by: Mitch Thompson
+
+using UnityEngine;
+using System.Collections;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class FootSoldierExample : MonoBehaviour {
+		[SpineAnimation("Idle")]
+		public string idleAnimation;
+
+		[SpineAnimation]
+		public string attackAnimation;
+
+		[SpineAnimation]
+		public string moveAnimation;
+
+		[SpineSlot]
+		public string eyesSlot;
+
+		[SpineAttachment(currentSkinOnly: true, slotField: "eyesSlot")]
+		public string eyesOpenAttachment;
+
+		[SpineAttachment(currentSkinOnly: true, slotField: "eyesSlot")]
+		public string blinkAttachment;
+
+		[Range(0, 0.2f)]
+		public float blinkDuration = 0.05f;
+
+		public KeyCode attackKey = KeyCode.Mouse0;
+		public KeyCode rightKey = KeyCode.D;
+		public KeyCode leftKey = KeyCode.A;
+
+		public float moveSpeed = 3;
+
+		SkeletonAnimation skeletonAnimation;
+
+		void Awake () {
+			skeletonAnimation = GetComponent<SkeletonAnimation>();
+			skeletonAnimation.OnRebuild += Apply;
+		}
+
+		void Apply (SkeletonRenderer skeletonRenderer) {
+			StartCoroutine(Blink());
+		}
+
+		void Update () {
+			if (Input.GetKey(attackKey)) {
+				skeletonAnimation.AnimationName = attackAnimation;
+			} else {
+				if (Input.GetKey(rightKey)) {
+					skeletonAnimation.AnimationName = moveAnimation;
+					skeletonAnimation.Skeleton.ScaleX = 1;
+					transform.Translate(moveSpeed * Time.deltaTime, 0, 0);
+				} else if(Input.GetKey(leftKey)) {
+					skeletonAnimation.AnimationName = moveAnimation;
+					skeletonAnimation.Skeleton.ScaleX = -1;
+					transform.Translate(-moveSpeed * Time.deltaTime, 0, 0);
+				} else {
+					skeletonAnimation.AnimationName = idleAnimation;
+				}
+			}
+		}
+
+		IEnumerator Blink() {
+			while (true) {
+				yield return new WaitForSeconds(Random.Range(0.25f, 3f));
+				skeletonAnimation.Skeleton.SetAttachment(eyesSlot, blinkAttachment);
+				yield return new WaitForSeconds(blinkDuration);
+				skeletonAnimation.Skeleton.SetAttachment(eyesSlot, eyesOpenAttachment);
+			}
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/FootSoldierExample.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 3c826b50b0cfee343be3bdbbf59d0f7c
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a34eef132f2b4da45aa8023dbe5934e7
+folderAsset: yes
+timeCreated: 1452593684
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/BasicPlatformerController.cs

@@ -0,0 +1,220 @@
+/******************************************************************************
+ * 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;
+using UnityEngine.Events;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+
+	[RequireComponent(typeof(CharacterController))]
+	public class BasicPlatformerController : MonoBehaviour {
+
+		public enum CharacterState {
+			None,
+			Idle,
+			Walk,
+			Run,
+			Crouch,
+			Rise,
+			Fall,
+			Attack
+		}
+
+		[Header("Components")]
+		public CharacterController controller;
+
+		[Header("Controls")]
+		public string XAxis = "Horizontal";
+		public string YAxis = "Vertical";
+		public string JumpButton = "Jump";
+
+		[Header("Moving")]
+		public float walkSpeed = 1.5f;
+		public float runSpeed = 7f;
+		public float gravityScale = 6.6f;
+
+		[Header("Jumping")]
+		public float jumpSpeed = 25;
+		public float minimumJumpDuration = 0.5f;
+		public float jumpInterruptFactor = 0.5f;
+		public float forceCrouchVelocity = 25;
+		public float forceCrouchDuration = 0.5f;
+
+		[Header("Animation")]
+		public SkeletonAnimationHandleExample animationHandle;
+
+		// Events
+		public event UnityAction OnJump, OnLand, OnHardLand;
+
+		Vector2 input = default(Vector2);
+		Vector3 velocity = default(Vector3);
+		float minimumJumpEndTime = 0;
+		float forceCrouchEndTime;
+		bool wasGrounded = false;
+
+		CharacterState previousState, currentState;
+
+		void Update () {
+			float dt = Time.deltaTime;
+			bool isGrounded = controller.isGrounded;
+			bool landed = !wasGrounded && isGrounded;
+
+			// Dummy input.
+			input.x = Input.GetAxis(XAxis);
+			input.y = Input.GetAxis(YAxis);
+			bool inputJumpStop = Input.GetButtonUp(JumpButton);
+			bool inputJumpStart = Input.GetButtonDown(JumpButton);
+			bool doCrouch = (isGrounded && input.y < -0.5f) || (forceCrouchEndTime > Time.time);
+			bool doJumpInterrupt = false;
+			bool doJump = false;
+			bool hardLand = false;
+
+			if (landed) {
+				if (-velocity.y > forceCrouchVelocity) {
+					hardLand = true;
+					doCrouch = true;
+					forceCrouchEndTime = Time.time + forceCrouchDuration;
+				}
+			}
+
+			if (!doCrouch) {
+				if (isGrounded) {
+					if (inputJumpStart) {
+						doJump = true;
+					}
+				} else {
+					doJumpInterrupt = inputJumpStop && Time.time < minimumJumpEndTime;
+				}
+			}
+
+			// Dummy physics and controller using UnityEngine.CharacterController.
+			Vector3 gravityDeltaVelocity = Physics.gravity * gravityScale * dt;
+
+			if (doJump) {
+				velocity.y = jumpSpeed;
+				minimumJumpEndTime = Time.time + minimumJumpDuration;
+			} else if (doJumpInterrupt) {
+				if (velocity.y > 0)
+					velocity.y *= jumpInterruptFactor;
+			}
+
+			velocity.x = 0;
+			if (!doCrouch) {
+				if (input.x != 0) {
+					velocity.x = Mathf.Abs(input.x) > 0.6f ? runSpeed : walkSpeed;
+					velocity.x *= Mathf.Sign(input.x);
+				}
+			}
+
+
+			if (!isGrounded) {
+				if (wasGrounded) {
+					if (velocity.y < 0)
+						velocity.y = 0;
+				} else {
+					velocity += gravityDeltaVelocity;
+				}
+			}
+			controller.Move(velocity * dt);
+			wasGrounded = isGrounded;
+
+			// Determine and store character state
+			if (isGrounded) {
+				if (doCrouch) {
+					currentState = CharacterState.Crouch;
+				} else {
+					if (input.x == 0)
+						currentState = CharacterState.Idle;
+					else
+						currentState = Mathf.Abs(input.x) > 0.6f ? CharacterState.Run : CharacterState.Walk;
+				}
+			} else {
+				currentState = velocity.y > 0 ? CharacterState.Rise : CharacterState.Fall;
+			}
+
+			bool stateChanged = previousState != currentState;
+			previousState = currentState;
+
+			// Animation
+			// Do not modify character parameters or state in this phase. Just read them.
+			// Detect changes in state, and communicate with animation handle if it changes.
+			if (stateChanged)
+				HandleStateChanged();
+
+			if (input.x != 0)
+				animationHandle.SetFlip(input.x);
+
+			// Fire events.
+			if (doJump) {
+				OnJump.Invoke();
+			}
+			if (landed) {
+				if (hardLand) {
+					OnHardLand.Invoke();
+				} else {
+					OnLand.Invoke();
+				}
+			}
+		}
+
+		void HandleStateChanged () {
+			// When the state changes, notify the animation handle of the new state.
+			string stateName = null;
+			switch (currentState) {
+				case CharacterState.Idle:
+					stateName = "idle";
+					break;
+				case CharacterState.Walk:
+					stateName = "walk";
+					break;
+				case CharacterState.Run:
+					stateName = "run";
+					break;
+				case CharacterState.Crouch:
+					stateName = "crouch";
+					break;
+				case CharacterState.Rise:
+					stateName = "rise";
+					break;
+				case CharacterState.Fall:
+					stateName = "fall";
+					break;
+				case CharacterState.Attack:
+					stateName = "attack";
+					break;
+				default:
+					break;
+			}
+
+			animationHandle.PlayAnimationForState(stateName, 0);
+		}
+
+	}
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/BasicPlatformerController.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 27b3e3370f55c0a438ef0a10c2eba510
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/ConstrainedCamera.cs

@@ -0,0 +1,52 @@
+/******************************************************************************
+ * 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.
+ *****************************************************************************/
+
+// Contributed by: Mitch Thompson
+
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class ConstrainedCamera : MonoBehaviour {
+		public Transform target;
+		public Vector3 offset;
+		public Vector3 min;
+		public Vector3 max;
+		public float smoothing = 5f;
+
+		// Update is called once per frame
+		void LateUpdate () {
+			Vector3 goalPoint = target.position + offset;
+			goalPoint.x = Mathf.Clamp(goalPoint.x, min.x, max.x);
+			goalPoint.y = Mathf.Clamp(goalPoint.y, min.y, max.y);
+			goalPoint.z = Mathf.Clamp(goalPoint.z, min.z, max.z);
+
+			transform.position = Vector3.Lerp(transform.position, goalPoint, smoothing * Time.deltaTime);
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/ConstrainedCamera.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 6df2d8b571e22504284108b691b4a3cd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/Raptor.cs

@@ -0,0 +1,66 @@
+/******************************************************************************
+ * 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;
+using System.Collections;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class Raptor : MonoBehaviour {
+
+		#region Inspector
+		public AnimationReferenceAsset walk;
+		public AnimationReferenceAsset gungrab;
+		public AnimationReferenceAsset gunkeep;
+		#endregion
+
+		SkeletonAnimation skeletonAnimation;
+
+		void Start () {
+			skeletonAnimation = GetComponent<SkeletonAnimation>();
+			StartCoroutine(GunGrabRoutine());
+		}
+
+		IEnumerator GunGrabRoutine () {
+			// Play the walk animation on track 0.
+			skeletonAnimation.AnimationState.SetAnimation(0, walk, true);
+
+			// Repeatedly play the gungrab and gunkeep animation on track 1.
+			while (true) {
+				yield return new WaitForSeconds(Random.Range(0.5f, 3f));
+				skeletonAnimation.AnimationState.SetAnimation(1, gungrab, false);
+
+				yield return new WaitForSeconds(Random.Range(0.5f, 3f));
+				skeletonAnimation.AnimationState.SetAnimation(1, gunkeep, false);
+			}
+
+		}
+
+	}
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/Raptor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 8b0d38dc0b91fb443a41838d475ae49b
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineBeginnerTwo.cs

@@ -0,0 +1,109 @@
+/******************************************************************************
+ * 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;
+using System.Collections;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class SpineBeginnerTwo : MonoBehaviour {
+
+		#region Inspector
+		// [SpineAnimation] attribute allows an Inspector dropdown of Spine animation names coming form SkeletonAnimation.
+		[SpineAnimation]
+		public string runAnimationName;
+
+		[SpineAnimation]
+		public string idleAnimationName;
+
+		[SpineAnimation]
+		public string walkAnimationName;
+
+		[SpineAnimation]
+		public string shootAnimationName;
+
+		[Header("Transitions")]
+		[SpineAnimation]
+		public string idleTurnAnimationName;
+
+		[SpineAnimation]
+		public string runToIdleAnimationName;
+
+		public float runWalkDuration = 1.5f;
+		#endregion
+
+		SkeletonAnimation skeletonAnimation;
+
+		// Spine.AnimationState and Spine.Skeleton are not Unity-serialized objects. You will not see them as fields in the inspector.
+		public Spine.AnimationState spineAnimationState;
+		public Spine.Skeleton skeleton;
+
+		void Start () {
+			// Make sure you get these AnimationState and Skeleton references in Start or Later.
+			// Getting and using them in Awake is not guaranteed by default execution order.
+			skeletonAnimation = GetComponent<SkeletonAnimation>();
+			spineAnimationState = skeletonAnimation.AnimationState;
+			skeleton = skeletonAnimation.Skeleton;
+
+			StartCoroutine(DoDemoRoutine());
+		}
+
+		/// This is an infinitely repeating Unity Coroutine. Read the Unity documentation on Coroutines to learn more.
+		IEnumerator DoDemoRoutine () {
+			while (true) {
+				// SetAnimation is the basic way to set an animation.
+				// SetAnimation sets the animation and starts playing it from the beginning.
+				// Common Mistake: If you keep calling it in Update, it will keep showing the first pose of the animation, do don't do that.
+
+				spineAnimationState.SetAnimation(0, walkAnimationName, true);
+				yield return new WaitForSeconds(runWalkDuration);
+
+				spineAnimationState.SetAnimation(0, runAnimationName, true);
+				yield return new WaitForSeconds(runWalkDuration);
+
+				// AddAnimation queues up an animation to play after the previous one ends.
+				spineAnimationState.SetAnimation(0, runToIdleAnimationName, false);
+				spineAnimationState.AddAnimation(0, idleAnimationName, true, 0);
+				yield return new WaitForSeconds(1f);
+
+				skeleton.ScaleX = -1;		// skeleton allows you to flip the skeleton.
+				spineAnimationState.SetAnimation(0, idleTurnAnimationName, false);
+				spineAnimationState.AddAnimation(0, idleAnimationName, true, 0);
+				yield return new WaitForSeconds(0.5f);
+				skeleton.ScaleX = 1;
+				spineAnimationState.SetAnimation(0, idleTurnAnimationName, false);
+				spineAnimationState.AddAnimation(0, idleAnimationName, true, 0);
+				yield return new WaitForSeconds(0.5f);
+
+			}
+		}
+
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineBeginnerTwo.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a57fe3aaf2b1f964182d90c5546754d1
+timeCreated: 1452593662
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineBlinkPlayer.cs

@@ -0,0 +1,51 @@
+/******************************************************************************
+ * 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;
+using System.Collections;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class SpineBlinkPlayer : MonoBehaviour {
+		const int BlinkTrack = 1;
+
+		public AnimationReferenceAsset blinkAnimation;
+		public float minimumDelay = 0.15f;
+		public float maximumDelay = 3f;
+
+		IEnumerator Start () {
+			var skeletonAnimation = GetComponent<SkeletonAnimation>(); if (skeletonAnimation == null) yield break;
+			while (true) {
+				skeletonAnimation.AnimationState.SetAnimation(SpineBlinkPlayer.BlinkTrack, blinkAnimation, false);
+				yield return new WaitForSeconds(Random.Range(minimumDelay, maximumDelay));
+			}
+		}
+
+	}
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineBlinkPlayer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5a5ef44bf3e0d864794c0da71c84363d
+timeCreated: 1455509353
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyBeginnerInput.cs

@@ -0,0 +1,68 @@
+/******************************************************************************
+ * 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;
+using System.Collections;
+
+namespace Spine.Unity.Examples {
+	public class SpineboyBeginnerInput : MonoBehaviour {
+		#region Inspector
+		public string horizontalAxis = "Horizontal";
+		public string attackButton = "Fire1";
+		public string aimButton = "Fire2";
+		public string jumpButton = "Jump";
+
+		public SpineboyBeginnerModel model;
+
+		void OnValidate () {
+			if (model == null)
+				model = GetComponent<SpineboyBeginnerModel>();
+		}
+		#endregion
+
+		void Update () {
+			if (model == null) return;
+
+			float currentHorizontal = Input.GetAxisRaw(horizontalAxis);
+			model.TryMove(currentHorizontal);
+
+			if (Input.GetButton(attackButton))
+				model.TryShoot();
+
+			if (Input.GetButtonDown(aimButton))
+				model.StartAim();
+			if (Input.GetButtonUp(aimButton))
+				model.StopAim();
+
+			if (Input.GetButtonDown(jumpButton))
+				model.TryJump();
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyBeginnerInput.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8f685123e0610c347a7b2c03c8a19535
+timeCreated: 1452595430
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyBeginnerModel.cs

@@ -0,0 +1,124 @@
+/******************************************************************************
+ * 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;
+using System.Collections;
+
+namespace Spine.Unity.Examples {
+	[SelectionBase]
+	public class SpineboyBeginnerModel : MonoBehaviour {
+
+		#region Inspector
+		[Header("Current State")]
+		public SpineBeginnerBodyState state;
+		public bool facingLeft;
+		[Range(-1f, 1f)]
+		public float currentSpeed;
+
+		[Header("Balance")]
+		public float shootInterval = 0.12f;
+		#endregion
+
+		float lastShootTime;
+		public event System.Action ShootEvent;	// Lets other scripts know when Spineboy is shooting. Check C# Documentation to learn more about events and delegates.
+		public event System.Action StartAimEvent;   // Lets other scripts know when Spineboy is aiming.
+		public event System.Action StopAimEvent;   // Lets other scripts know when Spineboy is no longer aiming.
+
+		#region API
+		public void TryJump () {
+			StartCoroutine(JumpRoutine());
+		}
+
+		public void TryShoot () {
+			float currentTime = Time.time;
+
+			if (currentTime - lastShootTime > shootInterval) {
+				lastShootTime = currentTime;
+				if (ShootEvent != null) ShootEvent();	// Fire the "ShootEvent" event.
+			}
+		}
+
+		public void StartAim () {
+			if (StartAimEvent != null) StartAimEvent();   // Fire the "StartAimEvent" event.
+		}
+
+		public void StopAim () {
+			if (StopAimEvent != null) StopAimEvent();   // Fire the "StopAimEvent" event.
+		}
+
+		public void TryMove (float speed) {
+			currentSpeed = speed; // show the "speed" in the Inspector.
+
+			if (speed != 0) {
+				bool speedIsNegative = (speed < 0f);
+				facingLeft = speedIsNegative; // Change facing direction whenever speed is not 0.
+			}
+
+			if (state != SpineBeginnerBodyState.Jumping) {
+				state = (speed == 0) ? SpineBeginnerBodyState.Idle : SpineBeginnerBodyState.Running;
+			}
+
+		}
+		#endregion
+
+		IEnumerator JumpRoutine () {
+			if (state == SpineBeginnerBodyState.Jumping) yield break;	// Don't jump when already jumping.
+
+			state = SpineBeginnerBodyState.Jumping;
+
+			// Fake jumping.
+			{
+				var pos = transform.localPosition;
+				const float jumpTime = 1.2f;
+				const float half = jumpTime * 0.5f;
+				const float jumpPower = 20f;
+				for (float t = 0; t < half; t += Time.deltaTime) {
+					float d = jumpPower * (half - t);
+					transform.Translate((d * Time.deltaTime) * Vector3.up);
+					yield return null;
+				}
+				for (float t = 0; t < half; t += Time.deltaTime) {
+					float d = jumpPower * t;
+					transform.Translate((d * Time.deltaTime) * Vector3.down);
+					yield return null;
+				}
+				transform.localPosition = pos;
+			}
+
+			state = SpineBeginnerBodyState.Idle;
+		}
+
+	}
+
+	public enum SpineBeginnerBodyState {
+		Idle,
+		Running,
+		Jumping
+	}
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyBeginnerModel.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f999dde27e9711a45b0ee1b0d25217ec
+timeCreated: 1452594812
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyBeginnerView.cs

@@ -0,0 +1,170 @@
+/******************************************************************************
+ * 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;
+using System.Collections;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class SpineboyBeginnerView : MonoBehaviour {
+
+		#region Inspector
+		[Header("Components")]
+		public SpineboyBeginnerModel model;
+		public SkeletonAnimation skeletonAnimation;
+
+		public AnimationReferenceAsset run, idle, aim, shoot, jump;
+		public EventDataReferenceAsset footstepEvent;
+
+		[Header("Audio")]
+		public float footstepPitchOffset = 0.2f;
+		public float gunsoundPitchOffset = 0.13f;
+		public AudioSource footstepSource, gunSource, jumpSource;
+
+		[Header("Effects")]
+		public ParticleSystem gunParticles;
+		#endregion
+
+		SpineBeginnerBodyState previousViewState;
+
+		void Start () {
+			if (skeletonAnimation == null) return;
+			model.ShootEvent += PlayShoot;
+			model.StartAimEvent += StartPlayingAim;
+			model.StopAimEvent += StopPlayingAim;
+			skeletonAnimation.AnimationState.Event += HandleEvent;
+		}
+
+		void HandleEvent (Spine.TrackEntry trackEntry, Spine.Event e) {
+			if (e.Data == footstepEvent.EventData)
+				PlayFootstepSound();
+		}
+
+		void Update () {
+			if (skeletonAnimation == null) return;
+			if (model == null) return;
+
+			if ((skeletonAnimation.skeleton.ScaleX < 0) != model.facingLeft) {	// Detect changes in model.facingLeft
+				Turn(model.facingLeft);
+			}
+
+			// Detect changes in model.state
+			var currentModelState = model.state;
+
+			if (previousViewState != currentModelState) {
+				PlayNewStableAnimation();
+			}
+
+			previousViewState = currentModelState;
+		}
+
+		void PlayNewStableAnimation () {
+			var newModelState = model.state;
+			Animation nextAnimation;
+
+			// Add conditionals to not interrupt transient animations.
+
+			if (previousViewState == SpineBeginnerBodyState.Jumping && newModelState != SpineBeginnerBodyState.Jumping) {
+				PlayFootstepSound();
+			}
+
+			if (newModelState == SpineBeginnerBodyState.Jumping) {
+				jumpSource.Play();
+				nextAnimation = jump;
+			} else {
+				if (newModelState == SpineBeginnerBodyState.Running) {
+					nextAnimation = run;
+				} else {
+					nextAnimation = idle;
+				}
+			}
+
+			skeletonAnimation.AnimationState.SetAnimation(0, nextAnimation, true);
+		}
+
+		void PlayFootstepSound () {
+			footstepSource.Play();
+			footstepSource.pitch = GetRandomPitch(footstepPitchOffset);
+		}
+
+		[ContextMenu("Check Tracks")]
+		void CheckTracks () {
+			var state = skeletonAnimation.AnimationState;
+			Debug.Log(state.GetCurrent(0));
+			Debug.Log(state.GetCurrent(1));
+		}
+
+		#region Transient Actions
+		public void PlayShoot () {
+			// Play the shoot animation on track 1.
+			var shootTrack = skeletonAnimation.AnimationState.SetAnimation(1, shoot, false);
+			shootTrack.AttachmentThreshold = 1f;
+			shootTrack.MixDuration = 0f;
+			var empty1 = skeletonAnimation.state.AddEmptyAnimation(1, 0.5f, 0.1f);
+			empty1.AttachmentThreshold = 1f;
+
+			// Play the aim animation on track 2 to aim at the mouse target.
+			var aimTrack = skeletonAnimation.AnimationState.SetAnimation(2, aim, false);
+			aimTrack.AttachmentThreshold = 1f;
+			aimTrack.MixDuration = 0f;
+			var empty2 = skeletonAnimation.state.AddEmptyAnimation(2, 0.5f, 0.1f);
+			empty2.AttachmentThreshold = 1f;
+
+			gunSource.pitch = GetRandomPitch(gunsoundPitchOffset);
+			gunSource.Play();
+			//gunParticles.randomSeed = (uint)Random.Range(0, 100);
+			gunParticles.Play();
+		}
+
+		public void StartPlayingAim () {
+			// Play the aim animation on track 2 to aim at the mouse target.
+			var aimTrack = skeletonAnimation.AnimationState.SetAnimation(2, aim, true);
+			aimTrack.AttachmentThreshold = 1f;
+			aimTrack.MixDuration = 0f;
+		}
+
+		public void StopPlayingAim () {
+			var empty2 = skeletonAnimation.state.AddEmptyAnimation(2, 0.5f, 0.1f);
+			empty2.AttachmentThreshold = 1f;
+		}
+
+		public void Turn (bool facingLeft) {
+			skeletonAnimation.Skeleton.ScaleX = facingLeft ? -1f : 1f;
+			// Maybe play a transient turning animation too, then call ChangeStableAnimation.
+		}
+		#endregion
+
+		#region Utility
+		public float GetRandomPitch (float maxPitchOffset) {
+			return 1f + Random.Range(-maxPitchOffset, maxPitchOffset);
+		}
+		#endregion
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyBeginnerView.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b59f510ae90fd1a419f19ed805e6e229
+timeCreated: 1452594730
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyTargetController.cs

@@ -0,0 +1,61 @@
+/******************************************************************************
+ * 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.Examples {
+	public class SpineboyTargetController : MonoBehaviour {
+
+		public SkeletonAnimation skeletonAnimation;
+
+		[SpineBone(dataField:"skeletonAnimation")]
+		public string boneName;
+		public Camera cam;
+
+		Bone bone;
+
+		void OnValidate () {
+			if (skeletonAnimation == null) skeletonAnimation = GetComponent<SkeletonAnimation>();
+		}
+
+		void Start () {
+			bone = skeletonAnimation.Skeleton.FindBone(boneName);
+		}
+
+		void Update () {
+			var mousePosition = Input.mousePosition;
+			var worldMousePosition = cam.ScreenToWorldPoint(mousePosition);
+			var skeletonSpacePoint = skeletonAnimation.transform.InverseTransformPoint(worldMousePosition);
+			skeletonSpacePoint.x *= skeletonAnimation.Skeleton.ScaleX;
+			skeletonSpacePoint.y *= skeletonAnimation.Skeleton.ScaleY;
+			bone.SetLocalPosition(skeletonSpacePoint);
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/SpineboyTargetController.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: af275876c7b01264b85161629a9bc217
+timeCreated: 1489915484
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/TransitionDictionaryExample.cs

@@ -0,0 +1,64 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+
+	// This is an example of how you could store animation transitions for use in your animation system.
+	// More ideally, this would be stored in a ScriptableObject in asset form rather than in a MonoBehaviour.
+	public sealed class TransitionDictionaryExample : MonoBehaviour {
+
+		[System.Serializable]
+		public struct SerializedEntry {
+			public AnimationReferenceAsset from;
+			public AnimationReferenceAsset to;
+			public AnimationReferenceAsset transition;
+		}
+
+		[SerializeField]
+		List<SerializedEntry> transitions = new List<SerializedEntry>();
+		readonly Dictionary<AnimationStateData.AnimationPair, Animation> dictionary = new Dictionary<AnimationStateData.AnimationPair, Animation>();
+
+		void Start () {
+			dictionary.Clear();
+			foreach (var e in transitions) {
+				dictionary.Add(new AnimationStateData.AnimationPair(e.from.Animation, e.to.Animation), e.transition.Animation);
+			}
+		}
+
+		public Animation GetTransition (Animation from, Animation to) {
+			Animation result;
+			dictionary.TryGetValue(new AnimationStateData.AnimationPair(from, to), out result);
+			return result;
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Getting Started Scripts/TransitionDictionaryExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 69a52bf79b7e78e4cb1dfd2d2e698c2d
+timeCreated: 1524024687
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Goblins.cs

@@ -0,0 +1,67 @@
+/******************************************************************************
+ * 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;
+using Spine;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class Goblins : MonoBehaviour {
+		SkeletonAnimation skeletonAnimation;
+		Bone headBone;
+		bool girlSkin;
+
+		[Range(-360, 360)]
+		public float extraRotation;
+
+		public void Start () {
+			skeletonAnimation = GetComponent<SkeletonAnimation>();
+			headBone = skeletonAnimation.Skeleton.FindBone("head");
+			skeletonAnimation.UpdateLocal += UpdateLocal;
+		}
+
+		// This is called after the animation is applied to the skeleton and can be used to adjust the bones dynamically.
+		public void UpdateLocal (ISkeletonAnimation skeletonRenderer) {
+			headBone.Rotation += extraRotation;
+		}
+
+		public void OnMouseDown () {
+			skeletonAnimation.Skeleton.SetSkin(girlSkin ? "goblin" : "goblingirl");
+			skeletonAnimation.Skeleton.SetSlotsToSetupPose();
+
+			girlSkin = !girlSkin;
+
+			if (girlSkin) {
+				skeletonAnimation.Skeleton.SetAttachment("right-hand-item", null);
+				skeletonAnimation.Skeleton.SetAttachment("left-hand-item", "spear");
+			} else
+				skeletonAnimation.Skeleton.SetAttachment("left-hand-item", "dagger");
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Goblins.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 40a82af6554a7594f9ffa9ac8dde212f
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/HandleEventWithAudioExample.cs

@@ -0,0 +1,83 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class HandleEventWithAudioExample : MonoBehaviour {
+
+		public SkeletonAnimation skeletonAnimation;
+		[SpineEvent(dataField: "skeletonAnimation", fallbackToTextField: true)]
+		public string eventName;
+
+		[Space]
+		public AudioSource audioSource;
+		public AudioClip audioClip;
+		public float basePitch = 1f;
+		public float randomPitchOffset = 0.1f;
+
+		[Space]
+		public bool logDebugMessage = false;
+
+		Spine.EventData eventData;
+
+		void OnValidate () {
+			if (skeletonAnimation == null) GetComponent<SkeletonAnimation>();
+			if (audioSource == null) GetComponent<AudioSource>();
+		}
+
+		void Start () {
+			if (audioSource == null) return;
+			if (skeletonAnimation == null) return;
+			skeletonAnimation.Initialize(false);
+			if (!skeletonAnimation.valid) return;
+
+			eventData = skeletonAnimation.Skeleton.Data.FindEvent(eventName);
+			skeletonAnimation.AnimationState.Event += HandleAnimationStateEvent;
+		}
+
+		private void HandleAnimationStateEvent (TrackEntry trackEntry, Event e) {
+			if (logDebugMessage) Debug.Log("Event fired! " + e.Data.Name);
+			//bool eventMatch = string.Equals(e.Data.Name, eventName, System.StringComparison.Ordinal); // Testing recommendation: String compare.
+			bool eventMatch = (eventData == e.Data); // Performance recommendation: Match cached reference instead of string.
+			if (eventMatch) {
+				Play();
+			}
+		}
+
+		public void Play () {
+			audioSource.pitch = basePitch + Random.Range(-randomPitchOffset, randomPitchOffset);
+			audioSource.clip = audioClip;
+			audioSource.Play();
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/HandleEventWithAudioExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1d55a3bd6ac81af44b2f9a4447f2ae72
+timeCreated: 1516481531
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/HeroEffectsHandlerExample.cs

@@ -0,0 +1,47 @@
+/******************************************************************************
+ * 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;
+using UnityEngine.Events;
+
+namespace Spine.Unity.Examples {
+	public class HeroEffectsHandlerExample : MonoBehaviour {
+		public BasicPlatformerController eventSource;
+		public UnityEvent OnJump, OnLand, OnHardLand;
+
+		public void Awake () {
+			if (eventSource == null)
+				return;
+
+			eventSource.OnLand += OnLand.Invoke;
+			eventSource.OnJump += OnJump.Invoke;
+			eventSource.OnHardLand += OnHardLand.Invoke;
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/HeroEffectsHandlerExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8a0f8a82c5d8a334db6996478778b892
+timeCreated: 1545916292
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/HurtFlashEffect.cs

@@ -0,0 +1,77 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class HurtFlashEffect : MonoBehaviour {
+
+	const int DefaultFlashCount = 3;
+
+	public int flashCount = DefaultFlashCount;
+	public Color flashColor = Color.white;
+	[Range(1f/120f, 1f/15f)]
+	public float interval = 1f/60f;
+	public string fillPhaseProperty = "_FillPhase";
+	public string fillColorProperty = "_FillColor";
+
+	MaterialPropertyBlock mpb;
+	MeshRenderer meshRenderer;
+
+	public void Flash () {
+		if (mpb == null) mpb = new MaterialPropertyBlock();
+		if (meshRenderer == null) meshRenderer = GetComponent<MeshRenderer>();
+		meshRenderer.GetPropertyBlock(mpb);
+
+		StartCoroutine(FlashRoutine());
+	}
+
+	IEnumerator FlashRoutine () {
+		if (flashCount < 0) flashCount = DefaultFlashCount;
+		int fillPhase = Shader.PropertyToID(fillPhaseProperty);
+		int fillColor = Shader.PropertyToID(fillColorProperty);
+
+		var wait = new WaitForSeconds(interval);
+
+		for (int i = 0; i < flashCount; i++) {
+			mpb.SetColor(fillColor, flashColor);
+			mpb.SetFloat(fillPhase, 1f);
+			meshRenderer.SetPropertyBlock(mpb);
+			yield return wait;
+
+			mpb.SetFloat(fillPhase, 0f);
+			meshRenderer.SetPropertyBlock(mpb);
+			yield return wait;
+		}
+
+		yield return null;
+	}
+
+}

unity/Assets/Spine Examples/Scripts/HurtFlashEffect.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 395f769061839bf488f157c37d23835d
+timeCreated: 1497416645
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MaterialPropertyBlockExample.cs

@@ -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.
+ *****************************************************************************/
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class MaterialPropertyBlockExample : MonoBehaviour {
+
+		public float timeInterval = 1f;
+		public Gradient randomColors = new Gradient();
+		public string colorPropertyName = "_FillColor";
+
+		MaterialPropertyBlock mpb;
+		float timeToNextColor = 0;
+
+		void Start () {
+			mpb = new MaterialPropertyBlock();
+		}
+
+		void Update () {
+			if (timeToNextColor <= 0) {
+				timeToNextColor = timeInterval;
+
+				Color newColor = randomColors.Evaluate(UnityEngine.Random.value);
+				mpb.SetColor(colorPropertyName, newColor);
+				GetComponent<MeshRenderer>().SetPropertyBlock(mpb);
+			}
+
+			timeToNextColor -= Time.deltaTime;
+		}
+
+	}
+
+}

unity/Assets/Spine Examples/Scripts/MaterialPropertyBlockExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0456e5bde0b34594782f280f40128902
+timeCreated: 1516388202
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MaterialReplacementExample.cs

@@ -0,0 +1,75 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class MaterialReplacementExample : MonoBehaviour {
+
+		public Material originalMaterial;
+		public Material replacementMaterial;
+		public bool replacementEnabled = true;
+		public SkeletonAnimation skeletonAnimation;
+
+		[Space]
+		public string phasePropertyName = "_FillPhase";
+		[Range(0f, 1f)] public float phase = 1f;
+
+		bool previousEnabled;
+		MaterialPropertyBlock mpb;
+
+		void Start () {
+			previousEnabled = replacementEnabled;
+			SetReplacementEnabled(replacementEnabled);
+			mpb = new MaterialPropertyBlock();
+		}
+
+		void Update () {
+			mpb.SetFloat(phasePropertyName, phase);
+			GetComponent<MeshRenderer>().SetPropertyBlock(mpb);
+
+			if (previousEnabled != replacementEnabled)
+				SetReplacementEnabled(replacementEnabled);
+
+			previousEnabled = replacementEnabled;
+
+		}
+
+		void SetReplacementEnabled (bool active) {
+			if (replacementEnabled) {
+				skeletonAnimation.CustomMaterialOverride[originalMaterial] = replacementMaterial;
+			} else {
+				skeletonAnimation.CustomMaterialOverride.Remove(originalMaterial);
+			}
+		}
+
+	}
+}

unity/Assets/Spine Examples/Scripts/MaterialReplacementExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 62982591830b87b45a3f6efd3ee82630
+timeCreated: 1539082420
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mecanim as Logic.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: deef60f3c6fd9ae45b2c4dfcac0706f1
+folderAsset: yes
+timeCreated: 1545227769
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mecanim as Logic/DummyMecanimControllerExample.cs

@@ -0,0 +1,104 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class DummyMecanimControllerExample : MonoBehaviour {
+
+		public Animator logicAnimator;
+		public SkeletonAnimationHandleExample animationHandle;
+
+		[Header("Controls")]
+		public KeyCode walkButton = KeyCode.LeftShift;
+		public KeyCode jumpButton = KeyCode.Space;
+
+		[Header("Animator Properties")]
+		public string horizontalSpeedProperty = "Speed";
+		public string verticalSpeedProperty = "VerticalSpeed";
+		public string groundedProperty = "Grounded";
+
+		[Header("Fake Physics")]
+		public float jumpDuration = 1.5f;
+		public Vector2 speed;
+		public bool isGrounded;
+
+		void Awake () {
+			isGrounded = true;
+		}
+
+		void Update () {
+			float x = Input.GetAxisRaw("Horizontal");
+			if (Input.GetKey(walkButton)) {
+				x *= 0.4f;
+			}
+
+			speed.x = x;
+
+			// Flip skeleton.
+			if (x != 0) {
+				animationHandle.SetFlip(x);
+			}
+
+			if (Input.GetKeyDown(jumpButton)) {
+				if (isGrounded)
+					StartCoroutine(FakeJump());
+			}
+
+			logicAnimator.SetFloat(horizontalSpeedProperty, Mathf.Abs(speed.x));
+			logicAnimator.SetFloat(verticalSpeedProperty, speed.y);
+			logicAnimator.SetBool(groundedProperty, isGrounded);
+		}
+
+		IEnumerator FakeJump () {
+			// Rise
+			isGrounded = false;
+			speed.y = 10f;
+			float durationLeft = jumpDuration * 0.5f;
+			while (durationLeft > 0) {
+				durationLeft -= Time.deltaTime;
+				if (!Input.GetKey(jumpButton)) break;
+				yield return null;
+			}
+
+			// Fall
+			speed.y = -10f;
+			float fallDuration = (jumpDuration * 0.5f) - durationLeft;
+			yield return new WaitForSeconds(fallDuration);
+
+			// Land
+			speed.y = 0f;
+			isGrounded = true;
+			yield return null;
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Mecanim as Logic/DummyMecanimControllerExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 782062825deffd64ba7e7e9f978788e5
+timeCreated: 1531300740
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mecanim as Logic/MecanimToAnimationHandleExample.cs

@@ -0,0 +1,51 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+
+	// This StateMachineBehaviour handles sending the Mecanim state information to the component that handles playing the Spine animations.
+	public class MecanimToAnimationHandleExample : StateMachineBehaviour {
+		SkeletonAnimationHandleExample animationHandle;
+		bool initialized;
+
+		override public void OnStateEnter (Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
+			if (!initialized) {
+				animationHandle = animator.GetComponent<SkeletonAnimationHandleExample>();
+				initialized = true;
+			}
+
+			animationHandle.PlayAnimationForState(stateInfo.shortNameHash, layerIndex);
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Mecanim as Logic/MecanimToAnimationHandleExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 16f3a0143bc0dbc4793717b6d2ff94a2
+timeCreated: 1545230670
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mecanim as Logic/SkeletonAnimationHandleExample.cs

@@ -0,0 +1,164 @@
+/******************************************************************************
+ * 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 System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+
+	// This is an example of an animation handle. This is implemented with strings as state names.
+	// Strings can serve as the identifier when Mecanim is used as the state machine and state source.
+	// If you don't use Mecanim, using custom ScriptableObjects may be a more efficient way to store information about the state and its connection with specific Spine animations.
+
+	// This animation handle implementation also comes with a dummy implementation of transition-handling.
+	public class SkeletonAnimationHandleExample : MonoBehaviour {
+		public SkeletonAnimation skeletonAnimation;
+		public List<StateNameToAnimationReference> statesAndAnimations = new List<StateNameToAnimationReference>();
+		public List<AnimationTransition> transitions = new List<AnimationTransition>(); // Alternately, an AnimationPair-Animation Dictionary (commented out) can be used for more efficient lookups.
+
+		[System.Serializable]
+		public class StateNameToAnimationReference {
+			public string stateName;
+			public AnimationReferenceAsset animation;
+		}
+
+		[System.Serializable]
+		public class AnimationTransition {
+			public AnimationReferenceAsset from;
+			public AnimationReferenceAsset to;
+			public AnimationReferenceAsset transition;
+		}
+
+		//readonly Dictionary<Spine.AnimationStateData.AnimationPair, Spine.Animation> transitionDictionary = new Dictionary<AnimationStateData.AnimationPair, Animation>(Spine.AnimationStateData.AnimationPairComparer.Instance);
+
+		public Spine.Animation TargetAnimation { get; private set; }
+
+		void Awake () {
+			// Initialize AnimationReferenceAssets
+			foreach (var entry in statesAndAnimations) {
+				entry.animation.Initialize();
+			}
+			foreach (var entry in transitions) {
+				entry.from.Initialize();
+				entry.to.Initialize();
+				entry.transition.Initialize();
+			}
+
+			// Build Dictionary
+			//foreach (var entry in transitions) {
+			//	transitionDictionary.Add(new AnimationStateData.AnimationPair(entry.from.Animation, entry.to.Animation), entry.transition.Animation);
+			//}
+		}
+
+		/// <summary>Sets the horizontal flip state of the skeleton based on a nonzero float. If negative, the skeleton is flipped. If positive, the skeleton is not flipped.</summary>
+		public void SetFlip (float horizontal) {
+			if (horizontal != 0) {
+				skeletonAnimation.Skeleton.ScaleX = horizontal > 0 ? 1f : -1f;
+			}
+		}
+
+		/// <summary>Plays an animation based on the state name.</summary>
+		public void PlayAnimationForState (string stateShortName, int layerIndex) {
+			PlayAnimationForState(StringToHash(stateShortName), layerIndex);
+		}
+
+		/// <summary>Plays an animation based on the hash of the state name.</summary>
+		public void PlayAnimationForState (int shortNameHash, int layerIndex) {
+			var foundAnimation = GetAnimationForState(shortNameHash);
+			if (foundAnimation == null)
+				return;
+
+			PlayNewAnimation(foundAnimation, layerIndex);
+		}
+
+		/// <summary>Gets a Spine Animation based on the state name.</summary>
+		public Spine.Animation GetAnimationForState (string stateShortName) {
+			return GetAnimationForState(StringToHash(stateShortName));
+		}
+
+		/// <summary>Gets a Spine Animation based on the hash of the state name.</summary>
+		public Spine.Animation GetAnimationForState (int shortNameHash) {
+			var foundState = statesAndAnimations.Find(entry => StringToHash(entry.stateName) == shortNameHash);
+			return (foundState == null) ? null : foundState.animation;
+		}
+
+		/// <summary>Play an animation. If a transition animation is defined, the transition is played before the target animation being passed.</summary>
+		public void PlayNewAnimation (Spine.Animation target, int layerIndex) {
+			Spine.Animation transition = null;
+			Spine.Animation current = null;
+
+			current = GetCurrentAnimation(layerIndex);
+			if (current != null)
+				transition = TryGetTransition(current, target);
+
+			if (transition != null) {
+				skeletonAnimation.AnimationState.SetAnimation(layerIndex, transition, false);
+				skeletonAnimation.AnimationState.AddAnimation(layerIndex, target, true, 0f);
+			} else {
+				skeletonAnimation.AnimationState.SetAnimation(layerIndex, target, true);
+			}
+
+			this.TargetAnimation = target;
+		}
+
+		/// <summary>Play a non-looping animation once then continue playing the state animation.</summary>
+		public void PlayOneShot (Spine.Animation oneShot, int layerIndex) {
+			var state = skeletonAnimation.AnimationState;
+			state.SetAnimation(0, oneShot, false);
+
+			var transition = TryGetTransition(oneShot, TargetAnimation);
+			if (transition != null)
+				state.AddAnimation(0, transition, false, 0f);
+
+			state.AddAnimation(0, this.TargetAnimation, true, 0f);
+		}
+
+		Spine.Animation TryGetTransition (Spine.Animation from, Spine.Animation to) {
+			foreach (var transition in transitions) {
+				if (transition.from.Animation == from && transition.to.Animation == to) {
+					return transition.transition.Animation;
+				}
+			}
+			return null;
+
+			//Spine.Animation foundTransition = null;
+			//transitionDictionary.TryGetValue(new AnimationStateData.AnimationPair(from, to), out foundTransition);
+			//return foundTransition;
+		}
+
+		Spine.Animation GetCurrentAnimation (int layerIndex) {
+			var currentTrackEntry = skeletonAnimation.AnimationState.GetCurrent(layerIndex);
+			return (currentTrackEntry != null) ? currentTrackEntry.Animation : null;
+		}
+
+		int StringToHash (string s) {
+			return Animator.StringToHash(s);
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Mecanim as Logic/SkeletonAnimationHandleExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: dd8d49de34fd0724ca8c1ae3c44afe59
+timeCreated: 1545230473
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: bdfae2bc4b385b84eb4f5f6855d0f991
+folderAsset: yes
+timeCreated: 1537527020
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier/AnimationMatchModifierAsset.cs

@@ -0,0 +1,245 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using Spine;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+
+	//[CreateAssetMenu(menuName = "Spine/SkeletonData Modifiers/Animation Match", order = 200)]
+	public class AnimationMatchModifierAsset : SkeletonDataModifierAsset {
+
+		public bool matchAllAnimations = true;
+
+		public override void Apply (SkeletonData skeletonData) {
+			if (matchAllAnimations)
+				AnimationTools.MatchAnimationTimelines(skeletonData.Animations, skeletonData);
+		}
+
+		public static class AnimationTools {
+
+			#region Filler Timelines
+			/// <summary>
+			/// Matches the animation timelines across the given set of animations.
+			/// This allows unkeyed properties to assume setup pose when animations are naively mixed using Animation.Apply.
+			/// </summary>
+			/// <param name="animations">An enumerable collection animations whose timelines will be matched.</param>
+			/// <param name="skeletonData">The SkeletonData where the animations belong.</param>
+			public static void MatchAnimationTimelines (IEnumerable<Spine.Animation> animations, SkeletonData skeletonData) {
+				if (animations == null) return;
+				if (skeletonData == null) throw new System.ArgumentNullException("skeletonData", "Timelines can't be matched without a SkeletonData source.");
+
+				// Build a reference collection of timelines to match
+				// and a collection of dummy timelines that can be used to fill-in missing items.
+				var timelineDictionary = new Dictionary<int, Spine.Timeline>();
+				foreach (var animation in animations) {
+					foreach (var timeline in animation.Timelines) {
+						if (timeline is EventTimeline) continue;
+
+						int propertyID = timeline.PropertyId;
+						if (!timelineDictionary.ContainsKey(propertyID)) {
+							timelineDictionary.Add(propertyID, GetFillerTimeline(timeline, skeletonData));
+						}
+					}
+				}
+				var idsToMatch = new List<int>(timelineDictionary.Keys);
+
+				// For each animation in the list, check for and add missing timelines.
+				var currentAnimationIDs = new HashSet<int>();
+				foreach (var animation in animations) {
+					currentAnimationIDs.Clear();
+					foreach (var timeline in animation.Timelines) {
+						if (timeline is EventTimeline) continue;
+						currentAnimationIDs.Add(timeline.PropertyId);
+					}
+
+					var animationTimelines = animation.Timelines;
+					foreach (int propertyID in idsToMatch) {
+						if (!currentAnimationIDs.Contains(propertyID))
+							animationTimelines.Add(timelineDictionary[propertyID]);
+					}
+				}
+
+				// These are locals, but sometimes Unity's GC does weird stuff. So let's clean up.
+				timelineDictionary.Clear();
+				timelineDictionary = null;
+				idsToMatch.Clear();
+				idsToMatch = null;
+				currentAnimationIDs.Clear();
+				currentAnimationIDs = null;
+			}
+
+			static Timeline GetFillerTimeline (Timeline timeline, SkeletonData skeletonData) {
+				if (timeline is RotateTimeline)
+					return GetFillerTimeline((RotateTimeline)timeline, skeletonData);
+				if (timeline is TranslateTimeline)
+					return GetFillerTimeline((TranslateTimeline)timeline, skeletonData);
+				if (timeline is ScaleTimeline)
+					return GetFillerTimeline((ScaleTimeline)timeline, skeletonData);
+				if (timeline is ShearTimeline)
+					return GetFillerTimeline((ShearTimeline)timeline, skeletonData);
+				if (timeline is AttachmentTimeline)
+					return GetFillerTimeline((AttachmentTimeline)timeline, skeletonData);
+				if (timeline is ColorTimeline)
+					return GetFillerTimeline((ColorTimeline)timeline, skeletonData);
+				if (timeline is TwoColorTimeline)
+					return GetFillerTimeline((TwoColorTimeline)timeline, skeletonData);
+				if (timeline is DeformTimeline)
+					return GetFillerTimeline((DeformTimeline)timeline, skeletonData);
+				if (timeline is DrawOrderTimeline)
+					return GetFillerTimeline((DrawOrderTimeline)timeline, skeletonData);
+				if (timeline is IkConstraintTimeline)
+					return GetFillerTimeline((IkConstraintTimeline)timeline, skeletonData);
+				if (timeline is TransformConstraintTimeline)
+					return GetFillerTimeline((TransformConstraintTimeline)timeline, skeletonData);
+				if (timeline is PathConstraintPositionTimeline)
+					return GetFillerTimeline((PathConstraintPositionTimeline)timeline, skeletonData);
+				if (timeline is PathConstraintSpacingTimeline)
+					return GetFillerTimeline((PathConstraintSpacingTimeline)timeline, skeletonData);
+				if (timeline is PathConstraintMixTimeline)
+					return GetFillerTimeline((PathConstraintMixTimeline)timeline, skeletonData);
+				return null;
+			}
+
+			static RotateTimeline GetFillerTimeline (RotateTimeline timeline, SkeletonData skeletonData) {
+				var t = new RotateTimeline(1);
+				t.BoneIndex = timeline.BoneIndex;
+				t.SetFrame(0, 0, 0);
+				return t;
+			}
+
+			static TranslateTimeline GetFillerTimeline (TranslateTimeline timeline, SkeletonData skeletonData) {
+				var t = new TranslateTimeline(1);
+				t.BoneIndex = timeline.BoneIndex;
+				t.SetFrame(0, 0, 0, 0);
+				return t;
+			}
+
+			static ScaleTimeline GetFillerTimeline (ScaleTimeline timeline, SkeletonData skeletonData) {
+				var t = new ScaleTimeline(1);
+				t.BoneIndex = timeline.BoneIndex;
+				t.SetFrame(0, 0, 0, 0);
+				return t;
+			}
+
+			static ShearTimeline GetFillerTimeline (ShearTimeline timeline, SkeletonData skeletonData) {
+				var t = new ShearTimeline(1);
+				t.BoneIndex = timeline.BoneIndex;
+				t.SetFrame(0, 0, 0, 0);
+				return t;
+			}
+
+			static AttachmentTimeline GetFillerTimeline (AttachmentTimeline timeline, SkeletonData skeletonData) {
+				var t = new AttachmentTimeline(1);
+				t.SlotIndex = timeline.SlotIndex;
+				var slotData = skeletonData.Slots.Items[t.SlotIndex];
+				t.SetFrame(0, 0, slotData.AttachmentName);
+				return t;
+			}
+
+			static ColorTimeline GetFillerTimeline (ColorTimeline timeline, SkeletonData skeletonData) {
+				var t = new ColorTimeline(1);
+				t.SlotIndex = timeline.SlotIndex;
+				var slotData = skeletonData.Slots.Items[t.SlotIndex];
+				t.SetFrame(0, 0, slotData.R, slotData.G, slotData.B, slotData.A);
+				return t;
+			}
+
+			static TwoColorTimeline GetFillerTimeline (TwoColorTimeline timeline, SkeletonData skeletonData) {
+				var t = new TwoColorTimeline(1);
+				t.SlotIndex = timeline.SlotIndex;
+				var slotData = skeletonData.Slots.Items[t.SlotIndex];
+				t.SetFrame(0, 0, slotData.R, slotData.G, slotData.B, slotData.A, slotData.R2, slotData.G2, slotData.B2);
+				return t;
+			}
+
+			static DeformTimeline GetFillerTimeline (DeformTimeline timeline, SkeletonData skeletonData) {
+				var t = new DeformTimeline(1);
+				t.SlotIndex = timeline.SlotIndex;
+				t.Attachment = timeline.Attachment;
+
+				if (t.Attachment.IsWeighted()) {
+					t.SetFrame(0, 0, new float[t.Attachment.Vertices.Length]);
+				} else {
+					t.SetFrame(0, 0, t.Attachment.Vertices.Clone() as float[]);
+				}
+
+				return t;
+			}
+
+			static DrawOrderTimeline GetFillerTimeline (DrawOrderTimeline timeline, SkeletonData skeletonData) {
+				var t = new DrawOrderTimeline(1);
+				t.SetFrame(0, 0, null); // null means use setup pose in DrawOrderTimeline.Apply.
+				return t;
+			}
+
+			static IkConstraintTimeline GetFillerTimeline (IkConstraintTimeline timeline, SkeletonData skeletonData) {
+				var t = new IkConstraintTimeline(1);
+				var ikConstraintData = skeletonData.IkConstraints.Items[timeline.IkConstraintIndex];
+				t.SetFrame(0, 0, ikConstraintData.Mix, ikConstraintData.Softness, ikConstraintData.BendDirection, ikConstraintData.Compress, ikConstraintData.Stretch);
+				return t;
+			}
+
+			static TransformConstraintTimeline GetFillerTimeline (TransformConstraintTimeline timeline, SkeletonData skeletonData) {
+				var t = new TransformConstraintTimeline(1);
+				var data = skeletonData.TransformConstraints.Items[timeline.TransformConstraintIndex];
+				t.SetFrame(0, 0, data.RotateMix, data.TranslateMix, data.ScaleMix, data.ShearMix);
+				return t;
+			}
+
+			static PathConstraintPositionTimeline GetFillerTimeline (PathConstraintPositionTimeline timeline, SkeletonData skeletonData) {
+				var t = new PathConstraintPositionTimeline(1);
+				var data = skeletonData.PathConstraints.Items[timeline.PathConstraintIndex];
+				t.SetFrame(0, 0, data.Position);
+				return t;
+			}
+
+			static PathConstraintSpacingTimeline GetFillerTimeline (PathConstraintSpacingTimeline timeline, SkeletonData skeletonData) {
+				var t = new PathConstraintSpacingTimeline(1);
+				var data = skeletonData.PathConstraints.Items[timeline.PathConstraintIndex];
+				t.SetFrame(0, 0, data.Spacing);
+				return t;
+			}
+
+			static PathConstraintMixTimeline GetFillerTimeline (PathConstraintMixTimeline timeline, SkeletonData skeletonData) {
+				var t = new PathConstraintMixTimeline(1);
+				var data = skeletonData.PathConstraints.Items[timeline.PathConstraintIndex];
+				t.SetFrame(0, 0, data.RotateMix, data.TranslateMix);
+				return t;
+			}
+			#endregion
+		}
+
+	}
+
+}

unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier/AnimationMatchModifierAsset.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: df7d457928e0f4041a439f9847f72290
+timeCreated: 1537527074
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier/AnimationMatchModifierAsset.txt

@@ -0,0 +1,6 @@
+AnimationMatchModifierAsset
+===========================
+
+This is a SkeletonDataModifierAsset. Add it to a SkeletonDataAsset to apply its effects when its SkeletonData is loaded.
+
+AnimationMatchModifierAsset processes animations so that their timelines match. This allows them to function with naive Animation Apply systems such as SkeletonMecanim without the need for autoreset functionality.

unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier/AnimationMatchModifierAsset.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b4436c0c78cc5ee469089ed864f4e1ea
+timeCreated: 1537528259
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier/Default Match All Animations.asset

@@ -0,0 +1,14 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: df7d457928e0f4041a439f9847f72290, type: 3}
+  m_Name: Default Match All Animations
+  m_EditorClassIdentifier: 
+  matchAllAnimations: 1

unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier/Default Match All Animations.asset.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 8623082208cae724e88314ec951691e1
+timeCreated: 1537527914
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 39dcbd139c9316f46919f47f9706ca79
+folderAsset: yes
+timeCreated: 1522686452
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipAssetExample.cs

@@ -0,0 +1,41 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Spine.Unity.Examples {
+	public class EquipAssetExample : ScriptableObject {
+		public EquipSystemExample.EquipType equipType;
+		public Sprite sprite;
+		public string description;
+		public int yourStats;
+	}
+}

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipAssetExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: dcf21dc1875a05044835c5a6c969bda4
+timeCreated: 1522687338
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipButtonExample.cs

@@ -0,0 +1,60 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using UnityEngine.UI;
+
+namespace Spine.Unity.Examples {
+	public class EquipButtonExample : MonoBehaviour {
+		public EquipAssetExample asset;
+		public EquipSystemExample equipSystem;
+		public Image inventoryImage;
+
+		void OnValidate () {
+			MatchImage();
+		}
+
+		void MatchImage () {
+			if (inventoryImage != null)
+				inventoryImage.sprite = asset.sprite;
+		}
+
+		void Start () {
+			MatchImage();
+
+			var button = GetComponent<Button>();
+			button.onClick.AddListener(
+				delegate { equipSystem.Equip(asset); }
+			);
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipButtonExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d818155d239e98d46bb41e307ba270d4
+timeCreated: 1522744049
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipSystemExample.cs

@@ -0,0 +1,108 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using Spine.Unity.AttachmentTools;
+
+namespace Spine.Unity.Examples {
+	public class EquipSystemExample : MonoBehaviour, IHasSkeletonDataAsset {
+
+		// Implementing IHasSkeletonDataAsset allows Spine attribute drawers to automatically detect this component as a skeleton data source.
+		public SkeletonDataAsset skeletonDataAsset;
+		SkeletonDataAsset IHasSkeletonDataAsset.SkeletonDataAsset { get { return this.skeletonDataAsset; } }
+
+		public Material sourceMaterial;
+		public bool applyPMA = true;
+		public List<EquipHook> equippables = new List<EquipHook>();
+
+		public EquipsVisualsComponentExample target;
+		public Dictionary<EquipAssetExample, Attachment> cachedAttachments = new Dictionary<EquipAssetExample, Attachment>();
+
+		[System.Serializable]
+		public class EquipHook {
+			public EquipType type;
+			[SpineSlot]
+			public string slot;
+			[SpineSkin]
+			public string templateSkin;
+			[SpineAttachment(skinField:"templateSkin")]
+			public string templateAttachment;
+		}
+
+		public enum EquipType {
+			Gun,
+			Goggles
+		}
+
+		public void Equip (EquipAssetExample asset) {
+			var equipType = asset.equipType;
+			EquipHook howToEquip = equippables.Find(x => x.type == equipType);
+
+			var skeletonData = skeletonDataAsset.GetSkeletonData(true);
+			int slotIndex = skeletonData.FindSlotIndex(howToEquip.slot);
+			var attachment = GenerateAttachmentFromEquipAsset(asset, slotIndex, howToEquip.templateSkin, howToEquip.templateAttachment);
+			target.Equip(slotIndex, howToEquip.templateAttachment, attachment);
+		}
+
+		Attachment GenerateAttachmentFromEquipAsset (EquipAssetExample asset, int slotIndex, string templateSkinName, string templateAttachmentName) {
+			Attachment attachment;
+			cachedAttachments.TryGetValue(asset, out attachment);
+
+			if (attachment == null) {
+				var skeletonData = skeletonDataAsset.GetSkeletonData(true);
+				var templateSkin = skeletonData.FindSkin(templateSkinName);
+				Attachment templateAttachment = templateSkin.GetAttachment(slotIndex, templateAttachmentName);
+				attachment = templateAttachment.GetRemappedClone(asset.sprite, sourceMaterial, premultiplyAlpha: this.applyPMA);
+				// Note: Each call to `GetRemappedClone()` with parameter `premultiplyAlpha` set to `true` creates
+				// a cached Texture copy which can be cleared by calling AtlasUtilities.ClearCache() as shown in the method below.
+
+				cachedAttachments.Add(asset, attachment); // Cache this value for next time this asset is used.
+			}
+
+			return attachment;
+		}
+
+		public void Done () {
+			target.OptimizeSkin();
+			// `GetRepackedSkin()` and each call to `GetRemappedClone()` with parameter `premultiplyAlpha` set to `true`
+			// creates cached Texture copies which can be cleared by calling AtlasUtilities.ClearCache().
+			// You can optionally clear the textures cache after multiple repack operations.
+			// Just be aware that while this cleanup frees up memory, it is also a costly operation
+			// and will likely cause a spike in the framerate.
+
+			//AtlasUtilities.ClearCache();
+			//Resources.UnloadUnusedAssets();
+		}
+
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipSystemExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6159005f7c3d5fd4ba33cff41eae5531
+timeCreated: 1522686506
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipsVisualsComponentExample.cs

@@ -0,0 +1,101 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using Spine.Unity.AttachmentTools;
+
+namespace Spine.Unity.Examples {
+	public class EquipsVisualsComponentExample : MonoBehaviour {
+
+		public SkeletonAnimation skeletonAnimation;
+
+		[SpineSkin]
+		public string templateSkinName;
+
+		Spine.Skin equipsSkin;
+		Spine.Skin collectedSkin;
+
+		public Material runtimeMaterial;
+		public Texture2D runtimeAtlas;
+
+		void Start () {
+			equipsSkin = new Skin("Equips");
+
+			// OPTIONAL: Add all the attachments from the template skin.
+			var templateSkin = skeletonAnimation.Skeleton.Data.FindSkin(templateSkinName);
+			if (templateSkin != null)
+				equipsSkin.AddAttachments(templateSkin);
+
+			skeletonAnimation.Skeleton.Skin = equipsSkin;
+			RefreshSkeletonAttachments();
+		}
+
+		public void Equip (int slotIndex, string attachmentName, Attachment attachment) {
+			equipsSkin.SetAttachment(slotIndex, attachmentName, attachment);
+			skeletonAnimation.Skeleton.SetSkin(equipsSkin);
+			RefreshSkeletonAttachments();
+		}
+
+		public void OptimizeSkin () {
+			// 1. Collect all the attachments of all active skins.
+			collectedSkin = collectedSkin ?? new Skin("Collected skin");
+			collectedSkin.Clear();
+			collectedSkin.AddAttachments(skeletonAnimation.Skeleton.Data.DefaultSkin);
+			collectedSkin.AddAttachments(equipsSkin);
+
+			// 2. Create a repacked skin.
+			// Note: materials and textures returned by GetRepackedSkin() behave like 'new Texture2D()' and need to be destroyed
+			if (runtimeMaterial)
+				Destroy(runtimeMaterial);
+			if (runtimeAtlas)
+				Destroy(runtimeAtlas);
+			var repackedSkin = collectedSkin.GetRepackedSkin("Repacked skin", skeletonAnimation.SkeletonDataAsset.atlasAssets[0].PrimaryMaterial,
+				out runtimeMaterial, out runtimeAtlas, maxAtlasSize : 1024, clearCache: false);
+			collectedSkin.Clear();
+
+			// You can optionally clear the textures cache after each ore multiple repack operations are done.
+			//AtlasUtilities.ClearCache();
+			//Resources.UnloadUnusedAssets();
+
+			// 3. Use the repacked skin.
+			skeletonAnimation.Skeleton.Skin = repackedSkin;
+			RefreshSkeletonAttachments();
+		}
+
+		void RefreshSkeletonAttachments () {
+			skeletonAnimation.Skeleton.SetSlotsToSetupPose();
+			skeletonAnimation.AnimationState.Apply(skeletonAnimation.Skeleton); //skeletonAnimation.Update(0);
+		}
+
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/EquipsVisualsComponentExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5732385e4912c444dae078ddc7d04c89
+timeCreated: 1522688085
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/MixAndMatchSkinsButtonExample.cs

@@ -0,0 +1,50 @@
+/******************************************************************************
+ * 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;
+using Spine.Unity;
+using UnityEngine.UI;
+
+namespace Spine.Unity.Examples {
+	public class MixAndMatchSkinsButtonExample : MonoBehaviour {
+
+		public SkeletonDataAsset skeletonDataAsset;
+		public MixAndMatchSkinsExample skinsSystem;
+
+		[SpineSkin(dataField:"skeletonDataAsset")] public string itemSkin;
+		public MixAndMatchSkinsExample.ItemType itemType;
+
+		void Start () {
+			var button = GetComponent<Button>();
+			button.onClick.AddListener(
+				delegate { skinsSystem.Equip(itemSkin, itemType); }
+			);
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/MixAndMatchSkinsButtonExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c32a308f5ae4c534991805c82c575058
+timeCreated: 1522744049
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/MixAndMatchSkinsExample.cs

@@ -0,0 +1,195 @@
+/******************************************************************************
+ * 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 System.Collections.Generic;
+using UnityEngine;
+using Spine.Unity.AttachmentTools;
+
+namespace Spine.Unity.Examples {
+
+	public class MixAndMatchSkinsExample : MonoBehaviour {
+
+		// character skins
+		[SpineSkin] public string baseSkin = "skin-base";
+		[SpineSkin] public string eyelidsSkin = "eyelids/girly";
+
+		// here we use arrays of strings to be able to cycle between them easily.
+		[SpineSkin] public string[] hairSkins = { "hair/brown", "hair/blue", "hair/pink", "hair/short-red", "hair/long-blue-with-scarf" };
+		public int activeHairIndex = 0;
+		[SpineSkin] public string[] eyesSkins = { "eyes/violet", "eyes/green", "eyes/yellow" };
+		public int activeEyesIndex = 0;
+		[SpineSkin] public string[] noseSkins = { "nose/short", "nose/long" };
+		public int activeNoseIndex = 0;
+
+		// equipment skins
+		public enum ItemType {
+			Cloth,
+			Pants,
+			Bag,
+			Hat
+		}
+		[SpineSkin] public string clothesSkin = "clothes/hoodie-orange";
+		[SpineSkin] public string pantsSkin = "legs/pants-jeans";
+		[SpineSkin] public string bagSkin = "";
+		[SpineSkin] public string hatSkin = "accessories/hat-red-yellow";
+
+		SkeletonAnimation skeletonAnimation;
+		// This "naked body" skin will likely change only once upon character creation,
+		// so we store this combined set of non-equipment Skins for later re-use.
+		Skin characterSkin;
+
+		// for repacking the skin to a new atlas texture
+		public Material runtimeMaterial;
+		public Texture2D runtimeAtlas;
+
+		void Awake () {
+			skeletonAnimation = this.GetComponent<SkeletonAnimation>();
+		}
+
+		void Start () {
+			UpdateCharacterSkin();
+			UpdateCombinedSkin();
+		}
+
+		public void NextHairSkin() {
+			activeHairIndex = (activeHairIndex + 1) % hairSkins.Length;
+			UpdateCharacterSkin();
+			UpdateCombinedSkin();
+		}
+
+		public void PrevHairSkin () {
+			activeHairIndex = (activeHairIndex + hairSkins.Length - 1) % hairSkins.Length;
+			UpdateCharacterSkin();
+			UpdateCombinedSkin();
+		}
+
+		public void NextEyesSkin () {
+			activeEyesIndex = (activeEyesIndex + 1) % eyesSkins.Length;
+			UpdateCharacterSkin();
+			UpdateCombinedSkin();
+		}
+
+		public void PrevEyesSkin () {
+			activeEyesIndex = (activeEyesIndex + eyesSkins.Length - 1) % eyesSkins.Length;
+			UpdateCharacterSkin();
+			UpdateCombinedSkin();
+		}
+
+		public void NextNoseSkin () {
+			activeNoseIndex = (activeNoseIndex + 1) % noseSkins.Length;
+			UpdateCharacterSkin();
+			UpdateCombinedSkin();
+		}
+
+		public void PrevNoseSkin () {
+			activeNoseIndex = (activeNoseIndex + noseSkins.Length - 1) % noseSkins.Length;
+			UpdateCharacterSkin();
+			UpdateCombinedSkin();
+		}
+
+		public void Equip(string itemSkin, ItemType itemType) {
+			switch (itemType) {
+				case ItemType.Cloth:
+					clothesSkin = itemSkin;
+					break;
+				case ItemType.Pants:
+					pantsSkin = itemSkin;
+					break;
+				case ItemType.Bag:
+					bagSkin = itemSkin;
+					break;
+				case ItemType.Hat:
+					hatSkin = itemSkin;
+					break;
+				default:
+					break;
+			}
+			UpdateCombinedSkin();
+		}
+
+		public void OptimizeSkin () {
+			// Create a repacked skin.
+			var previousSkin = skeletonAnimation.Skeleton.Skin;
+			// Note: materials and textures returned by GetRepackedSkin() behave like 'new Texture2D()' and need to be destroyed
+			if (runtimeMaterial)
+				Destroy(runtimeMaterial);
+			if (runtimeAtlas)
+				Destroy(runtimeAtlas);
+			Skin repackedSkin = previousSkin.GetRepackedSkin("Repacked skin", skeletonAnimation.SkeletonDataAsset.atlasAssets[0].PrimaryMaterial, out runtimeMaterial, out runtimeAtlas);
+			previousSkin.Clear();
+
+			// Use the repacked skin.
+			skeletonAnimation.Skeleton.Skin = repackedSkin;
+			skeletonAnimation.Skeleton.SetSlotsToSetupPose();
+			skeletonAnimation.AnimationState.Apply(skeletonAnimation.Skeleton);
+
+			// `GetRepackedSkin()` and each call to `GetRemappedClone()` with parameter `premultiplyAlpha` set to `true`
+			// cache necessarily created Texture copies which can be cleared by calling AtlasUtilities.ClearCache().
+			// You can optionally clear the textures cache after multiple repack operations.
+			// Just be aware that while this cleanup frees up memory, it is also a costly operation
+			// and will likely cause a spike in the framerate.
+			AtlasUtilities.ClearCache();
+			Resources.UnloadUnusedAssets();
+		}
+
+		void UpdateCharacterSkin () {
+			var skeleton = skeletonAnimation.Skeleton;
+			var skeletonData = skeleton.Data;
+			characterSkin = new Skin("character-base");
+			// Note that the result Skin returned by calls to skeletonData.FindSkin()
+			// could be cached once in Start() instead of searching for the same skin
+			// every time. For demonstration purposes we keep it simple here.
+			characterSkin.AddSkin(skeletonData.FindSkin(baseSkin));
+			characterSkin.AddSkin(skeletonData.FindSkin(noseSkins[activeNoseIndex]));
+			characterSkin.AddSkin(skeletonData.FindSkin(eyelidsSkin));
+			characterSkin.AddSkin(skeletonData.FindSkin(eyesSkins[activeEyesIndex]));
+			characterSkin.AddSkin(skeletonData.FindSkin(hairSkins[activeHairIndex]));
+		}
+
+		void AddEquipmentSkinsTo (Skin combinedSkin) {
+			var skeleton = skeletonAnimation.Skeleton;
+			var skeletonData = skeleton.Data;
+			combinedSkin.AddSkin(skeletonData.FindSkin(clothesSkin));
+			combinedSkin.AddSkin(skeletonData.FindSkin(pantsSkin));
+			if (!string.IsNullOrEmpty(bagSkin)) combinedSkin.AddSkin(skeletonData.FindSkin(bagSkin));
+			if (!string.IsNullOrEmpty(hatSkin)) combinedSkin.AddSkin(skeletonData.FindSkin(hatSkin));
+		}
+
+		void UpdateCombinedSkin () {
+			var skeleton = skeletonAnimation.Skeleton;
+			var resultCombinedSkin = new Skin("character-combined");
+
+			resultCombinedSkin.AddSkin(characterSkin);
+			AddEquipmentSkinsTo(resultCombinedSkin);
+
+			skeleton.SetSkin(resultCombinedSkin);
+			skeleton.SetSlotsToSetupPose();
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Mix and Match Character Customize/MixAndMatchSkinsExample.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b5a66492fdefc494b8399943a0f9b250
+timeCreated: 1601458489
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MixAndMatch.cs

@@ -0,0 +1,150 @@
+/******************************************************************************
+ * 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;
+using Spine.Unity.AttachmentTools;
+using System.Collections;
+
+namespace Spine.Unity.Examples {
+
+	// This is an example script that shows you how to change images on your skeleton using UnityEngine.Sprites.
+	public class MixAndMatch : MonoBehaviour {
+
+		#region Inspector
+		[SpineSkin]
+		public string templateAttachmentsSkin = "base";
+		public Material sourceMaterial; // This will be used as the basis for shader and material property settings.
+
+		[Header("Visor")]
+		public Sprite visorSprite;
+		[SpineSlot] public string visorSlot;
+		[SpineAttachment(slotField:"visorSlot", skinField:"baseSkinName")] public string visorKey = "goggles";
+
+		[Header("Gun")]
+		public Sprite gunSprite;
+		[SpineSlot] public string gunSlot;
+		[SpineAttachment(slotField:"gunSlot", skinField:"baseSkinName")] public string gunKey = "gun";
+
+		[Header("Runtime Repack")]
+		public bool repack = true;
+		public BoundingBoxFollower bbFollower;
+
+		[Header("Do not assign")]
+		public Texture2D runtimeAtlas;
+		public Material runtimeMaterial;
+		#endregion
+
+		Skin customSkin;
+
+		void OnValidate () {
+			if (sourceMaterial == null) {
+				var skeletonAnimation = GetComponent<SkeletonAnimation>();
+				if (skeletonAnimation != null)
+					sourceMaterial = skeletonAnimation.SkeletonDataAsset.atlasAssets[0].PrimaryMaterial;
+			}
+		}
+
+		IEnumerator Start () {
+			yield return new WaitForSeconds(1f); // Delay for one second before applying. For testing.
+			Apply();
+		}
+
+		void Apply () {
+			var skeletonAnimation = GetComponent<SkeletonAnimation>();
+			var skeleton = skeletonAnimation.Skeleton;
+
+			// STEP 0: PREPARE SKINS
+			// Let's prepare a new skin to be our custom skin with equips/customizations. We get a clone so our original skins are unaffected.
+			customSkin = customSkin ?? new Skin("custom skin"); // This requires that all customizations are done with skin placeholders defined in Spine.
+			//customSkin = customSkin ?? skeleton.UnshareSkin(true, false, skeletonAnimation.AnimationState); // use this if you are not customizing on the default skin.
+			var templateSkin = skeleton.Data.FindSkin(templateAttachmentsSkin);
+
+			// STEP 1: "EQUIP" ITEMS USING SPRITES
+			// STEP 1.1 Find the original/template attachment.
+			// Step 1.2 Get a clone of the original/template attachment.
+			// Step 1.3 Apply the Sprite image to the clone.
+			// Step 1.4 Add the remapped clone to the new custom skin.
+
+			// Let's do this for the visor.
+			int visorSlotIndex = skeleton.FindSlotIndex(visorSlot); // You can access GetAttachment and SetAttachment via string, but caching the slotIndex is faster.
+			Attachment templateAttachment = templateSkin.GetAttachment(visorSlotIndex, visorKey); // STEP 1.1
+			Attachment newAttachment = templateAttachment.GetRemappedClone(visorSprite, sourceMaterial, pivotShiftsMeshUVCoords : false); // STEP 1.2 - 1.3
+			// Note: Each call to `GetRemappedClone()` with parameter `premultiplyAlpha` set to `true` creates
+			// a cached Texture copy which can be cleared by calling AtlasUtilities.ClearCache() as done in the method below.
+			customSkin.SetAttachment(visorSlotIndex, visorKey, newAttachment); // STEP 1.4
+
+			// And now for the gun.
+			int gunSlotIndex = skeleton.FindSlotIndex(gunSlot);
+			Attachment templateGun = templateSkin.GetAttachment(gunSlotIndex, gunKey); // STEP 1.1
+			Attachment newGun = templateGun.GetRemappedClone(gunSprite, sourceMaterial, pivotShiftsMeshUVCoords: false); // STEP 1.2 - 1.3
+			if (newGun != null) customSkin.SetAttachment(gunSlotIndex, gunKey, newGun); // STEP 1.4
+
+			// customSkin.RemoveAttachment(gunSlotIndex, gunKey); // To remove an item.
+			// customSkin.Clear()
+			// Use skin.Clear() To remove all customizations.
+			// Customizations will fall back to the value in the default skin if it was defined there.
+			// To prevent fallback from happening, make sure the key is not defined in the default skin.
+
+			// STEP 3: APPLY AND CLEAN UP.
+			// Recommended, preferably at level-load-time: REPACK THE CUSTOM SKIN TO MINIMIZE DRAW CALLS
+			// 				IMPORTANT NOTE: the GetRepackedSkin() operation is expensive - if multiple characters
+			// 				need to call it every few seconds the overhead will outweigh the draw call benefits.
+			//
+			// 				Repacking requires that you set all source textures/sprites/atlases to be Read/Write enabled in the inspector.
+			// 				Combine all the attachment sources into one skin. Usually this means the default skin and the custom skin.
+			// 				call Skin.GetRepackedSkin to get a cloned skin with cloned attachments that all use one texture.
+			if (repack)	{
+				var repackedSkin = new Skin("repacked skin");
+				repackedSkin.AddAttachments(skeleton.Data.DefaultSkin); // Include the "default" skin. (everything outside of skin placeholders)
+				repackedSkin.AddAttachments(customSkin); // Include your new custom skin.
+				// Note: materials and textures returned by GetRepackedSkin() behave like 'new Texture2D()' and need to be destroyed
+				if (runtimeMaterial)
+					Destroy(runtimeMaterial);
+				if (runtimeAtlas)
+					Destroy(runtimeAtlas);
+				repackedSkin = repackedSkin.GetRepackedSkin("repacked skin", sourceMaterial, out runtimeMaterial, out runtimeAtlas); // Pack all the items in the skin.
+				skeleton.SetSkin(repackedSkin); // Assign the repacked skin to your Skeleton.
+				if (bbFollower != null) bbFollower.Initialize(true);
+			} else {
+				skeleton.SetSkin(customSkin); // Just use the custom skin directly.
+			}
+
+			skeleton.SetSlotsToSetupPose(); // Use the pose from setup pose.
+			skeletonAnimation.Update(0); // Use the pose in the currently active animation.
+
+			// `GetRepackedSkin()` and each call to `GetRemappedClone()` with parameter `premultiplyAlpha` set to `true`
+			// cache necessarily created Texture copies which can be cleared by calling AtlasUtilities.ClearCache().
+			// You can optionally clear the textures cache after multiple repack operations.
+			// Just be aware that while this cleanup frees up memory, it is also a costly operation
+			// and will likely cause a spike in the framerate.
+			AtlasUtilities.ClearCache();
+			Resources.UnloadUnusedAssets();
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/MixAndMatch.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fdd7c8b428f700c438a6a14addca0346
+timeCreated: 1480089275
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/MixAndMatchGraphic.cs

@@ -0,0 +1,149 @@
+/******************************************************************************
+ * 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;
+using Spine.Unity.AttachmentTools;
+using System.Collections;
+
+namespace Spine.Unity.Examples {
+
+	// This is an example script that shows you how to change images on your skeleton using UnityEngine.Sprites.
+	public class MixAndMatchGraphic : MonoBehaviour {
+
+		#region Inspector
+		[SpineSkin]
+		public string baseSkinName = "base";
+		public Material sourceMaterial; // This will be used as the basis for shader and material property settings.
+
+		[Header("Visor")]
+		public Sprite visorSprite;
+		[SpineSlot] public string visorSlot;
+		[SpineAttachment(slotField:"visorSlot", skinField:"baseSkinName")] public string visorKey = "goggles";
+
+		[Header("Gun")]
+		public Sprite gunSprite;
+		[SpineSlot] public string gunSlot;
+		[SpineAttachment(slotField:"gunSlot", skinField:"baseSkinName")] public string gunKey = "gun";
+
+		[Header("Runtime Repack Required!!")]
+		public bool repack = true;
+
+		[Header("Do not assign")]
+		public Texture2D runtimeAtlas;
+		public Material runtimeMaterial;
+		#endregion
+
+		Skin customSkin;
+
+		void OnValidate () {
+			if (sourceMaterial == null) {
+				var skeletonGraphic = GetComponent<SkeletonGraphic>();
+				if (skeletonGraphic != null)
+					sourceMaterial = skeletonGraphic.SkeletonDataAsset.atlasAssets[0].PrimaryMaterial;
+			}
+		}
+
+		IEnumerator Start () {
+			yield return new WaitForSeconds(1f); // Delay for 1 second. For testing.
+			Apply();
+		}
+
+		[ContextMenu("Apply")]
+		void Apply () {
+			var skeletonGraphic = GetComponent<SkeletonGraphic>();
+			var skeleton = skeletonGraphic.Skeleton;
+
+			// STEP 0: PREPARE SKINS
+			// Let's prepare a new skin to be our custom skin with equips/customizations. We get a clone so our original skins are unaffected.
+			customSkin = customSkin ?? new Skin("custom skin"); // This requires that all customizations are done with skin placeholders defined in Spine.
+			//customSkin = customSkin ?? skeleton.UnshareSkin(true, false, skeletonAnimation.AnimationState); // use this if you are not customizing on the default skin and don't plan to remove
+			// Next let's get the skin that contains our source attachments. These are the attachments that
+			var baseSkin = skeleton.Data.FindSkin(baseSkinName);
+
+			// STEP 1: "EQUIP" ITEMS USING SPRITES
+			// STEP 1.1 Find the original attachment.
+			// Step 1.2 Get a clone of the original attachment.
+			// Step 1.3 Apply the Sprite image to it.
+			// Step 1.4 Add the remapped clone to the new custom skin.
+
+			// Let's do this for the visor.
+			int visorSlotIndex = skeleton.FindSlotIndex(visorSlot); // You can access GetAttachment and SetAttachment via string, but caching the slotIndex is faster.
+			Attachment baseAttachment = baseSkin.GetAttachment(visorSlotIndex, visorKey); // STEP 1.1
+			Attachment newAttachment = baseAttachment.GetRemappedClone(visorSprite, sourceMaterial); // STEP 1.2 - 1.3
+			// Note: Each call to `GetRemappedClone()` with parameter `premultiplyAlpha` set to `true` creates
+			// a cached Texture copy which can be cleared by calling AtlasUtilities.ClearCache() as done below.
+			customSkin.SetAttachment(visorSlotIndex, visorKey, newAttachment); // STEP 1.4
+
+			// And now for the gun.
+			int gunSlotIndex = skeleton.FindSlotIndex(gunSlot);
+			Attachment baseGun = baseSkin.GetAttachment(gunSlotIndex, gunKey); // STEP 1.1
+			Attachment newGun = baseGun.GetRemappedClone(gunSprite, sourceMaterial); // STEP 1.2 - 1.3
+			if (newGun != null) customSkin.SetAttachment(gunSlotIndex, gunKey, newGun); // STEP 1.4
+
+			// customSkin.RemoveAttachment(gunSlotIndex, gunKey); // To remove an item.
+			// customSkin.Clear()
+			// Use skin.Clear() To remove all customizations.
+			// Customizations will fall back to the value in the default skin if it was defined there.
+			// To prevent fallback from happening, make sure the key is not defined in the default skin.
+
+			// STEP 3: APPLY AND CLEAN UP.
+			// Recommended: REPACK THE CUSTOM SKIN TO MINIMIZE DRAW CALLS
+			// 				Repacking requires that you set all source textures/sprites/atlases to be Read/Write enabled in the inspector.
+			// 				Combine all the attachment sources into one skin. Usually this means the default skin and the custom skin.
+			// 				call Skin.GetRepackedSkin to get a cloned skin with cloned attachments that all use one texture.
+			if (repack)	{
+				var repackedSkin = new Skin("repacked skin");
+				repackedSkin.AddAttachments(skeleton.Data.DefaultSkin);
+				repackedSkin.AddAttachments(customSkin);
+				// Note: materials and textures returned by GetRepackedSkin() behave like 'new Texture2D()' and need to be destroyed
+				if (runtimeMaterial)
+					Destroy(runtimeMaterial);
+				if (runtimeAtlas)
+					Destroy(runtimeAtlas);
+				repackedSkin = repackedSkin.GetRepackedSkin("repacked skin", sourceMaterial, out runtimeMaterial, out runtimeAtlas);
+				skeleton.SetSkin(repackedSkin);
+			} else {
+				skeleton.SetSkin(customSkin);
+			}
+
+			//skeleton.SetSlotsToSetupPose();
+			skeleton.SetToSetupPose();
+			skeletonGraphic.Update(0);
+			skeletonGraphic.OverrideTexture = runtimeAtlas;
+
+			// `GetRepackedSkin()` and each call to `GetRemappedClone()` with parameter `premultiplyAlpha` set to `true`
+			// cache necessarily created Texture copies which can be cleared by calling AtlasUtilities.ClearCache().
+			// You can optionally clear the textures cache after multiple repack operations.
+			// Just be aware that while this cleanup frees up memory, it is also a costly operation
+			// and will likely cause a spike in the framerate.
+			AtlasUtilities.ClearCache();
+			Resources.UnloadUnusedAssets();
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/MixAndMatchGraphic.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8e24c5293ec0b444eba7a2680caa925f
+timeCreated: 1480089275
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/RaggedySpineboy.cs

@@ -0,0 +1,102 @@
+/******************************************************************************
+ * 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;
+using System.Collections;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class RaggedySpineboy : MonoBehaviour {
+
+		public LayerMask groundMask;
+		public float restoreDuration = 0.5f;
+		public Vector2 launchVelocity = new Vector2(50,100);
+
+		Spine.Unity.Examples.SkeletonRagdoll2D ragdoll;
+		Collider2D naturalCollider;
+
+		void Start () {
+			ragdoll = GetComponent<Spine.Unity.Examples.SkeletonRagdoll2D>();
+			naturalCollider = GetComponent<Collider2D>();
+		}
+
+		void AddRigidbody () {
+			var rb = gameObject.AddComponent<Rigidbody2D>();
+			rb.freezeRotation = true;
+			naturalCollider.enabled = true;
+		}
+
+		void RemoveRigidbody () {
+			Destroy(GetComponent<Rigidbody2D>());
+			naturalCollider.enabled = false;
+		}
+
+		void OnMouseUp () {
+			if (naturalCollider.enabled)
+				Launch();
+		}
+
+		void Launch () {
+			RemoveRigidbody();
+			ragdoll.Apply();
+			ragdoll.RootRigidbody.velocity = new Vector2(Random.Range(-launchVelocity.x, launchVelocity.x), launchVelocity.y);
+			StartCoroutine(WaitUntilStopped());
+		}
+
+		IEnumerator Restore () {
+			Vector3 estimatedPos = ragdoll.EstimatedSkeletonPosition;
+			Vector3 rbPosition = ragdoll.RootRigidbody.position;
+
+			Vector3 skeletonPoint = estimatedPos;
+			RaycastHit2D hit = Physics2D.Raycast((Vector2)rbPosition, (Vector2)(estimatedPos - rbPosition), Vector3.Distance(estimatedPos, rbPosition), groundMask);
+			if (hit.collider != null)
+				skeletonPoint = hit.point;
+
+			ragdoll.RootRigidbody.isKinematic = true;
+			ragdoll.SetSkeletonPosition(skeletonPoint);
+
+			yield return ragdoll.SmoothMix(0, restoreDuration);
+			ragdoll.Remove();
+
+			AddRigidbody();
+		}
+
+		IEnumerator WaitUntilStopped () {
+			yield return new WaitForSeconds(0.5f);
+
+			float t = 0;
+			while (t < 0.5f) {
+				t = (ragdoll.RootRigidbody.velocity.magnitude > 0.09f) ? 0 : t + Time.deltaTime;
+				yield return null;
+			}
+
+			StartCoroutine(Restore());
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/RaggedySpineboy.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 849a7739a7df0754882fcb34c09df4c1
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

unity/Assets/Spine Examples/Scripts/ReloadSceneOnKeyDown.cs

@@ -0,0 +1,44 @@
+/******************************************************************************
+ * 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 System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using UnityEngine.SceneManagement;
+
+public class ReloadSceneOnKeyDown : MonoBehaviour {
+
+	public KeyCode reloadKey = KeyCode.R;
+
+	void Update () {
+		if (Input.GetKeyDown(reloadKey))
+			SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex, LoadSceneMode.Single);
+	}
+}

unity/Assets/Spine Examples/Scripts/ReloadSceneOnKeyDown.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d655607dd16c7f644a73bd10fc7370b1
+timeCreated: 1523294158
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Rotator.cs

@@ -0,0 +1,41 @@
+/******************************************************************************
+ * 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.Examples {
+	public class Rotator : MonoBehaviour {
+		public Vector3 direction = new Vector3(0, 0, 1f);
+		public float speed = 1f;
+
+		void Update () {
+			transform.Rotate(direction * (speed * Time.deltaTime * 100f));
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Rotator.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 12e291cb54756d04c9dd53ad6e00a126
+timeCreated: 1479532891
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 037ce88b9252fd241bd99d71721d9205
+folderAsset: yes
+timeCreated: 1481879243
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/BoneLocalOverride.cs

@@ -0,0 +1,91 @@
+/******************************************************************************
+ * 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;
+using Spine;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+	public class BoneLocalOverride : MonoBehaviour {
+		[SpineBone]
+		public string boneName;
+
+		[Space]
+		[Range(0, 1)] public float alpha = 1;
+
+		[Space]
+		public bool overridePosition = true;
+		public Vector2 localPosition;
+
+		[Space]
+		public bool overrideRotation = true;
+		[Range(0, 360)] public float rotation = 0;
+
+		ISkeletonAnimation spineComponent;
+		Bone bone;
+
+		#if UNITY_EDITOR
+		void OnValidate () {
+			if (Application.isPlaying) return;
+			spineComponent = spineComponent ?? GetComponent<ISkeletonAnimation>();
+			if (spineComponent == null) return;
+			if (bone != null) bone.SetToSetupPose();
+			OverrideLocal(spineComponent);
+		}
+		#endif
+
+		void Awake () {
+			spineComponent = GetComponent<ISkeletonAnimation>();
+			if (spineComponent == null) { this.enabled = false; return; }
+			spineComponent.UpdateLocal += OverrideLocal;
+
+			if (bone == null) {	this.enabled = false; return; }
+		}
+
+		void OverrideLocal (ISkeletonAnimation animated) {
+			if (bone == null || bone.Data.Name != boneName) {
+				if (string.IsNullOrEmpty(boneName)) return;
+				bone = spineComponent.Skeleton.FindBone(boneName);
+				if (bone == null) {
+					Debug.LogFormat("Cannot find bone: '{0}'", boneName);
+					return;
+				}
+			}
+
+			if (overridePosition) {
+				bone.X = Mathf.Lerp(bone.X, localPosition.x, alpha);
+				bone.Y = Mathf.Lerp(bone.Y, localPosition.y, alpha);
+			}
+
+			if (overrideRotation)
+				bone.Rotation = Mathf.Lerp(bone.Rotation, rotation, alpha);
+		}
+
+	}
+}

unity/Assets/Spine Examples/Scripts/Sample Components/BoneLocalOverride.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 61e6f96a4b02648479575d8b9127f5ed
+timeCreated: 1492782100
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/CombinedSkin.cs

@@ -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.
+ *****************************************************************************/
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Spine.Unity.AttachmentTools;
+
+namespace Spine.Unity.Examples {
+	public class CombinedSkin : MonoBehaviour {
+		[SpineSkin]
+		public List<string> skinsToCombine;
+
+		Skin combinedSkin;
+
+		void Start () {
+			var skeletonComponent = GetComponent<ISkeletonComponent>();
+			if (skeletonComponent == null) return;
+			var skeleton = skeletonComponent.Skeleton;
+			if (skeleton == null) return;
+
+			combinedSkin = combinedSkin ?? new Skin("combined");
+			combinedSkin.Clear();
+			foreach (var skinName in skinsToCombine) {
+				var skin = skeleton.Data.FindSkin(skinName);
+				if (skin != null) combinedSkin.AddAttachments(skin);
+			}
+
+			skeleton.SetSkin(combinedSkin);
+			skeleton.SetToSetupPose();
+			var animationStateComponent = skeletonComponent as IAnimationStateComponent;
+			if (animationStateComponent != null) animationStateComponent.AnimationState.Apply(skeleton);
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Sample Components/CombinedSkin.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e864d2963143ec04eb4f905e6add115e
+timeCreated: 1495176902
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 13193c9d213765f4c85f4c1faa615711
+folderAsset: yes
+DefaultImporter:
+  userData: 

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost/Shaders.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: a0cee0de78cef7440ae0b5aac39ae971
+folderAsset: yes
+DefaultImporter:
+  userData: 

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost/Shaders/Spine-Special-Skeleton-Ghost.shader

@@ -0,0 +1,67 @@
+// - Unlit + no shadow
+// - Premultiplied Alpha Blending (One OneMinusSrcAlpha)
+// - Double-sided, no depth
+
+Shader "Spine/Special/SkeletonGhost" {
+    Properties {
+		_Color ("Main Color", Color) = (1,1,1,1)
+		[NoScaleOffset] _MainTex ("Base (RGB) Alpha (A)", 2D) = "white" {}
+		_TextureFade ("Texture Fade Out", Range(0,1)) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+    }
+    SubShader {
+		Tags {
+			"Queue"="Transparent"
+			"IgnoreProjector"="False"
+			"RenderType"="Transparent"
+		}
+		Fog { Mode Off }
+		Blend One OneMinusSrcAlpha
+		ZWrite Off
+		Cull Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#include "UnityCG.cginc"
+			sampler2D _MainTex;
+			fixed4 _Color;
+			fixed _TextureFade;
+
+			struct VertexInput {
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 color : COLOR;
+			};
+
+			struct VertexOutput {
+			    float4  pos : SV_POSITION;
+			    float2  uv : TEXCOORD0;
+				float4 color : COLOR;
+			};
+
+			VertexOutput vert (VertexInput v) {
+			    VertexOutput o;
+			    o.pos = UnityObjectToClipPos(v.vertex);
+			    o.uv = v.uv;
+			    o.color = v.color;
+			    return o;
+			}
+
+			fixed4 frag (VertexOutput i) : SV_Target {
+			    fixed4 tc = tex2D(_MainTex, i.uv);
+				tc = fixed4(max(_TextureFade, tc.r), max(_TextureFade, tc.g), max(_TextureFade, tc.b), tc.a);
+				return tc * ((i.color * _Color) * tc.a);
+			}
+			ENDCG
+		}
+    }
+}

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost/Shaders/Spine-Special-Skeleton-Ghost.shader.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3873d4699ee8a4b4da8fa6b8c229b94d
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost/SkeletonGhost.cs

@@ -0,0 +1,201 @@
+/******************************************************************************
+ * 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.
+ *****************************************************************************/
+
+// Contributed by: Mitch Thompson
+
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Spine.Unity.Examples {
+
+	[RequireComponent(typeof(SkeletonRenderer))]
+	public class SkeletonGhost : MonoBehaviour {
+		// Internal Settings
+		const HideFlags GhostHideFlags = HideFlags.HideInHierarchy;
+		const string GhostingShaderName = "Spine/Special/SkeletonGhost";
+
+		[Header("Animation")]
+		public bool ghostingEnabled = true;
+		[Tooltip("The time between invididual ghost pieces being spawned.")]
+		[UnityEngine.Serialization.FormerlySerializedAs("spawnRate")]
+		public float spawnInterval = 1f/30f;
+		[Tooltip("Maximum number of ghosts that can exist at a time. If the fade speed is not fast enough, the oldest ghost will immediately disappear to enforce the maximum number.")]
+		public int maximumGhosts = 10;
+		public float fadeSpeed = 10;
+
+		[Header("Rendering")]
+		public Shader ghostShader;
+		public Color32 color = new Color32(0xFF, 0xFF, 0xFF, 0x00); // default for additive.
+		[Tooltip("Remember to set color alpha to 0 if Additive is true")]
+		public bool additive = true;
+		[Tooltip("0 is Color and Alpha, 1 is Alpha only.")]
+		[Range(0, 1)]
+		public float textureFade = 1;
+
+		[Header("Sorting")]
+		public bool sortWithDistanceOnly;
+		public float zOffset = 0f;
+
+		float nextSpawnTime;
+		SkeletonGhostRenderer[] pool;
+		int poolIndex = 0;
+		SkeletonRenderer skeletonRenderer;
+		MeshRenderer meshRenderer;
+		MeshFilter meshFilter;
+
+		readonly Dictionary<Material, Material> materialTable = new Dictionary<Material, Material>();
+
+		void Start () {
+			Initialize(false);
+		}
+
+		public void Initialize (bool overwrite) {
+			if (pool == null || overwrite) {
+				if (ghostShader == null)
+					ghostShader = Shader.Find(GhostingShaderName);
+
+				skeletonRenderer = GetComponent<SkeletonRenderer>();
+				meshFilter = GetComponent<MeshFilter>();
+				meshRenderer = GetComponent<MeshRenderer>();
+				nextSpawnTime = Time.time + spawnInterval;
+				pool = new SkeletonGhostRenderer[maximumGhosts];
+				for (int i = 0; i < maximumGhosts; i++) {
+					GameObject go = new GameObject(gameObject.name + " Ghost", typeof(SkeletonGhostRenderer));
+					pool[i] = go.GetComponent<SkeletonGhostRenderer>();
+					go.SetActive(false);
+					go.hideFlags = GhostHideFlags;
+				}
+
+				var skeletonAnimation = skeletonRenderer as Spine.Unity.IAnimationStateComponent;
+				if (skeletonAnimation != null)
+					skeletonAnimation.AnimationState.Event += OnEvent;
+			}
+		}
+
+		//SkeletonAnimation
+		/*
+		 *	Int Value:		0 sets ghostingEnabled to false, 1 sets ghostingEnabled to true
+		 *	Float Value:	Values greater than 0 set the spawnRate equal the float value
+		 *	String Value:	Pass RGBA hex color values in to set the color property. IE: "A0FF8BFF"
+		 */
+		void OnEvent (Spine.TrackEntry trackEntry, Spine.Event e) {
+			if (e.Data.Name.Equals("Ghosting", System.StringComparison.Ordinal)) {
+				ghostingEnabled = e.Int > 0;
+				if (e.Float > 0)
+					spawnInterval = e.Float;
+
+				if (!string.IsNullOrEmpty(e.String))
+					this.color = HexToColor(e.String);
+			}
+		}
+
+		//SkeletonAnimator
+		//SkeletonAnimator or Mecanim based animations only support toggling ghostingEnabled. Be sure not to set anything other than the Int param in Spine or String will take priority.
+		void Ghosting (float val) {
+			ghostingEnabled = val > 0;
+		}
+
+		void Update () {
+			if (!ghostingEnabled || poolIndex >= pool.Length)
+				return;
+
+			if (Time.time >= nextSpawnTime) {
+				GameObject go = pool[poolIndex].gameObject;
+
+				Material[] materials = meshRenderer.sharedMaterials;
+				for (int i = 0; i < materials.Length; i++) {
+					var originalMat = materials[i];
+					Material ghostMat;
+					if (!materialTable.ContainsKey(originalMat)) {
+						ghostMat = new Material(originalMat) {
+							shader = ghostShader,
+							color = Color.white
+						};
+
+						if (ghostMat.HasProperty("_TextureFade"))
+							ghostMat.SetFloat("_TextureFade", textureFade);
+
+						materialTable.Add(originalMat, ghostMat);
+					} else {
+						ghostMat = materialTable[originalMat];
+					}
+
+					materials[i] = ghostMat;
+				}
+
+				var goTransform = go.transform;
+				goTransform.parent = transform;
+
+				pool[poolIndex].Initialize(meshFilter.sharedMesh, materials, color, additive, fadeSpeed, meshRenderer.sortingLayerID, (sortWithDistanceOnly) ? meshRenderer.sortingOrder : meshRenderer.sortingOrder - 1);
+
+				goTransform.localPosition = new Vector3(0f, 0f, zOffset);
+				goTransform.localRotation = Quaternion.identity;
+				goTransform.localScale = Vector3.one;
+
+				goTransform.parent = null;
+
+				poolIndex++;
+
+				if (poolIndex == pool.Length)
+					poolIndex = 0;
+
+				nextSpawnTime = Time.time + spawnInterval;
+			}
+		}
+
+		void OnDestroy () {
+			if (pool != null) {
+				for (int i = 0; i < maximumGhosts; i++)
+					if (pool[i] != null) pool[i].Cleanup();
+			}
+
+			foreach (var mat in materialTable.Values)
+				Destroy(mat);
+		}
+
+		// based on UnifyWiki http://wiki.unity3d.com/index.php?title=HexConverter
+		static Color32 HexToColor (string hex) {
+			const System.Globalization.NumberStyles HexNumber = System.Globalization.NumberStyles.HexNumber;
+
+			if (hex.Length < 6)
+				return Color.magenta;
+
+			hex = hex.Replace("#", "");
+			byte r = byte.Parse(hex.Substring(0, 2), HexNumber);
+			byte g = byte.Parse(hex.Substring(2, 2), HexNumber);
+			byte b = byte.Parse(hex.Substring(4, 2), HexNumber);
+			byte a = 0xFF;
+			if (hex.Length == 8)
+				a = byte.Parse(hex.Substring(6, 2), HexNumber);
+
+			return new Color32(r, g, b, a);
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost/SkeletonGhost.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 02f2fa991881c6d419500ccc40ad443f
+timeCreated: 1431858330
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences:
+  - ghostShader: {fileID: 4800000, guid: 3873d4699ee8a4b4da8fa6b8c229b94d, type: 3}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost/SkeletonGhostRenderer.cs

@@ -0,0 +1,128 @@
+/******************************************************************************
+ * 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.
+ *****************************************************************************/
+
+// Contributed by: Mitch Thompson
+
+using UnityEngine;
+using System.Collections;
+
+namespace Spine.Unity.Examples {
+	public class SkeletonGhostRenderer : MonoBehaviour {
+		static readonly Color32 TransparentBlack = new Color32(0, 0, 0, 0);
+		const string colorPropertyName = "_Color";
+
+		float fadeSpeed = 10;
+		Color32 startColor;
+		MeshFilter meshFilter;
+		MeshRenderer meshRenderer;
+
+		MaterialPropertyBlock mpb;
+		int colorId;
+
+		void Awake () {
+			meshRenderer = gameObject.AddComponent<MeshRenderer>();
+			meshFilter = gameObject.AddComponent<MeshFilter>();
+
+			colorId = Shader.PropertyToID(colorPropertyName);
+			mpb = new MaterialPropertyBlock();
+		}
+
+		public void Initialize (Mesh mesh, Material[] materials, Color32 color, bool additive, float speed, int sortingLayerID, int sortingOrder) {
+			StopAllCoroutines();
+
+			gameObject.SetActive(true);
+			meshRenderer.sharedMaterials = materials;
+			meshRenderer.sortingLayerID = sortingLayerID;
+			meshRenderer.sortingOrder = sortingOrder;
+			meshFilter.sharedMesh = Instantiate(mesh);
+			startColor = color;
+			mpb.SetColor(colorId, color);
+			meshRenderer.SetPropertyBlock(mpb);
+
+			fadeSpeed = speed;
+
+			if (additive)
+				StartCoroutine(FadeAdditive());
+			else
+				StartCoroutine(Fade());
+		}
+
+		IEnumerator Fade () {
+			Color32 c = startColor;
+			Color32 black = SkeletonGhostRenderer.TransparentBlack;
+
+			float t = 1f;
+			for (float hardTimeLimit = 5f; hardTimeLimit > 0; hardTimeLimit -= Time.deltaTime) {
+				c = Color32.Lerp(black, startColor, t);
+				mpb.SetColor(colorId, c);
+				meshRenderer.SetPropertyBlock(mpb);
+
+				t = Mathf.Lerp(t, 0, Time.deltaTime * fadeSpeed);
+				if (t <= 0)
+					break;
+
+				yield return null;
+			}
+
+			Destroy(meshFilter.sharedMesh);
+			gameObject.SetActive(false);
+		}
+
+		IEnumerator FadeAdditive () {
+			Color32 c = startColor;
+			Color32 black = SkeletonGhostRenderer.TransparentBlack;
+
+			float t = 1f;
+
+			for (float hardTimeLimit = 5f; hardTimeLimit > 0; hardTimeLimit -= Time.deltaTime) {
+				c = Color32.Lerp(black, startColor, t);
+				mpb.SetColor(colorId, c);
+				meshRenderer.SetPropertyBlock(mpb);
+
+				t = Mathf.Lerp(t, 0, Time.deltaTime * fadeSpeed);
+				if (t <= 0)
+					break;
+
+				yield return null;
+			}
+
+			Destroy(meshFilter.sharedMesh);
+
+			gameObject.SetActive(false);
+		}
+
+		public void Cleanup () {
+			if (meshFilter != null && meshFilter.sharedMesh != null)
+				Destroy(meshFilter.sharedMesh);
+
+			Destroy(gameObject);
+		}
+	}
+
+}

unity/Assets/Spine Examples/Scripts/Sample Components/Ghost/SkeletonGhostRenderer.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 58e3a9b80754b7545a1dff4d8475b51f
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/Legacy.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d8033179a12443e4eaef33b35fed074c
+folderAsset: yes
+timeCreated: 1495179724
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/Legacy/AtlasRegionAttacher.cs

@@ -0,0 +1,81 @@
+/******************************************************************************
+ * 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;
+using System.Collections.Generic;
+using Spine;
+using Spine.Unity.AttachmentTools;
+
+namespace Spine.Unity.Examples {
+	/// <summary>
+	/// Example code for a component that replaces the default attachment of a slot with an image from a Spine atlas.</summary>
+	public class AtlasRegionAttacher : MonoBehaviour {
+
+		[System.Serializable]
+		public class SlotRegionPair {
+			[SpineSlot] public string slot;
+			[SpineAtlasRegion] public string region;
+		}
+
+		[SerializeField] protected SpineAtlasAsset atlasAsset;
+		[SerializeField] protected bool inheritProperties = true;
+		[SerializeField] protected List<SlotRegionPair> attachments = new List<SlotRegionPair>();
+
+		Atlas atlas;
+
+		void Awake () {
+			var skeletonRenderer = GetComponent<SkeletonRenderer>();
+			skeletonRenderer.OnRebuild += Apply;
+			if (skeletonRenderer.valid) Apply(skeletonRenderer);
+		}
+
+		void Apply (SkeletonRenderer skeletonRenderer) {
+			if (!this.enabled) return;
+
+			atlas = atlasAsset.GetAtlas();
+			if (atlas == null) return;
+			float scale = skeletonRenderer.skeletonDataAsset.scale;
+
+			foreach (var entry in attachments) {
+				Slot slot = skeletonRenderer.Skeleton.FindSlot(entry.slot);
+				Attachment originalAttachment = slot.Attachment;
+				AtlasRegion region = atlas.FindRegion(entry.region);
+
+				if (region == null) {
+					slot.Attachment = null;
+				} else if (inheritProperties && originalAttachment != null) {
+					slot.Attachment = originalAttachment.GetRemappedClone(region, true, true, scale);
+				} else {
+					var newRegionAttachment = region.ToRegionAttachment(region.name, scale);
+					slot.Attachment = newRegionAttachment;
+				}
+			}
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Sample Components/Legacy/AtlasRegionAttacher.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: afde57cc4fd39bb4dbd61b73403ae6a8
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/Legacy/CustomSkin.cs

@@ -0,0 +1,30 @@
+/******************************************************************************
+ * 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.
+ *****************************************************************************/
+
+

unity/Assets/Spine Examples/Scripts/Sample Components/Legacy/CustomSkin.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 6e55c8477eccddc4cb5c3551a3945ca7
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

unity/Assets/Spine Examples/Scripts/Sample Components/Legacy/SpriteAttacher.cs

@@ -0,0 +1,184 @@
+/******************************************************************************
+ * 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.
+ *****************************************************************************/
+
+// Original Contribution by: Mitch Thompson
+
+using UnityEngine;
+using System.Collections.Generic;
+using Spine.Unity.AttachmentTools;
+
+namespace Spine.Unity.Examples {
+	public class SpriteAttacher : MonoBehaviour {
+		public const string DefaultPMAShader = "Spine/Skeleton";
+		public const string DefaultStraightAlphaShader = "Sprites/Default";
+
+		#region Inspector
+		public bool attachOnStart = true;
+		public bool overrideAnimation = true;
+		public Sprite sprite;
+		[SpineSlot] public string slot;
+		#endregion
+
+		#if UNITY_EDITOR
+		void OnValidate () {
+			var skeletonComponent = GetComponent<ISkeletonComponent>();
+			var skeletonRenderer = skeletonComponent as SkeletonRenderer;
+			bool applyPMA;
+
+			if (skeletonRenderer != null) {
+				applyPMA = skeletonRenderer.pmaVertexColors;
+			} else {
+				var skeletonGraphic = skeletonComponent as SkeletonGraphic;
+				applyPMA = skeletonGraphic != null && skeletonGraphic.MeshGenerator.settings.pmaVertexColors;
+			}
+
+			if (applyPMA) {
+				try {
+					if (sprite == null)
+						return;
+					sprite.texture.GetPixel(0, 0);
+				} catch (UnityException e) {
+					Debug.LogFormat("Texture of {0} ({1}) is not read/write enabled. SpriteAttacher requires this in order to work with a SkeletonRenderer that renders premultiplied alpha. Please check the texture settings.", sprite.name, sprite.texture.name);
+					UnityEditor.EditorGUIUtility.PingObject(sprite.texture);
+					throw e;
+				}
+			}
+		}
+		#endif
+
+		RegionAttachment attachment;
+		Slot spineSlot;
+		bool applyPMA;
+
+		static Dictionary<Texture, AtlasPage> atlasPageCache;
+		static AtlasPage GetPageFor (Texture texture, Shader shader) {
+			if (atlasPageCache == null) atlasPageCache = new Dictionary<Texture, AtlasPage>();
+			AtlasPage atlasPage;
+			atlasPageCache.TryGetValue(texture, out atlasPage);
+			if (atlasPage == null) {
+				var newMaterial = new Material(shader);
+				atlasPage = newMaterial.ToSpineAtlasPage();
+				atlasPageCache[texture] = atlasPage;
+			}
+			return atlasPage;
+		}
+
+		void Start () {
+			// Initialize slot and attachment references.
+			Initialize(false);
+
+			if (attachOnStart)
+				Attach();
+		}
+
+		void AnimationOverrideSpriteAttach (ISkeletonAnimation animated) {
+			if (overrideAnimation && isActiveAndEnabled)
+				Attach();
+		}
+
+		public void Initialize (bool overwrite = true) {
+			if (overwrite || attachment == null) {
+				// Get the applyPMA value.
+				var skeletonComponent = GetComponent<ISkeletonComponent>();
+				var skeletonRenderer = skeletonComponent as SkeletonRenderer;
+				if (skeletonRenderer != null)
+					this.applyPMA = skeletonRenderer.pmaVertexColors;
+				else {
+					var skeletonGraphic = skeletonComponent as SkeletonGraphic;
+					if (skeletonGraphic != null)
+						this.applyPMA = skeletonGraphic.MeshGenerator.settings.pmaVertexColors;
+				}
+
+				// Subscribe to UpdateComplete to override animation keys.
+				if (overrideAnimation) {
+					var animatedSkeleton = skeletonComponent as ISkeletonAnimation;
+					if (animatedSkeleton != null) {
+						animatedSkeleton.UpdateComplete -= AnimationOverrideSpriteAttach;
+						animatedSkeleton.UpdateComplete += AnimationOverrideSpriteAttach;
+					}
+				}
+
+				spineSlot = spineSlot ?? skeletonComponent.Skeleton.FindSlot(slot);
+				Shader attachmentShader = applyPMA ? Shader.Find(DefaultPMAShader) : Shader.Find(DefaultStraightAlphaShader);
+				if (sprite == null)
+					attachment = null;
+				else
+					attachment = applyPMA ? sprite.ToRegionAttachmentPMAClone(attachmentShader) : sprite.ToRegionAttachment(SpriteAttacher.GetPageFor(sprite.texture, attachmentShader));
+			}
+		}
+
+		void OnDestroy () {
+			var animatedSkeleton = GetComponent<ISkeletonAnimation>();
+			if (animatedSkeleton != null)
+				animatedSkeleton.UpdateComplete -= AnimationOverrideSpriteAttach;
+		}
+
+		/// <summary>Update the slot's attachment to the Attachment generated from the sprite.</summary>
+		public void Attach () {
+			if (spineSlot != null)
+				spineSlot.Attachment = attachment;
+		}
+
+	}
+
+
+	public static class SpriteAttachmentExtensions {
+		[System.Obsolete]
+		public static RegionAttachment AttachUnitySprite (this Skeleton skeleton, string slotName, Sprite sprite, string shaderName = SpriteAttacher.DefaultPMAShader, bool applyPMA = true, float rotation = 0f) {
+			return skeleton.AttachUnitySprite(slotName, sprite, Shader.Find(shaderName), applyPMA, rotation: rotation);
+		}
+
+		[System.Obsolete]
+		public static RegionAttachment AddUnitySprite (this SkeletonData skeletonData, string slotName, Sprite sprite, string skinName = "", string shaderName = SpriteAttacher.DefaultPMAShader, bool applyPMA = true, float rotation = 0f) {
+			return skeletonData.AddUnitySprite(slotName, sprite, skinName, Shader.Find(shaderName), applyPMA, rotation: rotation);
+		}
+
+		[System.Obsolete]
+		public static RegionAttachment AttachUnitySprite (this Skeleton skeleton, string slotName, Sprite sprite, Shader shader, bool applyPMA, float rotation = 0f) {
+			RegionAttachment att = applyPMA ? sprite.ToRegionAttachmentPMAClone(shader, rotation: rotation) : sprite.ToRegionAttachment(new Material(shader), rotation: rotation);
+			skeleton.FindSlot(slotName).Attachment = att;
+			return att;
+		}
+
+		[System.Obsolete]
+		public static RegionAttachment AddUnitySprite (this SkeletonData skeletonData, string slotName, Sprite sprite, string skinName, Shader shader, bool applyPMA, float rotation = 0f) {
+			RegionAttachment att = applyPMA ? sprite.ToRegionAttachmentPMAClone(shader, rotation: rotation) : sprite.ToRegionAttachment(new Material(shader), rotation);
+
+			var slotIndex = skeletonData.FindSlotIndex(slotName);
+			Skin skin = skeletonData.DefaultSkin;
+			if (skinName != "")
+				skin = skeletonData.FindSkin(skinName);
+
+			if (skin != null)
+				skin.SetAttachment(slotIndex, att.Name, att);
+
+			return att;
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Sample Components/Legacy/SpriteAttacher.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2ee7b5e36685e2445a0097de42940987
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

unity/Assets/Spine Examples/Scripts/Sample Components/OutlineSkeletonGraphic.cs

@@ -0,0 +1,69 @@
+/******************************************************************************
+ * 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;
+using Spine.Unity;
+
+namespace Spine.Unity.Examples {
+
+	public class OutlineSkeletonGraphic : MonoBehaviour {
+
+		public SkeletonGraphic skeletonGraphic;
+		public Material materialWithoutOutline;
+		public Material materialWithOutline;
+
+		#if UNITY_EDITOR
+		void Reset () {
+			skeletonGraphic = GetComponent<SkeletonGraphic>();
+
+			// Add normal material as default
+			if (skeletonGraphic != null && skeletonGraphic.skeletonDataAsset != null) {
+				var atlasAssets = skeletonGraphic.skeletonDataAsset.atlasAssets;
+
+				if (atlasAssets.Length > 0 && atlasAssets[0].PrimaryMaterial) {
+					materialWithoutOutline = atlasAssets[0].PrimaryMaterial;
+				}
+			}
+		}
+		#endif
+
+		void OnEnable () {
+			if (skeletonGraphic == null)
+				skeletonGraphic = GetComponent<SkeletonGraphic>();
+		}
+
+		public void EnableOutlineRendering () {
+			skeletonGraphic.material = materialWithOutline;
+		}
+
+		public void  DisableOutlineRendering () {
+			skeletonGraphic.material = materialWithoutOutline;
+		}
+	}
+}

unity/Assets/Spine Examples/Scripts/Sample Components/OutlineSkeletonGraphic.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 78ceaa27e3b3c27498dcdd7729ebad83
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: