using UnityEngine;
using System.Collections;
namespace RootMotion.FinalIK {
///
/// Extends IKSolverTrigonometric to add automatic bend and rotation modes.
///
[System.Serializable]
public class IKSolverLimb : IKSolverTrigonometric {
#region Main Interface
///
/// The AvatarIKGoal of this solver.
///
public AvatarIKGoal goal;
///
/// Bend normal modifier.
///
public BendModifier bendModifier;
///
/// Weight of maintaining the rotation of the third bone as it was before solving.
///
[Range(0f, 1f)]
public float maintainRotationWeight;
///
/// Weight of bend normal modifier.
///
[Range(0f, 1f)]
public float bendModifierWeight = 1f;
///
/// The bend goal Transform.
///
public Transform bendGoal;
///
/// 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.
///
public void MaintainRotation() {
if (!initiated) return;
maintainRotation = bone3.transform.rotation;
maintainRotationFor1Frame = true;
}
///
/// If Auto Bend is on "Animation', %MaintainBend() can be used to set the bend axis relative to the first bone's rotation.
///
public void MaintainBend() {
if (!initiated) return;
animationNormal = bone1.GetBendNormalFromCurrentRotation();
maintainBendFor1Frame = true;
}
///
/// Automatic bend modes.
///
[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;
}
}
}
}