public static List <AnimationClip> ImportAnimationClips(ImporterContext ctx)
{
List <AnimationClip> animasionClips = new List <AnimationClip>();
for (int i = 0; i < ctx.GLTF.animations.Count; ++i)
{
var clip = new AnimationClip();
clip.ClearCurves();
clip.legacy = true;
clip.name = ctx.GLTF.animations[i].name;
if (string.IsNullOrEmpty(clip.name))
{
clip.name = "legacy_" + i;
}
clip.wrapMode = WrapMode.Loop;
var animation = ctx.GLTF.animations[i];
if (string.IsNullOrEmpty(animation.name))
{
animation.name = string.Format("animation:{0}", i);
}
animasionClips.Add(ImportAnimationClip(ctx, animation, ctx.GLTF.nodes[0]));
}
return(animasionClips);
}
/// <summary>
/// 删除指定帧
/// </summary>
/// <param name="clip">动画剪辑</param>
/// <param name="keyName">帧名</param>
static void CompressKey(AnimationClip clip)
{
// 部分骨骼带位移
// 部分动画不做减帧压缩
// 动画压缩分类型:All,OnlyScale,None;All只包含Scale和Position
EditorCurveBinding[] curves = AnimationUtility.GetCurveBindings(clip);
AnimationClip tempClip = Object.Instantiate(clip);
clip.ClearCurves();
for (int j = 0; j < curves.Length; j++)
{
EditorCurveBinding curveBinding = curves[j];
int index = curveBinding.path.LastIndexOf("/");
string boneName = curveBinding.path.Substring(index + 1);
if (!_excludeHash.Contains(boneName))
{
if (curveBinding.propertyName.Contains("Position") ||
curveBinding.propertyName.Contains("Scale"))
{
continue;
}
}
AnimationCurve curve = AnimationUtility.GetEditorCurve(tempClip, curveBinding);
clip.SetCurve(curveBinding.path, curveBinding.type, curveBinding.propertyName, curve);
}
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
//animClip = anim.clip;
animClip.ClearCurves();
//animClip.ClearCurves ();
//animator.GetCurrentAnimatorStateInfo(1).normalizedTime = 0.0f;
}
if (Input.GetKeyDown(KeyCode.RightArrow))
{
AnimationCurve testCurve = new AnimationCurve();
Keyframe key1 = new Keyframe();
Keyframe key2 = new Keyframe();
key1.time = 0f;
key1.value = 2;
key2.time = 2f;
key2.value = 1;
testCurve.AddKey(key1);
testCurve.AddKey(key2);
animClip.SetCurve("", typeof(Transform), "localPosition.y", testCurve);
//anim.
//animClip.
}
}
private List <AnimationClip> ImportAnimationClips(glTF gltf, Axises invertAxis)
{
var animationClips = new List <AnimationClip>();
for (var i = 0; i < gltf.animations.Count; ++i)
{
var clip = new AnimationClip();
clip.ClearCurves();
clip.legacy = true;
clip.name = gltf.animations[i].name;
if (string.IsNullOrEmpty(clip.name))
{
clip.name = $"legacy_{i}";
}
clip.wrapMode = WrapMode.Loop;
var animation = gltf.animations[i];
if (string.IsNullOrEmpty(animation.name))
{
animation.name = $"animation:{i}";
}
animationClips.Add(AnimationImporterUtil.ConvertAnimationClip(gltf, animation, invertAxis.Create()));
}
return(animationClips);
}
// When the Animation get's manipulated, it need's to reset when the game restarts and here it recreate the beginning
private void CreateElevateAnim()
{
float firstFloorKeyframeTime = 0.3f / 2.3f;
_elevateClip.ClearCurves();
AnimationCurve curve = AnimationCurve.Constant(0, firstFloorKeyframeTime * 2, 0);
Keyframe firstKeyframe = new Keyframe(0, 0);
Keyframe firstFloorKeyframe = new Keyframe(firstFloorKeyframeTime, -0.3f);
curve.AddKey(firstKeyframe);
curve.AddKey(firstFloorKeyframe);
_elevateClip.SetCurve("", typeof(Transform), "localPosition.y", curve);
AnimationEvent firstWork = new AnimationEvent();
firstWork.functionName = "Work";
firstWork.time = firstFloorKeyframeTime;
firstWork.intParameter = 0;
_elevateClip.AddEvent(firstWork);
_workEvents.Add(firstWork);
_storeCoins = new AnimationEvent();
_storeCoins.functionName = "StoreCoins";
_storeCoins.time = firstFloorKeyframeTime * 2;
_elevateClip.AddEvent(_storeCoins);
}
public void SaveToClip(AnimationClip clip, float fps = 60)
{
if (!recorder.isRecording)
{
clip.ClearCurves();
clip.frameRate = fps;
return;
}
// todo: use CurveFilterOptions in 2019
recorder.SaveToClip(clip, fps);
var rootCurves = new AnimationCurve[7];
var muscleCurves = new AnimationCurve[HumanTrait.MuscleCount];
getProxyCurves(clip, rootCurves, muscleCurves);
RemoveConstantCurves(clip);
SetHumanCurves(clip, rootCurves, muscleCurves);
var settings = AnimationUtility.GetAnimationClipSettings(clip);
settings.loopBlendOrientation = true; // Root Transform Rotation: Bake Into Pose
settings.keepOriginalOrientation = true; // Root Transform Rotation: Based Upon = Origin
settings.orientationOffsetY = 0; // Root Transform Rotation: Offset
settings.loopBlendPositionY = true; // Root Transform Position (Y): Bake Into Pose
settings.keepOriginalPositionY = true; // Root Transform Position (Y): Based Upon = Origin
settings.level = 0; // Root Transform Position (Y): Offset
settings.loopBlendPositionXZ = true; // Root Transform Position (XZ): Bake Into Pose
settings.keepOriginalPositionXZ = true; // Root Transform Position (XZ): Based Upon = Origin
AnimationUtility.SetAnimationClipSettings(clip, settings);
}
public static AnimationClip OptimizeAnimation(AnimationClip _srcClip, int _floatPrecision, bool _clearScale)
{
AnimationClip _dstClip = _srcClip.Copy();
_dstClip.ClearCurves();
foreach (var binding in AnimationUtility.GetCurveBindings(_srcClip))
{
if (_clearScale && binding.propertyName.Contains("Scale"))
{
continue;
}
AnimationCurve curve = AnimationUtility.GetEditorCurve(_srcClip, binding);
Keyframe[] keyframes = curve.keys;
for (int i = 0; i < keyframes.Length; i++)
{
Keyframe keyframe = keyframes[i];
keyframe.value = OptimizeFloat(keyframe.value, _floatPrecision);
keyframe.time = OptimizeFloat(keyframe.time, _floatPrecision);
keyframe.inTangent = OptimizeFloat(keyframe.inTangent, _floatPrecision);
keyframe.outTangent = OptimizeFloat(keyframe.outTangent, _floatPrecision);
keyframe.inWeight = OptimizeFloat(keyframe.inWeight, _floatPrecision);
keyframe.outWeight = OptimizeFloat(keyframe.outWeight, _floatPrecision);
keyframes[i] = keyframe;
}
curve.keys = keyframes;
_dstClip.SetCurve(binding.path, binding.type, binding.propertyName, curve);
}
return(_dstClip);
}
public void ClearAnimation()
{
clip.ClearCurves();
curveRotationW = new AnimationCurve(keyRotationW);
curveRotationX = new AnimationCurve(keyRotationX);
curveRotationY = new AnimationCurve(keyRotationY);
curveRotationZ = new AnimationCurve(keyRotationZ);
curveScaleX = new AnimationCurve(keyScaleX);
curveScaleY = new AnimationCurve(keyScaleY);
curveScaleZ = new AnimationCurve(keyScaleZ);
curvePositionX = new AnimationCurve(keyPositionX);
curvePositionY = new AnimationCurve(keyPositionY);
curvePositionZ = new AnimationCurve(keyPositionZ);
}
static int ClearCurves(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
AnimationClip obj = LuaScriptMgr.GetNetObject <AnimationClip>(L, 1);
obj.ClearCurves();
return(0);
}
static int ClearCurves(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
AnimationClip obj = (AnimationClip)LuaScriptMgr.GetUnityObjectSelf(L, 1, "AnimationClip");
obj.ClearCurves();
return(0);
}
public override void ClearCandidates()
{
StopCandidateRecording();
if (m_CandidateClip != null)
{
m_CandidateClip.ClearCurves();
}
}
private void SetClipProperties()
{
input.legacy = false;
input.ClearCurves();
for (var i = 0; i < clipPaths.Length; i++)
{
input.SetCurve(clipPaths[i], clipTypes[i], clipProperties[i], clipCurves[i]);
}
input.legacy = isLegacy;
}
// Start is called before the first frame update
void Start()
{
AnimationClip testClip = new AnimationClip();
if (testClip.isLooping)
{
print("WARNING: CLIP SET TO LOOP");
}
testClip.ClearCurves();
}
public void ClearAnimation()
{
//string clipFile = animationAssetPath;
//animationClip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipFile);
/*if (animationClip != null)
* {*/
animationClip.ClearCurves();
animationClip.frameRate = 1;
AssetDatabase.SaveAssets();
//}
}
// Use this for initialization
void Start()
{
anim = new AnimationClip();
anim.ClearCurves();
AnimationCurve curve = AnimationCurve.Linear(0.0F, transform.position.x, 2.0F, transform.position.x + 1);
anim.SetCurve("", typeof(Transform), "localPosition.x", curve);
anim.name = "Hit";
GetComponent <Animation>().clip = anim;
GetComponent <Animator>().Play("Note_Hit_Animation");
//GetComponent<Animation>().Play("Sheep_Hit");
}
public void SaveToClip(AnimationClip newClip)
{
newClip.ClearCurves();
foreach (var data in AnimationUtility.GetAllCurves(Clip))
{
AnimationUtility.SetEditorCurve(newClip,
data.path,
data.type,
data.propertyName,
data.curve);
}
}
static void RemoveScaleAndPosition()
{
if (null == Selection.activeObject)
{
return;
}
// AnimationClipを持つFBXのパス
string fbxPath = AssetDatabase.GetAssetPath(Selection.activeObject);
Debug.Log(fbxPath);
// AnimationClipの取得
Object[] animations = AssetDatabase.LoadAllAssetsAtPath(fbxPath);
List <AnimationClip> cs = new List <AnimationClip> ();
foreach (object c in animations)
{
if (c is AnimationClip)
{
cs.Add(c as AnimationClip);
}
}
int idx = fbxPath.LastIndexOf("/");
string rootPath = fbxPath.Substring(0, idx + 1);
foreach (AnimationClip _c in cs)
{
if (_c.name.Contains("__preview__") == false)
{
AnimationClip UpClip = Object.Instantiate(_c);
Dictionary <EditorCurveBinding, AnimationCurve> bcMap = new Dictionary <EditorCurveBinding, AnimationCurve> ();
List <EditorCurveBinding> newBinds = new List <EditorCurveBinding> ();
EditorCurveBinding[] binds = AnimationUtility.GetCurveBindings(UpClip);
foreach (EditorCurveBinding b in binds)
{
if (b.propertyName.Contains("m_LocalPosition") || b.propertyName.Contains("m_LocalScale"))
{
continue;
}
newBinds.Add(b);
AnimationCurve __clip = AnimationUtility.GetEditorCurve(UpClip, b);
bcMap [b] = __clip;
}
UpClip.ClearCurves();
foreach (EditorCurveBinding b in newBinds)
{
AnimationUtility.SetEditorCurve(UpClip, b, bcMap [b]);
}
AssetDatabase.CreateAsset(UpClip, rootPath + _c.name + ".anim");
}
}
}
static void FirstCommand()
{
if (Selection.activeGameObject.GetComponent <Animation> () != null)
{
Debug.Log("Deleting animation curves!!");
Animation anim = Selection.activeGameObject.GetComponent <Animation> ();
AnimationClip animClip = anim.clip;
animClip.ClearCurves();
}
}
public static void CopyAnimationClip(AnimationClip _src, AnimationClip _dstClip)
{
AnimationUtility.SetAnimationEvents(_dstClip, _src.events);
_dstClip.frameRate = _src.frameRate;
_dstClip.wrapMode = _src.wrapMode;
_dstClip.legacy = _src.legacy;
_dstClip.localBounds = _src.localBounds;
_dstClip.ClearCurves();
foreach (var curveBinding in AnimationUtility.GetCurveBindings(_src))
{
_dstClip.SetCurve(curveBinding.path, curveBinding.type, curveBinding.propertyName, AnimationUtility.GetEditorCurve(_src, curveBinding));
}
}
//TODO
public void StartRecording()
{
if (m_clip != null)
{
SteamVR_Controller.Input(Input.GetButtonDown("Button1") ? 1 : 2).TriggerHapticPulse(1000);
m_recording = true;
//previewAnimator.SetTrigger("StopPreview");
controlBoard_RecordControl.RequestControlBoardFocus();
m_clip.ClearCurves();
foreach (GameObject indicator in indicators)
{
indicator.SetActive(true);
}
}
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
// cube1 = newCube;
cube1.ClearCurves();
print("a");
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
cube1 = newCube;
// cube1.ClearCurves();
print("newCube");
}
}
void OnDisable()
{
if (clip == null)
{
return;
}
if (m_Recorder.isRecording && crash == false)
{
m_Recorder.SaveToClip(clip);
}
else
{
clip.ClearCurves();
}
}
public static int ClearCurves(IntPtr l)
{
int result;
try
{
AnimationClip animationClip = (AnimationClip)LuaObject.checkSelf(l);
animationClip.ClearCurves();
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
private static void Trim(string dir)
{
foreach (var animFile in Directory.GetFiles(dir, "*.anim", SearchOption.AllDirectories))
{
var anim = animFile.Replace("\\", "/");
AnimationClip clip = AssetDatabase.LoadAssetAtPath(anim, typeof(AnimationClip)) as AnimationClip;
if (clip != null)
{
if (clip.length > 0)
{
AnimationClip copiedClip = Object.Instantiate(clip);
copiedClip.ClearCurves();
int trimScale = 0;
foreach (var editorCurveBinding in AnimationUtility.GetCurveBindings(clip))
{
var curve = AnimationUtility.GetEditorCurve(clip, editorCurveBinding);
if (editorCurveBinding.propertyName.StartsWith("m_LocalScale"))
{
trimScale++;
}
else
{
copiedClip.SetCurve(editorCurveBinding.path, editorCurveBinding.type,
editorCurveBinding.propertyName, curve);
}
}
if (trimScale > 0)
{
EditorLogger.Log("{0} trim scale count ={1}", anim, trimScale);
AssetDatabase.CreateAsset(copiedClip, anim);
}
}
else
{
Debug.LogErrorFormat("animation clip length <= 0: {0} {1}", anim, clip.length);
}
}
else
{
Debug.LogErrorFormat("Can't load animation clip: {0}", anim);
}
}
}
private static int ClearCurves(IntPtr L)
{
int result;
try
{
ToLua.CheckArgsCount(L, 1);
AnimationClip animationClip = (AnimationClip)ToLua.CheckObject(L, 1, typeof(AnimationClip));
animationClip.ClearCurves();
result = 0;
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
void Start()
{
//Clear animation so we get a fresh one with no keyframes or curves
animation.ClearCurves();
material = GetComponent <Renderer>().material;
//Create a new list of the ShaderProperties that has Keyframing enabled (So we dont uselessly write to non existent curves)
keyframeProperties = properties.Where(x => x._UseForKeyframing).ToList();
List <AnimationCurve> c = new List <AnimationCurve>();
for (int i = 0; i < keyframeProperties.Count; i++)
{
//add animationcurve for every shaderproperty that we want to keyframe
c.Add(new AnimationCurve());
}
curve = c.ToArray();
}
public void ApplyChanges()
{
animationClip.ClearCurves();
foreach (AnimationCurveWithBinding curveWithBinding in poseCurveBindings)
{
animationClip.SetCurve(PoseObjectName, curveWithBinding.curveBinding.type, curveWithBinding.curveBinding.propertyName, curveWithBinding.curve);
}
foreach (AnimationCurveWithBinding curveWithBinding in blendshapesCurveBindings)
{
animationClip.SetCurve(BlendshapesObjectName, curveWithBinding.curveBinding.type, curveWithBinding.curveBinding.propertyName, curveWithBinding.curve);
}
AssetDatabase.SaveAssets();
ReadAnimationClip();
}
private List <AnimationClip> ImportAnimationClips(glTF gltf, Axises invertAxis)
{
var animationClips = new List <AnimationClip>();
for (var i = 0; i < gltf.animations.Count; ++i)
{
var clip = new AnimationClip();
clip.ClearCurves();
clip.legacy = true;
clip.name = gltf.animations[i].name;
if (string.IsNullOrEmpty(clip.name))
{
clip.name = $"legacy_{i}";
}
clip.wrapMode = WrapMode.Loop;
var animation = gltf.animations[i];
if (string.IsNullOrEmpty(animation.name))
{
animation.name = $"animation:{i}";
}
AxisInverter inverter = default;
switch (invertAxis)
{
case Axises.X:
inverter = AxisInverter.ReverseX;
break;
case Axises.Z:
inverter = AxisInverter.ReverseZ;
break;
default:
throw new System.Exception();
}
animationClips.Add(AnimationImporterUtil.ConvertAnimationClip(gltf, animation, inverter));
}
return(animationClips);
}
public static void clone(AnimationClip srcClip, AnimationClip dstClip)
{
dstClip.wrapMode = srcClip.wrapMode;
dstClip.frameRate = srcClip.frameRate;
var srcAcs = AnimationUtility.GetAnimationClipSettings(srcClip);
var dstAcs = AnimationUtility.GetAnimationClipSettings(dstClip);
dstAcs.cycleOffset = srcAcs.cycleOffset;
dstAcs.heightFromFeet = srcAcs.heightFromFeet;
dstAcs.keepOriginalOrientation = srcAcs.keepOriginalOrientation;
dstAcs.keepOriginalPositionXZ = srcAcs.keepOriginalPositionXZ;
dstAcs.keepOriginalPositionY = srcAcs.keepOriginalPositionY;
dstAcs.level = srcAcs.level;
dstAcs.loopBlend = srcAcs.loopBlend;
dstAcs.loopBlendOrientation = srcAcs.loopBlendOrientation;
dstAcs.loopBlendPositionXZ = srcAcs.loopBlendPositionXZ;
dstAcs.loopBlendPositionY = srcAcs.loopBlendPositionY;
dstAcs.loopTime = srcAcs.loopTime;
dstAcs.mirror = srcAcs.mirror;
dstAcs.orientationOffsetY = srcAcs.orientationOffsetY;
dstAcs.startTime = srcAcs.startTime;
dstAcs.stopTime = srcAcs.stopTime;
dstAcs.additiveReferencePoseClip = srcAcs.additiveReferencePoseClip;
dstAcs.additiveReferencePoseTime = srcAcs.additiveReferencePoseTime;
dstAcs.hasAdditiveReferencePose = srcAcs.hasAdditiveReferencePose;
AnimationUtility.SetAnimationClipSettings(dstClip, dstAcs);
dstClip.ClearCurves();
foreach (var i in AnimationUtility.GetCurveBindings(srcClip))
{
var ac = AnimationUtility.GetEditorCurve(srcClip, i);
AnimationUtility.SetEditorCurve(dstClip, i, ac);
}
foreach (var i in AnimationUtility.GetObjectReferenceCurveBindings(srcClip))
{
var keys = AnimationUtility.GetObjectReferenceCurve(srcClip, i);
AnimationUtility.SetObjectReferenceCurve(dstClip, i, keys);
}
}
public void Modify(string path)
{
var clip = AssetDatabase.LoadAssetAtPath <AnimationClip>(path);
if (clip == null)
{
return;
}
var bindings = AnimationUtility.GetCurveBindings(clip);
var newPaths = new string[bindings.Length];
var findFlag = false;
for (int i = 0; i < bindings.Length; i++)
{
var binding = bindings[i];
newPaths[i] = binding.path;
foreach (var key in replaceNamePairDictionary.Keys)
{
if (newPaths[i].Contains(key))
{
newPaths[i] = newPaths[i].Replace(key, replaceNamePairDictionary[key]);
findFlag = true;
}
}
}
if (findFlag)
{
var newClip = new AnimationClip();
EditorUtility.CopySerialized(clip, newClip);
newClip.ClearCurves();
for (int i = 0; i < bindings.Length; i++)
{
var binding = bindings[i];
var curve = AnimationUtility.GetEditorCurve(clip, binding);
newClip.SetCurve(newPaths[i], binding.type, binding.propertyName, curve);
}
AssetDatabase.CreateAsset(newClip, path);
}
}
