LandslideEmergencyEvacuation/EmergencyEvacuation/Assets/Plugins/RootMotion/FinalIK/IK Solvers/IKSolverLimb.cs

using UnityEngine;
using System.Collections;

namespace RootMotion.FinalIK {

	/// <summary>
	/// Extends IKSolverTrigonometric to add automatic bend and rotation modes.
	/// </summary>
	[System.Serializable]
	public class IKSolverLimb : IKSolverTrigonometric {
		
		#region Main Interface
		
		/// <summary>
		/// The AvatarIKGoal of this solver.
		/// </summary>
		public AvatarIKGoal goal;
		/// <summary>
		/// Bend normal modifier.
		/// </summary>
		public BendModifier bendModifier;
		/// <summary>
		/// Weight of maintaining the rotation of the third bone as it was before solving.
		/// </summary>
		[Range(0f, 1f)]
		public float maintainRotationWeight;
		/// <summary>
		/// Weight of bend normal modifier.
		/// </summary>
		[Range(0f, 1f)]
		public float bendModifierWeight = 1f;
		/// <summary>
		/// The bend goal Transform.
		/// </summary>
		public Transform bendGoal;

		/// <summary>
		/// Used to record rotation of the last bone for one frame. 
		/// If MaintainRotation is not called and maintainRotationWeight > 0, the solver will maintain the rotation of the last bone as it was before solving the %IK.
		/// You will probably need this if you wanted to maintain the animated rotation of a foot despite of any other %IK solver that manipulates its parents' rotation.
		/// So you would call %MaintainRotation() in LateUpdate() after animation and before updating the Spine %IK solver that would change the foot's rotation.
		/// </summary>
		public void MaintainRotation() {
			if (!initiated) return;
			
			maintainRotation = bone3.transform.rotation;
			maintainRotationFor1Frame = true;
		}
		
		/// <summary>
		/// If Auto Bend is on "Animation', %MaintainBend() can be used to set the bend axis relative to the first bone's rotation.
		/// </summary>
		public void MaintainBend() {
			if (!initiated) return;
			
			animationNormal = bone1.GetBendNormalFromCurrentRotation();
			
			maintainBendFor1Frame = true;
		}
		
		/// <summary>
		/// Automatic bend modes.
		/// </summary>
		[System.Serializable]
		public enum BendModifier {
			Animation, // Bending relative to the animated rotation of the first bone
			Target, // Bending relative to IKRotation
			Parent, // Bending relative to parentBone
			Arm, // Arm modifier tries to find the most biometrically natural and relaxed arm bend plane
			Goal // Use the bend goal Transform
		}
		
		#endregion Main Interface
		
		/*
		 * Override before Initiate
		 * */
		protected override void OnInitiateVirtual() {
			defaultRootRotation = root.rotation;
			
			if (bone1.transform.parent != null) {
				parentDefaultRotation = Quaternion.Inverse(defaultRootRotation) * bone1.transform.parent.rotation;
			}
			
			if (bone3.rotationLimit != null) bone3.rotationLimit.Disable();
			bone3DefaultRotation = bone3.transform.rotation;
			
			// Set bend plane to current (cant use the public SetBendPlaneToCurrent() method here because the solver has not initiated yet)
			Vector3 normal = Vector3.Cross(bone2.transform.position - bone1.transform.position, bone3.transform.position - bone2.transform.position);
			if (normal != Vector3.zero) bendNormal = normal;
			
			animationNormal = bendNormal;
			
			StoreAxisDirections(ref axisDirectionsLeft);
			StoreAxisDirections(ref axisDirectionsRight);
		}
		
		/*
		 * Changing stuff in Update() before solving
		 * */
		protected override void OnUpdateVirtual() {
			if (IKPositionWeight > 0) {
				// Clamping weights
				bendModifierWeight = Mathf.Clamp(bendModifierWeight, 0f, 1f);
				maintainRotationWeight = Mathf.Clamp(maintainRotationWeight, 0f, 1f);
				
				// Storing the bendNormal for reverting after solving
				_bendNormal = bendNormal;
				
				// Modifying bendNormal
				bendNormal = GetModifiedBendNormal();
			}
			
			if (maintainRotationWeight * IKPositionWeight > 0) {
				// Storing bone3 rotation
				bone3RotationBeforeSolve = maintainRotationFor1Frame? maintainRotation : bone3.transform.rotation;
				maintainRotationFor1Frame = false;
			}
		}
		
		/*
		 * Changing stuff in Update() after solving
		 * */
		protected override void OnPostSolveVirtual() {
			// Revert bendNormal to what it was before solving
			if (IKPositionWeight > 0) bendNormal = _bendNormal;
			
			// Auto rotation modes
			if (maintainRotationWeight * IKPositionWeight > 0) {
				bone3.transform.rotation = Quaternion.Slerp(bone3.transform.rotation, bone3RotationBeforeSolve, maintainRotationWeight * IKPositionWeight);
			}
		}
		
		/*
		 * Axis direction contains an arm bend axis for a specific IKPosition direction from the first bone. Used in Arm BendModifier mode.
		 * */
		[System.Serializable]
		public struct AxisDirection {
			public Vector3 direction;
			public Vector3 axis;
			public float dot;
			
			public AxisDirection(Vector3 direction, Vector3 axis) {
				this.direction = direction.normalized;
				this.axis = axis.normalized;
				this.dot = 0;
			}
		}
		
		public IKSolverLimb() {}
		
		public IKSolverLimb(AvatarIKGoal goal) {
			this.goal = goal;
		}
		
		private bool maintainBendFor1Frame, maintainRotationFor1Frame;
		private Quaternion defaultRootRotation, parentDefaultRotation, bone3RotationBeforeSolve, maintainRotation, bone3DefaultRotation;
		private Vector3 _bendNormal, animationNormal;
		private AxisDirection[] axisDirectionsLeft = new AxisDirection[4];
		private AxisDirection[] axisDirectionsRight = new AxisDirection[4];
		private AxisDirection[] axisDirections {
			get {
				if (goal == AvatarIKGoal.LeftHand) return axisDirectionsLeft;
				return axisDirectionsRight;
			}
		}
		
		/*
		 * Storing Bend axes for arm directions. The directions and axes here were found empirically, feel free to edit, add or remove.
		 * All vectors are in default character rotation space, where x is right and z is forward.
		 * */
		private void StoreAxisDirections(ref AxisDirection[] axisDirections) {
			axisDirections[0] = new AxisDirection(Vector3.zero, new Vector3(-1f, 0f, 0f)); // default
			axisDirections[1] = new AxisDirection(new Vector3(0.5f, 0f, -0.2f), new Vector3(-0.5f, -1f, 1f)); // behind head
			axisDirections[2] = new AxisDirection(new Vector3(-0.5f, -1f, -0.2f), new Vector3(0f, 0.5f, -1f)); // arm twist
			axisDirections[3] = new AxisDirection(new Vector3(-0.5f, -0.5f, 1f), new Vector3(-1f, -1f, -1f)); // cross heart
		}
		
		/*
		 * Modifying bendNormal
		 * */
		private Vector3 GetModifiedBendNormal() {
			float weight = bendModifierWeight;
			if (weight <= 0) return bendNormal;
			
			switch(bendModifier) {
			// Animation Bend Mode attempts to maintain the bend axis as it is in the animation
			case BendModifier.Animation:
				if (!maintainBendFor1Frame) MaintainBend();
				maintainBendFor1Frame = false;
				return Vector3.Lerp(bendNormal, animationNormal, weight);
				
			// Bending relative to the parent of the first bone
			case BendModifier.Parent:
				if (bone1.transform.parent == null) return bendNormal;
				
				Quaternion parentRotation = bone1.transform.parent.rotation * Quaternion.Inverse(parentDefaultRotation);
				return Quaternion.Slerp(Quaternion.identity, parentRotation * Quaternion.Inverse(defaultRootRotation), weight) * bendNormal;
				
			// Bending relative to IKRotation
			case BendModifier.Target:
				Quaternion targetRotation = IKRotation * Quaternion.Inverse(bone3DefaultRotation);
				return Quaternion.Slerp(Quaternion.identity, targetRotation, weight) * bendNormal;

			// Anatomic Arm
			case BendModifier.Arm:
				if (bone1.transform.parent == null) return bendNormal;
				
				// Disabling this for legs
				if (goal == AvatarIKGoal.LeftFoot || goal == AvatarIKGoal.RightFoot) {
					if (!Warning.logged) LogWarning("Trying to use the 'Arm' bend modifier on a leg.");
					return bendNormal;
				}
				
				Vector3 direction = (IKPosition - bone1.transform.position).normalized;
				
				// Converting direction to default world space
				direction = Quaternion.Inverse(bone1.transform.parent.rotation * Quaternion.Inverse(parentDefaultRotation)) * direction;
				
				// Inverting direction for left hand
				if (goal == AvatarIKGoal.LeftHand) direction.x = -direction.x;
				
				// Calculating dot products for all AxisDirections
				for (int i = 1; i < axisDirections.Length; i++) {
					axisDirections[i].dot = Mathf.Clamp(Vector3.Dot(axisDirections[i].direction, direction), 0f, 1f);
					axisDirections[i].dot = Interp.Float(axisDirections[i].dot, InterpolationMode.InOutQuintic);
				}
				
				// Summing up the arm bend axis
				Vector3 sum = axisDirections[0].axis;
				
				//for (int i = 1; i < axisDirections.Length; i++) sum = Vector3.Lerp(sum, axisDirections[i].axis, axisDirections[i].dot);
				for (int i = 1; i < axisDirections.Length; i++) sum = Vector3.Slerp(sum, axisDirections[i].axis, axisDirections[i].dot);
				
				// Inverting sum for left hand
				if (goal == AvatarIKGoal.LeftHand) {
					sum.x = -sum.x;
					sum = -sum;
				}
				
				// Converting sum back to parent space
				Vector3 armBendNormal = bone1.transform.parent.rotation * Quaternion.Inverse(parentDefaultRotation) * sum;
				
				if (weight >= 1) return armBendNormal;
				return Vector3.Lerp(bendNormal, armBendNormal, weight);
			
			// Bending towards the bend goal Transform
			case BendModifier.Goal:
				if (bendGoal == null) {
					if (!Warning.logged) LogWarning("Trying to use the 'Goal' Bend Modifier, but the Bend Goal is unassigned.");
					return bendNormal;
				}

				Vector3 normal = Vector3.Cross(bendGoal.position - bone1.transform.position, IKPosition - bone1.transform.position);

				if (normal == Vector3.zero) return bendNormal;

				if (weight >= 1f) return normal;
				return Vector3.Lerp(bendNormal, normal, weight);
			default: return bendNormal;
			}
		}
	}
}