// 浮点数精度压缩到f3
public static void SeoAnimationFloat3(AnimationClip anim_clip)
{
AnimationUtility.GetCurveBindings(anim_clip);
AnimationClipCurveData[] curves = AnimationUtility.GetAllCurves(anim_clip);
int length = curves.Length;
for (int k = 0; k < length; k++)
{
AnimationClipCurveData curve_data = curves[k];
if (curve_data == null || curve_data.curve.keys == null)
{
continue;
}
Keyframe[] key_frames = curve_data.curve.keys;
for (int i = 0; i < key_frames.Length; i++)
{
Keyframe key_frame = key_frames[i];
key_frame.value = float.Parse(key_frame.value.ToString(FLOAT_FORMAT));
key_frame.inTangent = float.Parse(key_frame.inTangent.ToString(FLOAT_FORMAT));
key_frame.outTangent = float.Parse(key_frame.outTangent.ToString(FLOAT_FORMAT));
key_frames[i] = key_frame;
}
curve_data.curve.keys = key_frames;
anim_clip.SetCurve(curve_data.path, curve_data.type, curve_data.propertyName, curve_data.curve);
}
}
private void AddToList(AnimationClipCurveData curveData, List <Curve> curves)
{
var property = curveData.propertyName;
if (property.EndsWith("x"))
{
curves.Add(new Curve());
var item = curves.Last();
item.path = curveData.path;
item.preInfinity = (int)curveData.curve.preWrapMode;
item.postInfinity = (int)curveData.curve.postWrapMode;
AddToList(curveData, curves, 0);
}
else if (property.EndsWith("y"))
{
AddToList(curveData, curves, 1);
}
else if (property.EndsWith("z"))
{
AddToList(curveData, curves, 2);
}
else if (property.EndsWith("w"))
{
AddToList(curveData, curves, 3);
}
}
private static void CompressFloatPrecision(AnimationClip clip, int precision)
{
EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(clip);
AnimationClipCurveData[] curves = new AnimationClipCurveData[curveBindings.Length];
for (int index = 0; index < curves.Length; ++index)
{
curves[index] = new AnimationClipCurveData(curveBindings[index]);
curves[index].curve = AnimationUtility.GetEditorCurve(clip, curveBindings[index]);
}
foreach (AnimationClipCurveData curveDate in curves)
{
var keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
var key = keyFrames[i];
string precisionFormat = $"f{precision}";
key.value = float.Parse(key.value.ToString(precisionFormat));
key.inTangent = float.Parse(key.inTangent.ToString(precisionFormat));
key.outTangent = float.Parse(key.outTangent.ToString(precisionFormat));
key.inWeight = float.Parse(key.inWeight.ToString(precisionFormat));
key.outWeight = float.Parse(key.outWeight.ToString(precisionFormat));
keyFrames[i] = key;
}
curveDate.curve.keys = keyFrames;
clip.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
}
//压缩精度
public static void CompressAnimationClip(AnimationClip _clip)
{
AnimationClipCurveData[] tCurveArr = AnimationUtility.GetAllCurves(_clip);
Keyframe tKey;
Keyframe[] tKeyFrameArr;
for (int i = 0; i < tCurveArr.Length; ++i)
{
AnimationClipCurveData tCurveData = tCurveArr[i];
if (tCurveData.curve == null || tCurveData.curve.keys == null)
{
continue;
}
tKeyFrameArr = tCurveData.curve.keys;
for (int j = 0; j < tKeyFrameArr.Length; j++)
{
tKey = tKeyFrameArr[j];
tKey.value = float.Parse(tKey.value.ToString("f3")); //#.###
tKey.inTangent = float.Parse(tKey.inTangent.ToString("f3"));
tKey.outTangent = float.Parse(tKey.outTangent.ToString("f3"));
tKeyFrameArr[j] = tKey;
}
tCurveData.curve.keys = tKeyFrameArr;
_clip.SetCurve(tCurveData.path, tCurveData.type, tCurveData.propertyName, tCurveData.curve);
}
}
/// <summary>
/// 优化浮点数精度压缩到f3
/// </summary>
static void OptmizeAnimationFloat(ref AnimationClip srcClip, ref AnimationClip newClip)
{
var curves = AnimationUtility.GetAllCurves(srcClip);
for (int i = 0; i < curves.Length; ++i)
{
AnimationClipCurveData curveDate = curves[i];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
//Debug.LogWarning(string.Format("AnimationClipCurveData {0} don't have curve; Animation name {1} ", curveDate, animationPath));
continue;
}
var keyFrames = curveDate.curve.keys;
for (int j = 0; j < keyFrames.Length; j++)
{
var key = keyFrames[j];
key.value = float.Parse(key.value.ToString("f3"));
key.inTangent = float.Parse(key.inTangent.ToString("f3"));
key.outTangent = float.Parse(key.outTangent.ToString("f3"));
keyFrames[j] = key;
}
curveDate.curve.keys = keyFrames;
newClip.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
}
/// <summary>
///压缩动画，数值的精度改为3位
///去掉scale曲线
/// </summary>
public static void CompressAnimationClip(GameObject g)
{
List <AnimationClip> animationClipList = new List <AnimationClip>(AnimationUtility.GetAnimationClips(g));
if (animationClipList.Count == 0)
{
AnimationClip[] objectList = UnityEngine.Object.FindObjectsOfType(typeof(AnimationClip)) as AnimationClip[];
animationClipList.AddRange(objectList);
}
foreach (AnimationClip theAnimation in animationClipList)
{
try
{
if (!g.name.Contains("mon_3@show1"))
{
//去除scale曲线
foreach (EditorCurveBinding theCurveBinding in AnimationUtility.GetCurveBindings(theAnimation))
{
string name = theCurveBinding.propertyName.ToLower();
if (name.Contains("scale"))
{
AnimationUtility.SetEditorCurve(theAnimation, theCurveBinding, null);
}
}
}
//浮点数精度压缩到f3
AnimationClipCurveData[] curves = null;
#pragma warning disable CS0618 // 类型或成员已过时
curves = AnimationUtility.GetAllCurves(theAnimation);
#pragma warning restore CS0618 // 类型或成员已过时
Keyframe key;
Keyframe[] keyFrames;
for (int ii = 0; ii < curves.Length; ++ii)
{
AnimationClipCurveData curveDate = curves[ii];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
continue;
}
keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
key = keyFrames[i];
key.value = float.Parse(key.value.ToString("f4"));
key.inTangent = float.Parse(key.inTangent.ToString("f4"));
key.outTangent = float.Parse(key.outTangent.ToString("f4"));
keyFrames[i] = key;
}
curveDate.curve.keys = keyFrames;
theAnimation.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
}
catch (System.Exception e)
{
Debug.LogError(string.Format("CompressAnimationClip Failed !!! animationPath : {0} error: {1}", " ", e));
}
}
}
private static void ForFun(AnimationClip clip, string clipName)
{
EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(clip);
AnimationClipCurveData[] curves = new AnimationClipCurveData[curveBindings.Length];
for (int index = 0; index < curves.Length; ++index)
{
curves[index] = new AnimationClipCurveData(curveBindings[index]);
curves[index].curve = AnimationUtility.GetEditorCurve(clip, curveBindings[index]);
}
foreach (AnimationClipCurveData curveDate in curves)
{
var keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
var key = keyFrames[i];
key.value = float.Parse(key.value.ToString("f3"));
key.inTangent = float.Parse(key.inTangent.ToString("f3"));
key.outTangent = float.Parse(key.outTangent.ToString("f3"));
keyFrames[i] = key;
}
curveDate.curve.keys = keyFrames;
clip.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
AssetDatabase.CreateAsset(clip, clipName);
}
private void AddToList(AnimationClipCurveData curveData)
{
// string[] propertyDisplayName = {
// "m_LocalPosition", "Position",
// "m_LocalScale", "Scale",
// "m_LocalRotation", "Rotation",
// "localEulerAnglesBaked", "Rotation",
// "localEulerAngles", "Rotation",
// "m_Materials.Array.data", "Material Reference",
// };
var property = curveData.propertyName;
if (property.StartsWith("m_LocalPosition"))
{
AddToList(curveData, PositionCurves);
}
else if (property.StartsWith("m_LocalScale"))
{
AddToList(curveData, ScaleCurves);
}
else if (property.StartsWith("m_LocalRotation"))
{
AddToList(curveData, RotationCurves);
}
}
//模型导入之后调用
public void OnPostprocessModel(GameObject go)
{
// for skeleton animations.
Debuger.Log("模型导入之后调用 ");
List <AnimationClip> animationClipList = new List <AnimationClip>(AnimationUtility.GetAnimationClips(go));
if (animationClipList.Count == 0)
{
AnimationClip[] objectList = UnityEngine.Object.FindObjectsOfType(typeof(AnimationClip)) as AnimationClip[];
animationClipList.AddRange(objectList);
}
foreach (AnimationClip theAnimation in animationClipList)
{
try
{
// 去除scale曲线
//foreach (EditorCurveBinding theCurveBinding in AnimationUtility.GetCurveBindings(theAnimation))
//{
// string name = theCurveBinding.propertyName.ToLower();
// if (name.Contains("scale"))
// {
// AnimationUtility.SetEditorCurve(theAnimation, theCurveBinding, null);
// }
//}
// 浮点数精度压缩到f3
AnimationClipCurveData[] curves = null;
curves = AnimationUtility.GetAllCurves(theAnimation);
Keyframe key;
Keyframe[] keyFrames;
for (int ii = 0; ii < curves.Length; ++ii)
{
AnimationClipCurveData curveDate = curves[ii];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
//Debuger.LogWarning(string.Format("AnimationClipCurveData {0} don't have curve; Animation name {1} ", curveDate, animationPath));
continue;
}
keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
key = keyFrames[i];
key.value = float.Parse(key.value.ToString("f3"));
key.inTangent = float.Parse(key.inTangent.ToString("f3"));
key.outTangent = float.Parse(key.outTangent.ToString("f3"));
keyFrames[i] = key;
}
curveDate.curve.keys = keyFrames;
theAnimation.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
Debuger.Log("设定数值");
}
}
catch (System.Exception e)
{
Debuger.LogError(string.Format("CompressAnimationClip Failed !!! animationPath : {0} error: {1}", assetPath, e));
}
}
}
/// <summary>
/// 动画默认不导出Scale序列帧，除非该节点包含scale关键词(加scale关键词表示该节点需要进行scale变换)
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
private static bool IsFilterCurveData(AnimationClipCurveData dt, string nodeName)
{
if (dt.propertyName.ToLower().Contains("scale") && !nodeName.Contains("scale"))
{
return(true);
}
return(false);
}
private static void CompressionAccuracy(GameObject g)
{
if (g == null)
{
return;
}
List <AnimationClip> animationClipList = new List <AnimationClip>(AnimationUtility.GetAnimationClips(g));
if (animationClipList.Count == 0)
{
AnimationClip[] objectList = UnityEngine.Object.FindObjectsOfType(typeof(AnimationClip)) as AnimationClip[];
animationClipList.AddRange(objectList);
}
foreach (AnimationClip theAnimation in animationClipList)
{
try
{
//去除scale曲线
//foreach (EditorCurveBinding theCurveBinding in AnimationUtility.GetCurveBindings(theAnimation))
//{
// string name = theCurveBinding.propertyName.ToLower();
// if (name.Contains("scale"))
// {
// AnimationUtility.SetEditorCurve(theAnimation, theCurveBinding, null);
// }
//}
//浮点数精度压缩到f3
AnimationClipCurveData[] curves = null;
curves = AnimationUtility.GetAllCurves(theAnimation);
Keyframe key;
Keyframe[] keyFrames;
for (int ii = 0; ii < curves.Length; ++ii)
{
AnimationClipCurveData curveDate = curves[ii];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
continue;
}
keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
key = keyFrames[i];
key.value = float.Parse(key.value.ToString("f3"));
key.inTangent = float.Parse(key.inTangent.ToString("f3"));
key.outTangent = float.Parse(key.outTangent.ToString("f3"));
keyFrames[i] = key;
}
curveDate.curve.keys = keyFrames;
theAnimation.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
}
catch (System.Exception e)
{
Debug.LogError(string.Format("CompressAnimationClip Failed !!! animationPath : {0} error: {1}", g.gameObject.name, e));
}
}
}
public static EditorCurveBinding GetBinding(this AnimationClipCurveData obj)
{
EditorCurveBinding binding = new EditorCurveBinding();
binding.propertyName = obj.propertyName;
binding.path = obj.path;
binding.type = obj.type;
return(binding);
}
public static AnimationClipCurveData NewAnimationClipCurveData(Type type, string path, string property)
{
AnimationClipCurveData blah = new AnimationClipCurveData();
blah.type = type;
blah.path = path;
blah.propertyName = property;
blah.curve = new AnimationCurve();
return(blah);
}
private void InsertCurve(AnimationClipCurveData animationClipCurveData)
{
EditorCurveBinding editorCurveBinding = new EditorCurveBinding();
editorCurveBinding.path = animationClipCurveData.path;
editorCurveBinding.propertyName = animationClipCurveData.propertyName;
editorCurveBinding.type = animationClipCurveData.type;
AnimationUtility.SetEditorCurve(selectedAnimationClip, editorCurveBinding, animationClipCurveData.curve);
}
void DuplicateAnimationClip(string path, AnimationClip sourceClip, string animName)
{
if (sourceClip != null)
{
AnimationClip tempClip = new AnimationClip();
EditorUtility.CopySerialized(sourceClip, tempClip);
string newPath = path + animName + ".anim";
if ((animName.Contains("Idle") || animName.Contains("Victory") || animName.Contains("FloatGetHit") || animName.Contains("TumbleGetHit")) && !path.Contains("Resources/ui"))
{
EditorCurveBinding[] editorCurveBindings = AnimationUtility.GetCurveBindings(tempClip);
AnimationClipCurveData[] animationClipCurveDatas = AnimationUtility.GetAllCurves(tempClip);
AnimationClip newClip = new AnimationClip();
for (int i = 0, length = editorCurveBindings.Length; i < length; i++)
{
AnimationClipCurveData animationClipCurveData = animationClipCurveDatas[i];
EditorCurveBinding editorCurveBinding = editorCurveBindings[i];
//Debugger.Log(editorCurveBinding.path);
AnimationClipCurveData accd = new AnimationClipCurveData(editorCurveBinding);
AnimationCurve animationCurve = animationClipCurveData.curve;
AnimationCurve newCurve = new AnimationCurve();
for (int j = 0, jLength = animationCurve.keys.Length; j < jLength; j++)
{
if (j % 2 != 0)
{
continue;
}
Keyframe key = animationCurve.keys[j];
newCurve.AddKey(key);
}
AnimationUtility.SetEditorCurve(newClip, editorCurveBinding, newCurve);
}
if (animName.Contains("Idle"))
{
AnimationClipSettings animationClipSettings = AnimationUtility.GetAnimationClipSettings(newClip);
animationClipSettings.loopTime = true;
AnimationUtility.SetAnimationClipSettings(newClip, animationClipSettings);
}
AssetDatabase.CreateAsset(newClip, newPath);
}
else
{
if (animName.Contains("Run") || animName.Contains("Stun"))
{
AnimationClipSettings animationClipSettings = AnimationUtility.GetAnimationClipSettings(tempClip);
animationClipSettings.loopTime = true;
AnimationUtility.SetAnimationClipSettings(tempClip, animationClipSettings);
}
AssetDatabase.CreateAsset(tempClip, newPath);
}
Debugger.Log("import clip:" + newPath);
}
}
private static void ParseClip(AnimationClip clip)
{
sb = new StringBuilder();
BeginObject();
WriteString("clipname", clip.name); Next();
WriteString("wrapmode", clip.wrapMode.ToString()); Next();
BeginArray("curves");
AnimationClipCurveData[] cdataarray = AnimationUtility.GetAllCurves(clip, true);
int l = ((AnimationClipCurveData[])cdataarray).Length;
for (int x = 0; x < l; x++)
{
AnimationClipCurveData cdata = cdataarray [x];
BeginObject();
WriteString("property_name", cdata.propertyName); Next();
WriteString("type", cdata.type.Name); Next();
BeginArray("keys");
Keyframe[] keys = cdata.curve.keys;
for (int i = 0; i < keys.Length; i++)
{
Keyframe kf = keys [i];
BeginObject();
WriteFloat("time", kf.time); Next();
WriteFloat("value", kf.value); Next();
WriteFloat("intangent", kf.inTangent); Next();
WriteFloat("outtangent", kf.outTangent);
EndObject();
if (i < keys.Length - 1)
{
Next();
}
}
EndArray();
EndObject();
if (x < l - 1)
{
Next();
}
}
EndArray();
EndObject();
if (folder.Length > 0)
{
string filename = folder + "/" + clip.name + jsonFileExt;
FileStream f = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.Write);
StreamWriter sw = new StreamWriter(f);
sw.Write(sb.ToString());
sw.Close();
f.Close();
}
}
void OutputAnimationClip(AnimationClipCurveData curveData)
{
Debug.Log(curveData.path);
Debug.Log(curveData.propertyName);
AnimationCurve curve = curveData.curve;
Keyframe[] keys = curve.keys;
Debug.Log(keys.Length);
Keyframe k = keys[0];
Debug.Log(k.tangentMode);
}
// parses keypoint curve data and adds to keypoint
private void addToKeys(AnimationClipCurveData curveData)
{
string prop = curveData.propertyName.Split('.')[0];
string vec = curveData.propertyName.Split('.')[1];
LoziAnimationKeyPoints point = getKeyPoint(curveData.path);
switch (prop)
{
case "m_LocalPosition": { parsePoint(vec, point.pos, curveData.curve.keys); break; }
case "m_LocalRotation": { parsePoint(vec, point.rot, curveData.curve.keys); break; }
case "m_LocalScale": { parsePoint(vec, point.scl, curveData.curve.keys); break; }
}
}
/// <summary>
/// 动画默认不导出Scale序列帧，除非该节点包含scale关键词(加scale关键词表示该节点需要进行scale变换)
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
private static bool IsFilterCurveData(AnimationClipCurveData dt, string nodeName)
{
bool isScale = dt.propertyName.ToLower().Contains("scale");
var keys = dt.curve.keys;
// 只有2个Key,且值都是1的也不过滤，之前启用有比较多的情况会动画异常
//if (keys.Length == 2 && Mathf.Approximately(keys[0].value, 1.0f) && Mathf.Approximately(keys[1].value, 1.0f))
//{
// // Debug.Log("ignore:"+ keys[0].value+","+ keys[1].value);
// return true;
//}
// if (dt.propertyName.ToLower().Contains("scale") && !nodeName.ToLower().Contains("scale"))
// return true;
return(false);
}
void _OptmizeAnimationFloat_X(uint x)
{
if (_clip != null && x > 0)
{
//浮点数精度压缩到f3
AnimationClipCurveData[] curves = null;
curves = AnimationUtility.GetAllCurves(_clip);
Keyframe key;
Keyframe[] keyFrames;
string floatFormat;
if (_FLOAT_FORMAT.TryGetValue(x, out floatFormat))
{
if (curves != null && curves.Length > 0)
{
for (int ii = 0; ii < curves.Length; ++ii)
{
AnimationClipCurveData curveDate = curves [ii];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
//Debug.LogWarning(string.Format("AnimationClipCurveData {0} don't have curve; Animation name {1} ", curveDate, animationPath));
continue;
}
keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
key = keyFrames [i];
key.value = float.Parse(key.value.ToString(floatFormat));
key.inTangent = float.Parse(key.inTangent.ToString(floatFormat));
key.outTangent = float.Parse(key.outTangent.ToString(floatFormat));
keyFrames [i] = key;
}
curveDate.curve.keys = keyFrames;
_clip.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
}
}
else
{
Debug.LogErrorFormat("目前不支持{0}位浮点", x);
}
}
}
public void PopulateAccessor(AnimationClipCurveData cd, Keyframe[] refKeyFrames)
{
string propName = cd.propertyName;
if (propName.Contains("m_LocalPosition"))
{
position.PopulateAccessor(cd, refKeyFrames);
}
else if (propName.Contains("m_LocalRotation"))
{
rotation.PopulateAccessor(cd, refKeyFrames);
}
else if (propName.Contains("m_LocalScale"))
{
scale.PopulateAccessor(cd, refKeyFrames);
}
}
// constructor
public CurveDataPosition(AnimationClipCurveData animClipCurveData_, float interFrameTime_, string parentName_)
{
UnityEngine.Debug.Assert(animClipCurveData_.curve.length > 0);
pathName = animClipCurveData_.path;
typeName = animClipCurveData_.type.ToString();
propertyName = animClipCurveData_.propertyName;
parentName = parentName_;
dataSize = animClipCurveData_.curve.length;
positionList = new Vector3[dataSize];
isXAdded = false;
isYAdded = false;
isZAdded = false;
keyframeTime = new float[dataSize];
interFrameTime = interFrameTime_;
for (int i = 0; i < dataSize; ++i)
{
keyframeTime[i] = animClipCurveData_.curve[i].time;
}
}//CurveDataPosition()
public static bool CompressAnimationClip(UnityEngine.Object o)
{
string animationPath = AssetDatabase.GetAssetPath(o);
try
{
//AnimationClip clip = GameObject.Instantiate(o) as AnimationClip;
AnimationClip clip = o as AnimationClip;
AnimationClipCurveData[] curves = null;
curves = AnimationUtility.GetAllCurves(clip);
Keyframe key;
Keyframe[] keyFrames;
for (int ii = 0; ii < curves.Length; ++ii)
{
AnimationClipCurveData curveDate = curves[ii];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
//Debug.LogWarning(string.Format("AnimationClipCurveData {0} don't have curve; Animation name {1} ", curveDate, animationPath));
continue;
}
keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
key = keyFrames[i];
key.value = float.Parse(key.value.ToString("f3"));
key.inTangent = float.Parse(key.inTangent.ToString("f3"));
key.outTangent = float.Parse(key.outTangent.ToString("f3"));
keyFrames[i] = key;
}
curveDate.curve.keys = keyFrames;
clip.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
//AssetDatabase.CreateAsset(clip, animationPath);
Debug.Log(string.Format(" CompressAnimationClip {0} Success !!!", animationPath));
return(true);
}
catch (Exception e)
{
Debug.LogError(string.Format("CompressAnimationClip Failed !!! animationPath : {0} error: {1}", animationPath, e));
return(false);
}
}
AnimCurveData ExprotCurve(AnimationClipCurveData data)
{
AnimCurveData curve = new AnimCurveData();
curve.path = data.path;
curve.propertyName = data.propertyName;
Keyframe[] keys = data.curve.keys;
curve.Alloc(keys.Length);
for (int i = 0; i < keys.Length; i++)
{
curve.inTangent[i] = keys[i].inTangent;
curve.outTangent[i] = keys[i].outTangent;
curve.tangentMode[i] = keys[i].tangentMode;
curve.time[i] = keys[i].time;
curve.value[i] = keys[i].value;
}
return(curve);
}
public void AddCurveData(AnimationClipCurveData pData)
{
_needsPostprocess = true;
var targetPropertyBits = pData.propertyName.Split('.');
var target = targetPropertyBits[0];
int componentIdx = "xyzw".IndexOf(targetPropertyBits[1][0]);
//var skeleton = _clip.Animation.Skeleton;
//skeleton.
// Figure out what this curve targets in terms of Goo data
if (target == "m_LocalPosition")
{
for (int i = 0; i < _clip.KeyframeCount; ++i)
{
_translationKeyframes[i][componentIdx] = pData.curve.Evaluate(_clip.GetTimeAtKeyframe(i));
}
}
else if (target == "m_LocalRotation")
{
for (int i = 0; i < _clip.KeyframeCount; ++i)
{
_rotationKeyframes[i][componentIdx] = pData.curve.Evaluate(_clip.GetTimeAtKeyframe(i));
}
}
else if (target == "m_LocalScale")
{
for (int i = 0; i < _clip.KeyframeCount; ++i)
{
_scaleKeyframes[i][componentIdx] = pData.curve.Evaluate(_clip.GetTimeAtKeyframe(i));
}
}
else
{
Debug.LogError("Curve describes a property we don't understand: " + target);
}
}
static AnimationClip optmizeAnimationFloat(AnimationClip clip)
{
if (clip == null)
{
return(clip);
}
try
{
AnimationClipCurveData[] curves = null;
curves = AnimationUtility.GetAllCurves(clip);
Keyframe key;
Keyframe[] keyFrames;
for (int i = 0; i < curves.Length; ++i)
{
AnimationClipCurveData curveDate = curves[i];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
continue;
}
keyFrames = curveDate.curve.keys;
for (int j = 0; j < keyFrames.Length; j++)
{
key = keyFrames[j];
key.value = float.Parse(key.value.ToString("f3"));
key.inTangent = float.Parse(key.inTangent.ToString("f3"));
key.outTangent = float.Parse(key.outTangent.ToString("f3"));
keyFrames[j] = key;
}
curveDate.curve.keys = keyFrames;
clip.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
return(clip);
}
catch (Exception e)
{
Debug.LogError(e);
return(clip);
}
}
public CurveInformation AddIfNonExistant(List <string> path, AnimationClipCurveData animationCLipCurveData)
{
if (Name.Equals(path[0]))
{
if (path.Count == 1)
{
AnimationClipCurveData = animationCLipCurveData;
return(this);
}
var pathReduced = path;
pathReduced.RemoveAt(0);
foreach (CurveInformation curveInformation in Children)
{
if (curveInformation.Name.Equals(pathReduced[0]))
{
CurveInformation childResult = curveInformation.AddIfNonExistant(pathReduced, animationCLipCurveData);
if (childResult != null)
{
return(childResult);
}
}
}
}
CurveInformation newChild = new CurveInformation(path[0]);
Children.Add(newChild);
if (path.Count == 1)
{
newChild.AnimationClipCurveData = animationCLipCurveData;
return(newChild);
}
else
{
var pathReduced = path;
pathReduced.RemoveAt(0);
return(newChild.AddIfNonExistant(pathReduced, animationCLipCurveData));
}
}
private void AddToList(AnimationClipCurveData curveData, List <Curve> curves, int index)
{
var item = curves.Last();
if (item.path != curveData.path)
{
throw new FormatException();
}
foreach (var key in curveData.curve.keys)
{
var keyData = item.keys.Find(x => Mathf.Abs(x.time - key.time) < float.Epsilon);
if (keyData == null)
{
keyData = new KeyframeContainer <Vector4>();
keyData.time = key.time;
item.keys.Add(keyData);
}
keyData.value[index] = key.value;
keyData.inSlope[index] = key.inTangent;
keyData.outSlope[index] = key.outTangent;
}
}
private static void OptmizeAnimationFloat(AnimationClip clip, uint x)
{
if (clip != null && x > 0)
{
//浮点数精度压缩到fx
AnimationClipCurveData[] curves = null;
curves = AnimationUtility.GetAllCurves(clip);
Keyframe key;
Keyframe[] keyFrames;
string floatFormat = "f" + x.ToString();
if (curves != null && curves.Length > 0)
{
for (int ii = 0; ii < curves.Length; ++ii)
{
AnimationClipCurveData curveDate = curves[ii];
if (curveDate.curve == null || curveDate.curve.keys == null)
{
//Debug.LogWarning(string.Format("AnimationClipCurveData {0} don't have curve; Animation name {1} ", curveDate, animationPath));
continue;
}
keyFrames = curveDate.curve.keys;
for (int i = 0; i < keyFrames.Length; i++)
{
key = keyFrames[i];
key.value = float.Parse(key.value.ToString(floatFormat));
key.inTangent = float.Parse(key.inTangent.ToString(floatFormat));
key.outTangent = float.Parse(key.outTangent.ToString(floatFormat));
keyFrames[i] = key;
}
curveDate.curve.keys = keyFrames;
clip.SetCurve(curveDate.path, curveDate.type, curveDate.propertyName, curveDate.curve);
}
}
}
}
public void Populate(AnimationClipCurveData curveData)
{
string propName = curveData.propertyName;
if (times == null) // allocate one array of times, assumes all channels have same number of keys
{
timeAccessor = new GlTF_Accessor(name + "TimeAccessor", GlTF_Accessor.Type.SCALAR, GlTF_Accessor.ComponentType.FLOAT);
timeAccessor.bufferView = GlTF_Writer.floatBufferView;
GlTF_Writer.accessors.Add(timeAccessor);
times = new float[curveData.curve.keys.Length];
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
times[i] = curveData.curve.keys[i].time;
}
timeAccessor.Populate(times);
}
if (propName.Contains("m_LocalPosition"))
{
if (positions == null)
{
translationAccessor = new GlTF_Accessor(name + "TranslationAccessor", GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
translationAccessor.bufferView = GlTF_Writer.vec3BufferView;
GlTF_Writer.accessors.Add(translationAccessor);
positions = new Vector3[curveData.curve.keys.Length];
}
if (propName.Contains(".x"))
{
px = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
positions[i].x = curveData.curve.keys[i].value;
}
}
else if (propName.Contains(".y"))
{
py = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
positions[i].y = curveData.curve.keys[i].value;
}
}
else if (propName.Contains(".z"))
{
pz = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
positions[i].z = curveData.curve.keys[i].value;
}
}
if (px && py && pz)
{
translationAccessor.Populate(positions);
}
}
if (propName.Contains("m_LocalScale"))
{
if (scales == null)
{
scaleAccessor = new GlTF_Accessor(name + "ScaleAccessor", GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
scaleAccessor.bufferView = GlTF_Writer.vec3BufferView;
GlTF_Writer.accessors.Add(scaleAccessor);
scales = new Vector3[curveData.curve.keys.Length];
}
if (propName.Contains(".x"))
{
sx = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
scales[i].x = curveData.curve.keys[i].value;
}
}
else if (propName.Contains(".y"))
{
sy = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
scales[i].y = curveData.curve.keys[i].value;
}
}
else if (propName.Contains(".z"))
{
sz = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
scales[i].z = curveData.curve.keys[i].value;
}
}
if (sx && sy && sz)
{
scaleAccessor.Populate(scales);
}
}
if (propName.Contains("m_LocalRotation"))
{
if (rotations == null)
{
rotationAccessor = new GlTF_Accessor(name + "RotationAccessor", GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
rotationAccessor.bufferView = GlTF_Writer.vec4BufferView;
GlTF_Writer.accessors.Add(rotationAccessor);
rotations = new Vector4[curveData.curve.keys.Length];
}
if (propName.Contains(".x"))
{
rx = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
rotations[i].x = curveData.curve.keys[i].value;
}
}
else if (propName.Contains(".y"))
{
ry = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
rotations[i].y = curveData.curve.keys[i].value;
}
}
else if (propName.Contains(".z"))
{
rz = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
rotations[i].z = curveData.curve.keys[i].value;
}
}
else if (propName.Contains(".w"))
{
rw = true;
for (int i = 0; i < curveData.curve.keys.Length; i++)
{
rotations[i].w = curveData.curve.keys[i].value;
}
}
if (rx && ry && rz && rw)
{
rotationAccessor.Populate(scales);
}
}
}
