302 lines
13 KiB
C#
302 lines
13 KiB
C#
using System;
|
|
#if UNITY_EDITOR
|
|
using System.Collections.Generic;
|
|
using UnityEditor;
|
|
|
|
|
|
namespace UnityEngine.Timeline
|
|
{
|
|
static class AnimationPreviewUtilities
|
|
{
|
|
private const string k_PosX = "m_LocalPosition.x";
|
|
private const string k_PosY = "m_LocalPosition.y";
|
|
private const string k_PosZ = "m_LocalPosition.z";
|
|
private const string k_RotX = "m_LocalRotation.x";
|
|
private const string k_RotY = "m_LocalRotation.y";
|
|
private const string k_RotZ = "m_LocalRotation.z";
|
|
private const string k_RotW = "m_LocalRotation.w";
|
|
private const string k_ScaleX = "m_LocalScale.x";
|
|
private const string k_ScaleY = "m_LocalScale.y";
|
|
private const string k_ScaleZ = "m_LocalScale.z";
|
|
private const string k_EulerAnglesRaw = "localEulerAnglesRaw";
|
|
private const string k_EulerHint = "m_LocalEulerAnglesHint";
|
|
private const string k_Pos = "m_LocalPosition";
|
|
private const string k_Rot = "m_LocalRotation";
|
|
private const string k_MotionT = "MotionT";
|
|
private const string k_MotionQ = "MotionQ";
|
|
private const string k_RootT = "RootT";
|
|
private const string k_RootQ = "RootQ";
|
|
|
|
|
|
internal static Object s_PreviewDriver;
|
|
|
|
|
|
internal class EditorCurveBindingComparer : IEqualityComparer<EditorCurveBinding>
|
|
{
|
|
public bool Equals(EditorCurveBinding x, EditorCurveBinding y) { return x.path.Equals(y.path) && x.type == y.type && x.propertyName == y.propertyName; }
|
|
public int GetHashCode(EditorCurveBinding obj)
|
|
{
|
|
return obj.propertyName.GetHashCode() ^ obj.path.GetHashCode();
|
|
}
|
|
|
|
public static readonly EditorCurveBindingComparer Instance = new EditorCurveBindingComparer();
|
|
}
|
|
|
|
// a dictionary is faster than a hashset, because the capacity can be pre-set
|
|
private static readonly Dictionary<EditorCurveBinding, int> s_CurveSet = new Dictionary<EditorCurveBinding, int>(10000, EditorCurveBindingComparer.Instance);
|
|
private static readonly AnimatorBindingCache s_BindingCache = new AnimatorBindingCache();
|
|
|
|
// string.StartsWith is slow (https://docs.unity3d.com/Manual/BestPracticeUnderstandingPerformanceInUnity5.html)
|
|
// hand rolled version has best performance.
|
|
private static bool FastStartsWith(string a, string toCompare)
|
|
{
|
|
int aLen = a.Length;
|
|
int bLen = toCompare.Length;
|
|
|
|
int ap = 0;
|
|
int bp = 0;
|
|
|
|
while (ap < aLen && bp < bLen && a[ap] == toCompare[bp])
|
|
{
|
|
ap++;
|
|
bp++;
|
|
}
|
|
|
|
return (bp == bLen);
|
|
}
|
|
|
|
public static void ClearCaches()
|
|
{
|
|
s_BindingCache.Clear();
|
|
s_CurveSet.Clear();
|
|
}
|
|
|
|
public static EditorCurveBinding[] GetBindings(GameObject animatorRoot, IEnumerable<AnimationClip> clips)
|
|
{
|
|
s_CurveSet.Clear();
|
|
foreach (var clip in clips)
|
|
{
|
|
AddBindings(s_BindingCache.GetCurveBindings(clip));
|
|
}
|
|
|
|
// if we have a transform binding, bind the entire skeleton
|
|
if (NeedsSkeletonBindings(s_CurveSet.Keys))
|
|
AddBindings(s_BindingCache.GetAnimatorBindings(animatorRoot));
|
|
|
|
var bindings = new EditorCurveBinding[s_CurveSet.Keys.Count];
|
|
s_CurveSet.Keys.CopyTo(bindings, 0);
|
|
return bindings;
|
|
}
|
|
|
|
public static int GetClipHash(List<AnimationClip> clips)
|
|
{
|
|
int hash = 0;
|
|
|
|
foreach (var clip in clips)
|
|
{
|
|
var stats = AnimationUtility.GetAnimationClipStats(clip);
|
|
hash = HashUtility.CombineHash(hash, clip.GetHashCode(), stats.clips, stats.size, stats.totalCurves);
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
public static void PreviewFromCurves(GameObject animatorRoot, IEnumerable<EditorCurveBinding> keys)
|
|
{
|
|
if (!AnimationMode.InAnimationMode())
|
|
return;
|
|
|
|
var avatarRoot = GetAvatarRoot(animatorRoot);
|
|
foreach (var binding in keys)
|
|
{
|
|
if (IsAvatarBinding(binding) || IsEuler(binding))
|
|
continue;
|
|
|
|
bool isTransform = typeof(Transform).IsAssignableFrom(binding.type);
|
|
if (isTransform && binding.propertyName.Equals(AnimatorBindingCache.TRPlaceHolder))
|
|
AddTRBinding(animatorRoot, binding);
|
|
else if (isTransform && binding.propertyName.Equals(AnimatorBindingCache.ScalePlaceholder))
|
|
AddScaleBinding(animatorRoot, binding);
|
|
else
|
|
AnimationMode.AddEditorCurveBinding(avatarRoot, binding);
|
|
}
|
|
}
|
|
|
|
public static AnimationClip CreateDefaultClip(GameObject animatorRoot, IEnumerable<EditorCurveBinding> keys)
|
|
{
|
|
AnimationClip animClip = new AnimationClip() { name = "DefaultPose" };
|
|
var keyFrames = new[] {new Keyframe(0, 0)};
|
|
var curve = new AnimationCurve(keyFrames);
|
|
bool rootMotion = false;
|
|
var avatarRoot = GetAvatarRoot(animatorRoot);
|
|
|
|
foreach (var binding in keys)
|
|
{
|
|
if (IsRootMotion(binding))
|
|
{
|
|
rootMotion = true;
|
|
continue;
|
|
}
|
|
|
|
if (typeof(Transform).IsAssignableFrom(binding.type) && binding.propertyName.Equals(AnimatorBindingCache.TRPlaceHolder))
|
|
{
|
|
if (string.IsNullOrEmpty(binding.path))
|
|
rootMotion = true;
|
|
else
|
|
{
|
|
var transform = animatorRoot.transform.Find(binding.path);
|
|
if (transform != null)
|
|
{
|
|
var pos = transform.localPosition;
|
|
var rot = transform.localRotation;
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_PosX, SetZeroKey(curve, keyFrames, pos.x));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_PosY, SetZeroKey(curve, keyFrames, pos.y));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_PosZ, SetZeroKey(curve, keyFrames, pos.z));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_RotX, SetZeroKey(curve, keyFrames, rot.x));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_RotY, SetZeroKey(curve, keyFrames, rot.y));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_RotZ, SetZeroKey(curve, keyFrames, rot.z));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_RotW, SetZeroKey(curve, keyFrames, rot.w));
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (typeof(Transform).IsAssignableFrom(binding.type) && binding.propertyName == AnimatorBindingCache.ScalePlaceholder)
|
|
{
|
|
var transform = animatorRoot.transform.Find(binding.path);
|
|
if (transform != null)
|
|
{
|
|
var scale = transform.localScale;
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_ScaleX, SetZeroKey(curve, keyFrames, scale.x));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_ScaleY, SetZeroKey(curve, keyFrames, scale.y));
|
|
animClip.SetCurve(binding.path, typeof(Transform), k_ScaleZ, SetZeroKey(curve, keyFrames, scale.z));
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Not setting curves through AnimationUtility.SetEditorCurve to avoid reentrant
|
|
// onCurveWasModified calls in timeline. This means we don't get sprite curves
|
|
// in the default clip right now.
|
|
if (IsAvatarBinding(binding) || IsEulerHint(binding) || binding.isPPtrCurve)
|
|
continue;
|
|
|
|
float floatValue;
|
|
AnimationUtility.GetFloatValue(avatarRoot, binding, out floatValue);
|
|
animClip.SetCurve(binding.path, binding.type, binding.propertyName, SetZeroKey(curve, keyFrames, floatValue));
|
|
}
|
|
|
|
// add root motion explicitly.
|
|
if (rootMotion)
|
|
{
|
|
var pos = Vector3.zero; // the appropriate root motion offsets are applied by timeline
|
|
var rot = Quaternion.identity;
|
|
animClip.SetCurve(string.Empty, typeof(Transform), k_PosX, SetZeroKey(curve, keyFrames, pos.x));
|
|
animClip.SetCurve(string.Empty, typeof(Transform), k_PosY, SetZeroKey(curve, keyFrames, pos.y));
|
|
animClip.SetCurve(string.Empty, typeof(Transform), k_PosZ, SetZeroKey(curve, keyFrames, pos.z));
|
|
animClip.SetCurve(string.Empty, typeof(Transform), k_RotX, SetZeroKey(curve, keyFrames, rot.x));
|
|
animClip.SetCurve(string.Empty, typeof(Transform), k_RotY, SetZeroKey(curve, keyFrames, rot.y));
|
|
animClip.SetCurve(string.Empty, typeof(Transform), k_RotZ, SetZeroKey(curve, keyFrames, rot.z));
|
|
animClip.SetCurve(string.Empty, typeof(Transform), k_RotW, SetZeroKey(curve, keyFrames, rot.w));
|
|
}
|
|
|
|
return animClip;
|
|
}
|
|
|
|
public static bool IsRootMotion(EditorCurveBinding binding)
|
|
{
|
|
// Root Transform TR.
|
|
if (typeof(Transform).IsAssignableFrom(binding.type) && string.IsNullOrEmpty(binding.path))
|
|
{
|
|
return FastStartsWith(binding.propertyName, k_Pos) || FastStartsWith(binding.propertyName, k_Rot);
|
|
}
|
|
|
|
// MotionCurves/RootCurves.
|
|
if (binding.type == typeof(Animator))
|
|
{
|
|
return FastStartsWith(binding.propertyName, k_MotionT) ||
|
|
FastStartsWith(binding.propertyName, k_MotionQ) ||
|
|
FastStartsWith(binding.propertyName, k_RootT) ||
|
|
FastStartsWith(binding.propertyName, k_RootQ);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool NeedsSkeletonBindings(IEnumerable<EditorCurveBinding> bindings)
|
|
{
|
|
foreach (var b in bindings)
|
|
{
|
|
if (IsSkeletalBinding(b))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static void AddBindings(IEnumerable<EditorCurveBinding> bindings)
|
|
{
|
|
foreach (var b in bindings)
|
|
{
|
|
if (!s_CurveSet.ContainsKey(b))
|
|
s_CurveSet[b] = 1;
|
|
}
|
|
}
|
|
|
|
private static void AddTRBinding(GameObject root, EditorCurveBinding binding)
|
|
{
|
|
var t = root.transform.Find(binding.path);
|
|
if (t != null)
|
|
{
|
|
DrivenPropertyManager.RegisterProperty(s_PreviewDriver, t, "m_LocalPosition");
|
|
DrivenPropertyManager.RegisterProperty(s_PreviewDriver, t, "m_LocalRotation");
|
|
}
|
|
}
|
|
|
|
private static void AddScaleBinding(GameObject root, EditorCurveBinding binding)
|
|
{
|
|
var t = root.transform.Find(binding.path);
|
|
if (t != null)
|
|
DrivenPropertyManager.RegisterProperty(s_PreviewDriver, t, "m_LocalScale");
|
|
}
|
|
|
|
private static bool IsEuler(EditorCurveBinding binding)
|
|
{
|
|
return FastStartsWith(binding.propertyName, k_EulerAnglesRaw) &&
|
|
typeof(Transform).IsAssignableFrom(binding.type);
|
|
}
|
|
|
|
private static bool IsAvatarBinding(EditorCurveBinding binding)
|
|
{
|
|
return string.IsNullOrEmpty(binding.path) && typeof(Animator) == binding.type;
|
|
}
|
|
|
|
private static bool IsSkeletalBinding(EditorCurveBinding binding)
|
|
{
|
|
// skin mesh incorporates blend shapes
|
|
return typeof(Transform).IsAssignableFrom(binding.type) || typeof(SkinnedMeshRenderer).IsAssignableFrom(binding.type);
|
|
}
|
|
|
|
private static AnimationCurve SetZeroKey(AnimationCurve curve, Keyframe[] keys, float val)
|
|
{
|
|
keys[0].value = val;
|
|
curve.keys = keys;
|
|
return curve;
|
|
}
|
|
|
|
private static bool IsEulerHint(EditorCurveBinding binding)
|
|
{
|
|
return typeof(Transform).IsAssignableFrom(binding.type) && binding.propertyName.StartsWith(k_EulerHint);
|
|
}
|
|
|
|
private static GameObject GetAvatarRoot(GameObject animatorRoot)
|
|
{
|
|
var animator = animatorRoot.GetComponent<Animator>();
|
|
if (animator != null && animator.avatarRoot != animatorRoot.transform)
|
|
return animator.avatarRoot.gameObject;
|
|
return animatorRoot;
|
|
}
|
|
}
|
|
}
|
|
#endif
|