IK（反向动力学）
反向运动学 (IK) 是一种设置动画的方法，它翻转链操纵的方向。它是从叶子而不是根开始进行工作的。
要了解 IK 是如何进行工作的，首先必须了解层次链接和正向运动学的原则。
简单演示
现在举个手臂的例子。要设置使用正向运动学的手臂的动画，可以旋转大臂使它移离肩膀，然后旋转小臂，手部等等，为每个子对象添加旋转关键点。
要设置使用反向运动学的手臂的动画，可以移动用以定位腕部的目标。手臂的上半部分和下半部分为 IK 解决方案所旋转，使称为末端效应器的腕部轴点向着目标移动。
|
|
|
- 反向运动学定义为确定一组适当的关节构型，使末端尽可能平稳、快速、准确地移动到所需位置的问题。
- 是一种通过估计每个独立自由度来计算姿态的方法，以满足用户约束的给定任务。
反向动力学的实现方法有很多种，常见的有 CCD（循环坐标下降法），FABR（前向和后向法），本文只说明反向动力学的基本方法。
策略思路
1.从最小子骨骼开始遍历并趋近目标
2.每个骨骼都将其子骨骼的轴点作为跟随点（最小子骨骼无子节点需直接跟随目标点），开始趋近
3.骨骼跟随方法为，以自身轴点与目标点的方向为骨骼变换方向，并将骨骼终点与目标点对齐
从目标点（X）开始求解，并从链式结构的“叶节点”到“根节点”逐渐将整个链式结构趋近目标位置。
范例：
构建链式结构：[P2,P1]、[P3,P2]、[P4,P3]，其长度分别为d1,d2,d3
（A）从尾端开始，以[P4,P3]开始逼近 X点,
（B）d3趋近，连接[P3, X], 将[P4,P3]移动至[P4‘,P3’],P4’ == X
（C）d2趋近，连接[P2, P3’],将[P3,P2]移动至[P3’,P2’]
（D）d1趋近，连接[P1, P2’],将[P2,P1]移动至[P2’,P1‘] 
角度限制
特殊情况下，得到运动的形状还不够，还需要进行一定的运动限制，现实中每一根骨骼在运动的过程中往往都会受到铰连接，带来的运动角度限制！
在链式结构跟随目标点运动时每个骨骼的运动角度都是相对的，即每个骨骼的角度限制都是以其子骨骼为相对方向（与子骨骼世界方向相同时角度为0°，相反时为180°或-180°），那么自然叶子节点因为没有子骨骼就没有什么限制（你要想有的话也可以有的，我这里不做实现）。
下图：
a为父骨骼，b 为子骨骼，那么，a的限制角度计算方式就为，a方向 旋转到 b方向 的角度为准，范围为（-180,180）,角度的限制在跟随的过程中计算即可。
实现代码：
Segment 类
public class Segment
{
public float len; //线段长度
public Vector2 angleLimt = new Vector2(-180f, 180f); //角度限制范围
public Color color = Color.white; //Gizmo color
public Vector2 a { get; private set; } //线段起点
public Vector2 b { get; private set; } //线段终点
public Vector2 forward { get { return (b - a).normalized; } } //线段终点方向
/// <summary>
/// 跟随目标节点,并计算自身位置
/// </summary>
/// <param name="target">目标点位置</param>
/// <param name="prevDir">上一线段的方向</param>
/// <param name="limt">是否使用角度限制</param>
/// <param name="isForward">是否将线段终点作为向前方向</param>
public void Follow(Vector2 target, Vector2 prevDir, Vector2 limt, bool isForward = true)
{
if (isForward)
{
a = -(target - a).normalized * len + target;
b = target;
}
else
{
a = target;
b = -(target - b).normalized * len + target;
}
if (limt.x != -180 || limt.y != 180) LimtAngle(prevDir, limt, isForward);
}
/// <summary>
/// 角度限制
/// </summary>
/// <param name="prevDir">上一线段的方向</param>
/// <param name="limt">角度的限制范围</param>
/// <param name="isForward">是否将线段终点作为向前方向</param>
private void LimtAngle(Vector2 prevDir, Vector2 limt, bool isForward = true)
{
float angle = Vector2.SignedAngle(prevDir, forward);
if (isForward)
{
if (-angle < limt.x)
{
a = -Rotate(prevDir, -limt.x) * len + b;
}
else if (-angle > limt.y)
{
a = -Rotate(prevDir, -limt.y) * len + b;
}
}
else
{
if (angle < limt.x)
{
b = Rotate(prevDir, limt.x) * len + a;
}
else if (angle > limt.y)
{
b = Rotate(prevDir, limt.y) * len + a;
}
}
}
/// <summary>
/// 返回旋转后的角度
/// </summary>
/// <param name="v">normal</param>
/// <param name="a">rad</param>
private Vector2 Rotate(Vector2 v, float a)
{
a = a * Mathf.Deg2Rad + Mathf.Atan2(v.y, v.x);
return new Vector2(Mathf.Cos(a), Mathf.Sin(a));
}
}
IKSolverSimp 类
public class IKSolverSimp {
public Segment[] segments = new Segment[] { };
public Vector2 target; //目标位置
public bool useLimt = false; //是否启用角度限制
/// <summary>
/// 以线段的起点为正方向，开始趋近目标
/// </summary>
public void CalculateForback()
{
segments[0].Follow(target, Vector2.zero, useLimt ? Vector2.zero : new Vector2(-180,180), false);
for (int i = 1; i < segments.Length; i++)
{
segments[i].Follow(segments[i - 1].b, segments[i - 1].forward, useLimt ? segments[i].angleLimt : new Vector2(-180, 180), false);
}
}
/// <summary>
/// 以线段的终点为正方向，开始趋近目标
/// </summary>
public void CalculateForward()
{
segments[segments.Length - 1].Follow(target, Vector2.zero, useLimt ? Vector2.zero : new Vector2(-180, 180), true);
for (int i = segments.Length - 2; i > -1; i--)
{
segments[i].Follow(segments[i + 1].a, segments[i + 1].forward, useLimt ? segments[i + 1].angleLimt : new Vector2(-180, 180), true);
}
}
}
SimpIKTest 类
public class SimpIKTest : MonoBehaviour
{
public IKSolverSimp iKSolverSimp; //简单解算器
public Transform targetP; //目标点位置
public bool useLimt = true; //使用限制
public bool update = false; //实时更新
public bool isHeadFollow = true; //线段起点为正方向
[Button("Calculate")] //需要插件：Sirenix.OdinInspector；或替换为[ContextMenu("Calculate")]
void Calculate()
{
iKSolverSimp.useLimt = useLimt;
iKSolverSimp.target = targetP.position;
if (isHeadFollow)
{
iKSolverSimp.CalculateForback();
}
else
{
iKSolverSimp.CalculateForward();
}
}
private void OnDrawGizmos()
{
if (targetP == null) return;
if (update) Calculate();
Segment last = null;
foreach (var item in iKSolverSimp.segments)
{
Gizmos.color = item.color;
Mov.GizmeDrawArrow(item.a, item.b);
if (useLimt && last != null)
{
Mov.GizmeDrawCircleLimt(item.a, (item.b - item.a).normalized, item.angleLimt, 0, item.len / 4f, last.a);
}
last = item;
}
}
}
public static class Mov{
public static Vector2 Rotate(Vector2 v, float a)
{
Vector2 n = v.normalized;
a += Mathf.Atan2(n.y, n.x);
return new Vector2(Mathf.Cos(a),Mathf.Sin(a)) * v.magnitude;
}
public static void GizmeDrawArrow(Vector2 a, Vector2 b)
{
Vector2 dir = (a - b).normalized;
float l = (a - b).magnitude * 0.2f;
Vector2 u = Rotate(dir, 30 * Mathf.Deg2Rad) * l;
Vector2 d = Rotate(dir, -30 * Mathf.Deg2Rad) * l;
Gizmos.DrawLine(a, b);
Gizmos.DrawLine(b, b + u);
Gizmos.DrawLine(b, b + d);
}
public static void GizmeDrawCircleLimt(Vector2 anchor, Vector2 right, Vector2 limt, float angleOff, float len, Vector2 anchor2)
{
Vector2 dir = right * len;
Vector2 a, b, c;
a = anchor;
b = a + Rotate(dir, -(limt.x + angleOff) * Mathf.Deg2Rad);
c = a + Rotate(dir, -(limt.y + angleOff) * Mathf.Deg2Rad);
Color green = new Color(0, 1, 1, .3f);
Color blue = new Color(0, 0, 1, .3f);
Color white = new Color(1, 1, 1, .3f);
Color black = new Color(0, 0, 0, .3f);
Gizmos.color = green;
Gizmos.DrawLine(a, b);
Gizmos.color = blue;
Gizmos.DrawLine(a, c);
Vector2 s = b - a;
float rad = (limt.y - limt.x) * Mathf.Deg2Rad;
for (float i = 0; i < 1f; i += 0.1f)
{
Gizmos.color = Color.Lerp(green, black, i);
Gizmos.DrawLine(a + Mov.Rotate(s, -i * rad), a + Mov.Rotate(s, -(i + 0.1f) * rad));
}
if (anchor != anchor2)
{
Gizmos.color = white;
Gizmos.DrawLine(a, a + (a - anchor2).normalized * len * 1.05f);
}
}
}
效果演示(角度限制与无限制)
扫一扫
3313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
