void Start()
{
currentMotionFrameData = new MotionFrameData();
motionOwner = this.transform;
currentComputeTime = motionMatcherSettings.ComputeMotionsBestCostGap;
motionDebugDataList = new List <MotionDebugData>();
//HumanoidCrouchIdle 动画有问题，只能通过这种方式临时处理一下
for (int i = 0; i < motionsData.motionDataList.Length; i++)
{
MotionData motionData = motionsData.motionDataList[i];
if (motionData.motionName.Contains("HumanoidCrouchIdle"))
{
for (int j = 0; j < motionData.motionFrameDataList.Length; j++)
{
MotionFrameData motionFrameData = motionData.motionFrameDataList[j];
for (int k = 0; k < motionFrameData.motionTrajectoryDataList.Length; k++)
{
MotionTrajectoryData motionTrajectoryData = motionFrameData.motionTrajectoryDataList[k];
motionTrajectoryData.localPosition = Vector3.zero;
}
}
}
}
}
private void CapturePlayingMotionSnapShot(PlayerInput playerInput, string motionName, float normalizedTime, MotionMainEntryType motionMainEntryType)
{
float velocity = playerInput.velocity;
float angularVelocity = playerInput.angularVelocity;
Vector3 direction = playerInput.direction;
float acceleration = playerInput.acceleration;
float brake = playerInput.brake;
MotionFrameData bakedMotionFrameData = AcquireBakedMotionFrameData(motionName, normalizedTime, motionMainEntryType);
currentMotionFrameData.velocity = velocity;
currentMotionFrameData.motionBoneDataList = bakedMotionFrameData.motionBoneDataList;
currentMotionFrameData.motionTrajectoryDataList = new MotionTrajectoryData[motionMatcherSettings.predictionTrajectoryTimeList.Length];
for (int i = 0; i < motionMatcherSettings.predictionTrajectoryTimeList.Length; i++)
{
float predictionTrajectoryTime = motionMatcherSettings.predictionTrajectoryTimeList[i];
currentMotionFrameData.motionTrajectoryDataList[i] = new MotionTrajectoryData();
MotionTrajectoryData motionTrajectoryData = currentMotionFrameData.motionTrajectoryDataList[i];
motionTrajectoryData.localPosition = velocity * direction * predictionTrajectoryTime;
motionTrajectoryData.velocity = velocity * direction;
if (Mathf.Abs(playerInput.angularVelocity) > 0)
{
motionTrajectoryData.direction = Quaternion.Euler(0, playerInput.angularVelocity * predictionTrajectoryTime, 0) * Vector3.forward;
}
}
}
public void Run(CommandArgs e) //命令插件核心，按下按钮后执行的部分
{
MessageBox.Show(ApplicationForm, "这是一次倒立的实践！");
BoneCollection bones = Scene.ActiveModel.Bones;
for (int i = 0; i < bones.Count; i++)
{
if (bones[i].Name != "全ての親")
{
continue;
}
MotionLayerCollection layers = bones[i].Layers;
for (int i2 = 0; i2 < layers.Count; i2++)
{
MotionFrameCollection frameDates = layers[i2].Frames;
for (int f = 0; f < 30; f++)
{
MotionFrameData data = new MotionFrameData();
data.FrameNumber = f * 10;
data.Quaternion = Quaternion.RotationAxis(new Vector3(0, 0, 1), 6 * f);
//Vector3 vector = frameDatas.GetFrame(f * 10).Position;
//vector.Y += 10;
frameDates.AddKeyFrame(data);
}
}
}
}
private MotionFrameData AcquireBakedMotionFrameData(string motionName, float normalizedTime, MotionMainEntryType motionMainEntryType)
{
MotionFrameData motionFrameData = null;
for (int i = 0; i < motionsData.motionDataList.Length; i++)
{
MotionData motionData = motionsData.motionDataList[i];
if (motionMainEntryType != MotionMainEntryType.none)
{
if (motionData.motionName.IndexOf(motionMatcherSettings.StandTag) >= 0 &&
motionMainEntryType == MotionMainEntryType.stand)
{
motionFrameData = motionData.motionFrameDataList[0];
break;
}
if (motionData.motionName.IndexOf(motionMatcherSettings.CrouchTag) >= 0 &&
motionMainEntryType == MotionMainEntryType.crouch)
{
motionFrameData = motionData.motionFrameDataList[0];
break;
}
}
else if (motionData.motionName == motionName)
{
int frame = Mathf.FloorToInt(motionData.motionFrameDataList.Length * normalizedTime);
motionFrameData = motionData.motionFrameDataList[frame];
}
}
return(motionFrameData);
}
void Start()
{
currentMotionFrameData = new MotionFrameData();
motionOwner = this.transform;
currentComputeTime = motionMatcherSettings.ComputeMotionsBestCostGap;
motionDebugDataList = new List <MotionDebugData>();
}
private float AcquireBakedMotionVelocity(string motionName, float normalizedTime, MotionMainEntryType motionMainEntryType)
{
MotionFrameData motionFrameData = AcquireBakedMotionFrameData(motionName, normalizedTime, motionMainEntryType);
if (motionFrameData != null)
{
return(motionFrameData.velocity);
}
return(0);
}
private void CaptureTrajectorySnapShot(AnimationClip animClip, MotionFrameData motionFrameData, MotionFrameData lastMotionFrameData, GameObject sampleGO, float bakeFrames, float currentFrame)
{
float lastFrameTime = 0;
for (int i = 0; i < predictionTrajectoryTimeList.Length; i++)
{
float PredictionTrajectoryTime = predictionTrajectoryTimeList[i];
float bakeDelta = currentFrame / bakeFrames;
EditorUtility.DisplayProgressBar("Baking Animation", string.Format("Processing: {0} Frame: {1}", animClip.name, i), bakeDelta);
float animationTime = bakeDelta * animClip.length + (PredictionTrajectoryTime * fps / bakeFrames) * animClip.length;
if (requiresAnimator)
{
float normalizedTime = animationTime / animClip.length;
animator.Play(animClip.name, 0, normalizedTime);
if (lastFrameTime == 0)
{
float nextBakeDelta = Mathf.Clamp01(((float)(PredictionTrajectoryTime * fps / bakeFrames)));
float nextAnimationTime = nextBakeDelta * animClip.length;
lastFrameTime = animationTime - nextAnimationTime;
}
animator.Update(animationTime - lastFrameTime);
lastFrameTime = animationTime;
}
else
{
GameObject sampleObject = sampleGO;
Animation legacyAnimation = sampleObject.GetComponentInChildren <Animation>();
if (animator && animator.gameObject != sampleObject)
{
sampleObject = animator.gameObject;
}
else if (legacyAnimation && legacyAnimation.gameObject != sampleObject)
{
sampleObject = legacyAnimation.gameObject;
}
animClip.SampleAnimation(sampleObject, animationTime);
}
MotionTrajectoryData motionTrajectoryData = motionFrameData.motionTrajectoryDataList[i];
motionTrajectoryData.position = animator.transform.position;
motionTrajectoryData.localPosition = motionTrajectoryData.position;
motionTrajectoryData.direction = animator.transform.forward;
//TODO
motionTrajectoryData.velocity = Vector3.zero;
}
float currentClipTime = predictionTrajectoryTimeList[predictionTrajectoryTimeList.Length - 1];
MotionTrajectoryData firstMotionTrajectoryData = motionFrameData.motionTrajectoryDataList[0];
MotionTrajectoryData lastMotionTrajectoryData = motionFrameData.motionTrajectoryDataList[motionFrameData.motionTrajectoryDataList.Length - 1];
Vector3 offset = lastMotionTrajectoryData.position - firstMotionTrajectoryData.position;
Vector3 velocity = offset / currentClipTime;
motionFrameData.velocity = velocity.magnitude;
}
private void CaptureBoneSnapShot(AnimationClip animClip, MotionFrameData motionFrameData, MotionFrameData lastMotionFrameData, GameObject sampleGO, float bakeFrames, float CurrentFrame)
{
float frameSkipsTimeStep = frameSkips[animClip.name] / (float)fps;
float bakeDelta = CurrentFrame / bakeFrames;
float animationTime = bakeDelta * animClip.length;
if (requiresAnimator)
{
float normalizedTime = animationTime / animClip.length;
animator.Play(animClip.name, 0, normalizedTime);
animator.Update(frameSkipsTimeStep);
}
else
{
GameObject sampleObject = sampleGO;
Animation legacyAnimation = sampleObject.GetComponentInChildren <Animation>();
if (animator && animator.gameObject != sampleObject)
{
sampleObject = animator.gameObject;
}
else if (legacyAnimation && legacyAnimation.gameObject != sampleObject)
{
sampleObject = legacyAnimation.gameObject;
}
animClip.SampleAnimation(sampleObject, animationTime);
}
int index = 0;
foreach (string boneName in bonesMap.Keys)
{
int boneIndex = bonesMap[boneName];
Transform child = joints[boneIndex];
MotionBoneData motionBoneData = motionFrameData.motionBoneDataList[index];
motionBoneData.position = child.position;
motionBoneData.localPosition = child.localPosition;
motionBoneData.rotation = child.rotation;
motionBoneData.localRotation = child.localRotation;
motionBoneData.velocity = Vector3.zero;
motionBoneData.boneName = child.name;
motionBoneData.boneIndex = boneIndex;
//calc velocity
if (lastMotionFrameData != null)
{
MotionBoneData lastMotionBoneData = lastMotionFrameData.motionBoneDataList[index];
lastMotionBoneData.velocity = (motionBoneData.localPosition - lastMotionBoneData.localPosition) / frameSkipsTimeStep;
}
index++;
}
}
protected virtual void OnSceneGUI()
{
float size = 0.1f;
MotionMatcher motionMatcher = (MotionMatcher)target;
currentMotionsData = motionMatcher.motionsData;
if (currentMotionsData)
{
Transform child = motionMatcher.transform.Find(MotionMatchingBakeEditor.RootBoneName);
Transform[] joints = child.GetComponentsInChildren <Transform>();
for (int i = 0; i < currentMotionsData.motionDataList.Length; i++)
{
MotionData motionData = currentMotionsData.motionDataList[i];
if (motionData.motionName == motionMatcher.bestMotionName ||
(string.IsNullOrEmpty(motionMatcher.bestMotionName) && motionData.motionName == defaultMotionName))
{
for (int j = 0; j < motionData.motionFrameDataList.Length; j++)
{
MotionFrameData motionFrameData = motionData.motionFrameDataList[j];
for (int k = 0; k < motionFrameData.motionBoneDataList.Length; k++)
{
MotionBoneData motionBoneData = motionFrameData.motionBoneDataList[k];
Transform bone = joints[motionBoneData.boneIndex];
if (bone)
{
Vector3 bonePosition = motionBoneData.position;
Handles.color = Color.green;
Handles.SphereHandleCap(0, bonePosition, Quaternion.identity, size, EventType.Repaint);
}
}
for (int l = 0; l < motionFrameData.motionTrajectoryDataList.Length; l++)
{
MotionTrajectoryData motionTrajectoryData = motionFrameData.motionTrajectoryDataList[l];
Handles.color = Color.yellow;
Handles.SphereHandleCap(0, motionTrajectoryData.position, Quaternion.identity, size, EventType.Repaint);
}
}
}
}
}
}
public void AddSequenceData(float[] data)
{
MotionFrameData frameData = new MotionFrameData();
frameData.deltaTime = data[0];
frameData.leftArm = new ArmAngles()
{
shoulder = data[1], upperArm = data[2], lowerArm = data[3]
};
frameData.rightArm = new ArmAngles()
{
shoulder = data[4], upperArm = data[5], lowerArm = data[6]
};
frameData.head = new HeadAngles()
{
neck = data[7], headBase = data[8]
};
sequence.Add(frameData);
}
private void CapturePlayingMotionSnapShot(string motionName, float velocity, Vector3 direction, float acceleration, float brake, float normalizedTime, MotionMainEntryType motionMainEntryType)
{
MotionFrameData bakedMotionFrameData = AcquireBakedMotionFrameData(motionName, normalizedTime, motionMainEntryType);
currentMotionFrameData.velocity = velocity;
currentMotionFrameData.motionBoneDataList = bakedMotionFrameData.motionBoneDataList;
currentMotionFrameData.motionTrajectoryDataList = new MotionTrajectoryData[motionMatcherSettings.predictionTrajectoryTimeList.Length];
float LastPredictionTrajectoryTime = 0;
Vector3 LastPredictionPosition = Vector3.zero;
for (int i = 0; i < motionMatcherSettings.predictionTrajectoryTimeList.Length; i++)
{
float predictionTrajectoryTime = motionMatcherSettings.predictionTrajectoryTimeList[i];
float deltaTime = predictionTrajectoryTime - LastPredictionTrajectoryTime;
currentMotionFrameData.motionTrajectoryDataList[i] = new MotionTrajectoryData();
MotionTrajectoryData motionTrajectoryData = currentMotionFrameData.motionTrajectoryDataList[i];
motionTrajectoryData.localPosition = LastPredictionPosition + velocity * direction * deltaTime;
motionTrajectoryData.velocity = velocity * direction;
motionTrajectoryData.direction = direction;
LastPredictionTrajectoryTime = predictionTrajectoryTime;
LastPredictionPosition = motionTrajectoryData.localPosition;
}
}
private void ComputeMotionsBestCost()
{
float bestMotionCost = float.MaxValue;
bestMotionName = "";
bestMotionFrameIndex = 0;
for (int i = 0; i < motionsData.motionDataList.Length; i++)
{
MotionData motionData = motionsData.motionDataList[i];
if (motionMatcherSettings.EnableDebugText)
{
AddDebugContent("motion: " + motionData.motionName);
}
for (int j = 0; j < motionData.motionFrameDataList.Length; j++)
{
MotionDebugData motionDebugData = new MotionDebugData();
float motionCost = 0f;
float bonesCost = 0f;
float bonePosCost = 0f;
float boneRotCost = 0f;
float trajectoryPosCost = 0f;
float trajectoryVelCost = 0f;
float trajectoryDirCost = 0f;
float trajectorysCost = 0f;
float rootMotionCost = 0f;
MotionFrameData motionFrameData = motionData.motionFrameDataList[j];
for (int k = 0; k < motionFrameData.motionBoneDataList.Length; k++)
{
MotionBoneData motionBoneData = motionFrameData.motionBoneDataList[k];
MotionBoneData currentMotionBoneData = currentMotionFrameData.motionBoneDataList[k];
float BonePosCost = Vector3.SqrMagnitude(motionBoneData.localPosition - currentMotionBoneData.localPosition);
Quaternion BonePosError = Quaternion.Inverse(motionBoneData.localRotation) * currentMotionBoneData.localRotation;
float BoneRotCost = Mathf.Abs(BonePosError.x) + Mathf.Abs(BonePosError.y) + Mathf.Abs(BonePosError.z) + (1 - Mathf.Abs(BonePosError.w));
//float BoneVelocityCost = Vector3.SqrMagnitude(motionBoneData.velocity - currentMotionBoneData.velocity);
bonePosCost += BonePosCost * motionCostFactorSettings.bonePosFactor;
boneRotCost += BoneRotCost * motionCostFactorSettings.boneRotFactor /* + BoneVelocityCost * motionCostFactorSettings.boneVelFactor*/;
//AddDebugContent("BonePosCost: " + BonePosCost);
//AddDebugContent("BoneRotCost: " + BoneRotCost);
//AddDebugContent("BoneVelocityCost: " + BoneVelocityCost);
}
bonesCost = bonePosCost + boneRotCost;
motionDebugData.bonePosCost = bonePosCost;
motionDebugData.boneRotCost = boneRotCost;
motionDebugData.bonesCost = bonesCost;
if (motionMatcherSettings.EnableDebugText)
{
AddDebugContent("bonesTotalCost: " + bonesCost);
}
for (int l = 0; l < motionFrameData.motionTrajectoryDataList.Length; l++)
{
MotionTrajectoryData motionTrajectoryData = motionFrameData.motionTrajectoryDataList[l];
MotionTrajectoryData currentMotionTrajectoryData = currentMotionFrameData.motionTrajectoryDataList[l];
trajectoryPosCost += Vector3.SqrMagnitude(motionTrajectoryData.localPosition - currentMotionTrajectoryData.localPosition) * motionCostFactorSettings.predictionTrajectoryPosFactor;
//trajectoryVelCost += Vector3.SqrMagnitude(motionTrajectoryData.velocity - currentMotionTrajectoryData.velocity) * motionCostFactorSettings.predictionTrajectoryVelFactor;
trajectoryDirCost += Vector3.Dot(motionTrajectoryData.direction, currentMotionTrajectoryData.direction) * motionCostFactorSettings.predictionTrajectoryDirFactor;
//AddDebugContent("trajectoryPosCost: " + trajectoryPosCost);
//AddDebugContent("trajectoryVelCost: " + trajectoryVelCost);
//AddDebugContent("trajectoryDirCost: " + trajectoryDirCost);
}
trajectorysCost = trajectoryPosCost + trajectoryVelCost + trajectoryDirCost;
motionDebugData.trajectoryPosCost = trajectoryPosCost;
motionDebugData.trajectoryVelCost = trajectoryVelCost;
motionDebugData.trajectoryDirCost = trajectoryDirCost;
motionDebugData.trajectorysCost = trajectorysCost;
if (motionMatcherSettings.EnableDebugText)
{
AddDebugContent("trajectorysToatalCost: " + trajectorysCost);
}
rootMotionCost = Mathf.Abs(motionFrameData.velocity - currentMotionFrameData.velocity) * motionCostFactorSettings.rootMotionVelFactor;
motionDebugData.rootMotionCost = rootMotionCost;
if (motionMatcherSettings.EnableDebugText)
{
AddDebugContent("rootMotionCost: " + rootMotionCost);
}
motionCost = bonesCost + trajectorysCost + rootMotionCost;
motionDebugData.motionCost = motionCost;
if (motionMatcherSettings.EnableDebugText)
{
AddDebugContent("motionTotalCost: " + motionCost);
}
//Debug.LogFormat("ComputeMotionsBestCost motionName {0} motionCost {1} ", motionData.motionName, motionCost);
if (bestMotionCost > motionCost)
{
bestMotionCost = motionCost;
bestMotionFrameIndex = j;
bestMotionName = motionData.motionName;
bestMotionDebugData = motionDebugData;
motionDebugData.motionName = motionData.motionName;
motionDebugData.motionFrameIndex = j;
motionDebugDataList.Add(motionDebugData);
}
}
}
}
private void onDropdownChanged(int arg0)
{
costTextContainer.SetActive(true);
hideCostTextContainerBtn.gameObject.SetActive(true);
MotionData[] motionDataList = playerMotionMatcher.motionsData.motionDataList;
MotionData motionData = motionDataList[arg0];
targetMotionFrameData = motionData.motionFrameDataList[0];
currentMotionFrameData = playerMotionMatcher.currentMotionFrameData;
MotionDebugData motionDebugData = new MotionDebugData();
AddDebugContent("----------------------" + motionData.motionName);
float motionCost = 0f;
float bonesCost = 0f;
float bonePosCost = 0f;
float boneRotCost = 0f;
float trajectoryPosCost = 0f;
float trajectoryVelCost = 0f;
float trajectoryDirCost = 0f;
float trajectorysCost = 0f;
float rootMotionCost = 0f;
for (int k = 0; k < targetMotionFrameData.motionBoneDataList.Length; k++)
{
MotionBoneData motionBoneData = targetMotionFrameData.motionBoneDataList[k];
MotionBoneData currentMotionBoneData = currentMotionFrameData.motionBoneDataList[k];
float BonePosCost = Vector3.SqrMagnitude(motionBoneData.localPosition - currentMotionBoneData.localPosition);
Quaternion BonePosError = Quaternion.Inverse(motionBoneData.localRotation) * currentMotionBoneData.localRotation;
float BoneRotCost = Mathf.Abs(BonePosError.x) + Mathf.Abs(BonePosError.y) + Mathf.Abs(BonePosError.z) + (1 - Mathf.Abs(BonePosError.w));
//float BoneVelocityCost = Vector3.SqrMagnitude(motionBoneData.velocity - currentMotionBoneData.velocity);
bonePosCost += BonePosCost * playerMotionMatcher.motionCostFactorSettings.bonePosFactor;
boneRotCost += BoneRotCost * playerMotionMatcher.motionCostFactorSettings.boneRotFactor /* + BoneVelocityCost * motionCostFactorSettings.boneVelFactor*/;
//AddDebugContent("BonePosCost: " + BonePosCost);
//AddDebugContent("BoneRotCost: " + BoneRotCost);
//AddDebugContent("BoneVelocityCost: " + BoneVelocityCost);
}
bonesCost = bonePosCost + boneRotCost;
motionDebugData.bonePosCost = bonePosCost;
motionDebugData.boneRotCost = boneRotCost;
motionDebugData.bonesCost = bonesCost;
AddDebugContent("bonesTotalCost: " + bonesCost);
for (int l = 0; l < targetMotionFrameData.motionTrajectoryDataList.Length; l++)
{
MotionTrajectoryData motionTrajectoryData = targetMotionFrameData.motionTrajectoryDataList[l];
MotionTrajectoryData currentMotionTrajectoryData = currentMotionFrameData.motionTrajectoryDataList[l];
trajectoryPosCost += Vector3.SqrMagnitude(motionTrajectoryData.localPosition - currentMotionTrajectoryData.localPosition) * playerMotionMatcher.motionCostFactorSettings.predictionTrajectoryPosFactor;
//trajectoryVelCost += Vector3.SqrMagnitude(motionTrajectoryData.velocity - currentMotionTrajectoryData.velocity) * motionCostFactorSettings.predictionTrajectoryVelFactor;
trajectoryDirCost += Vector3.Dot(motionTrajectoryData.direction, currentMotionTrajectoryData.direction) * playerMotionMatcher.motionCostFactorSettings.predictionTrajectoryDirFactor;
//AddDebugContent("trajectoryPosCost: " + trajectoryPosCost);
//AddDebugContent("trajectoryVelCost: " + trajectoryVelCost);
//AddDebugContent("trajectoryDirCost: " + trajectoryDirCost);
}
trajectorysCost = trajectoryPosCost + trajectoryVelCost + trajectoryDirCost;
motionDebugData.trajectoryPosCost = trajectoryPosCost;
motionDebugData.trajectoryVelCost = trajectoryVelCost;
motionDebugData.trajectoryDirCost = trajectoryDirCost;
motionDebugData.trajectorysCost = trajectorysCost;
AddDebugContent("trajectoryPosCost: " + trajectoryPosCost);
AddDebugContent("trajectoryVelCost: " + trajectoryVelCost);
AddDebugContent("trajectoryDirCost: " + trajectoryDirCost);
AddDebugContent("trajectorysToatalCost: " + trajectorysCost);
rootMotionCost = Mathf.Abs(targetMotionFrameData.velocity - currentMotionFrameData.velocity) * playerMotionMatcher.motionCostFactorSettings.rootMotionVelFactor;
motionDebugData.rootMotionCost = rootMotionCost;
AddDebugContent("rootMotionCost: " + rootMotionCost);
motionCost = bonesCost + trajectorysCost + rootMotionCost;
motionDebugData.motionCost = motionCost;
AddDebugContent("motionTotalCost: " + motionCost);
}
private void CreateSnapshots()
{
UnityEditor.Animations.AnimatorController bakeController = null;
string assetPath = GetPrefabPath();
if (string.IsNullOrEmpty(assetPath))
{
EditorUtility.DisplayDialog("Mesh Animator", "Unable to locate the asset path for prefab: " + prefab.name, "OK");
return;
}
HashSet <string> allAssets = new HashSet <string>();
List <AnimationClip> clips = GetClips();
foreach (var clip in clips)
{
allAssets.Add(AssetDatabase.GetAssetPath(clip));
}
string[] split = assetPath.Split("/".ToCharArray());
string assetFolder = string.Empty;
for (int s = 0; s < split.Length - 1; s++)
{
assetFolder += split[s] + "/";
}
var sampleGO = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
sampleGO.name = prefab.name;
animator = sampleGO.GetComponent <Animator>();
if (animator == null)
{
animator = sampleGO.GetComponentInChildren <Animator>();
}
InitAnimationBones(sampleGO);
if (requiresAnimator)
{
bakeController = CreateBakeController();
if (animator == null)
{
animator = sampleGO.AddComponent <Animator>();
animator.runtimeAnimatorController = bakeController;
animator.avatar = GetAvatar();
}
else
{
animator.runtimeAnimatorController = bakeController;
animator.avatar = GetAvatar();
}
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
animator.applyRootMotion = true;
}
MotionsData meshAnimationList = ScriptableObject.CreateInstance <MotionsData>();
meshAnimationList.motionDataList = new MotionData[clips.Count];
Transform rootMotionBaker = new GameObject().transform;
for (int x = 0; x < clips.Count; x++)
{
AnimationClip animClip = clips[x];
if (bakeAnims.ContainsKey(animClip.name) && bakeAnims[animClip.name] == false)
{
continue;
}
if (frameSkips.ContainsKey(animClip.name) == false)
{
Debug.LogWarningFormat("No animation with name {0} in frame skips", animClip.name);
continue;
}
string meshAnimationPath = string.Format("{0}{1}.asset", assetFolder, FormatClipName(animClip.name));
int bakeFrames = Mathf.CeilToInt(animClip.length * fps);
meshAnimationList.motionDataList[x] = new MotionData();
MotionData motionData = meshAnimationList.motionDataList[x];
motionData.motionName = animClip.name;
int totalFrame = 0;
for (int i = 0; i < bakeFrames; i += frameSkips[animClip.name])
{
totalFrame++;
}
motionData.motionFrameDataList = new MotionFrameData[totalFrame];
int frame = 0;
for (int i = 0; i < bakeFrames; i += frameSkips[animClip.name])
{
motionData.motionFrameDataList[frame] = new MotionFrameData();
motionData.motionFrameDataList[frame].motionBoneDataList = new MotionBoneData[bonesMap.Count];
motionData.motionFrameDataList[frame].motionTrajectoryDataList = new MotionTrajectoryData[predictionTrajectoryTimeList.Length];
for (int i1 = 0; i1 < bonesMap.Count; i1++)
{
motionData.motionFrameDataList[frame].motionBoneDataList[i1] = new MotionBoneData();
}
for (int i2 = 0; i2 < predictionTrajectoryTimeList.Length; i2++)
{
motionData.motionFrameDataList[frame].motionTrajectoryDataList[i2] = new MotionTrajectoryData();
}
frame++;
}
}
int animCount = 0;
for (int j = 0; j < clips.Count; j++)
{
//Vector3.zero, Quaternion.identity
sampleGO.transform.position = Vector3.zero;
sampleGO.transform.rotation = Quaternion.identity;
AnimationClip animClip = clips[j];
MotionData motionData = meshAnimationList.motionDataList[j];
int bakeFrames = Mathf.CeilToInt(animClip.length * fps);
int frame = 0;
for (int i = 0; i < bakeFrames; i += frameSkips[animClip.name])
{
float bakeDelta = Mathf.Clamp01(((float)i / bakeFrames));
EditorUtility.DisplayProgressBar("Baking Animation", string.Format("Processing: {0} Frame: {1}", animClip.name, i), bakeDelta);
float animationTime = bakeDelta * animClip.length;
MotionFrameData motionFrameData = motionData.motionFrameDataList[frame];
MotionFrameData lastMotionFrameData = frame > 0 ? motionData.motionFrameDataList[frame - 1] : null;
CaptureBoneSnapShot(animClip, motionFrameData, lastMotionFrameData, sampleGO, bakeFrames, i);
CaptureTrajectorySnapShot(animClip, motionFrameData, lastMotionFrameData, sampleGO, bakeFrames, i);
frame++;
}
animCount++;
}
//string TargetPath = Application.dataPath + "/Resources/" + sampleGO.name + "_MotionField1.asset";
//AssetDatabase.DeleteAsset(TargetPath);
//AssetDatabase.CreateAsset(meshAnimationList, TargetPath);
AssetDatabase.CreateAsset(meshAnimationList, assetFolder + sampleGO.name + "_MotionField.asset");
GameObject.DestroyImmediate(sampleGO);
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog("MotionField", string.Format("Baked {0} motionField {1} successfully!", clips.Count, clips.Count > 1 ? "s" : string.Empty), "OK");
try
{
//Wait
}
catch (System.Exception e)
{
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog("Bake Error", string.Format("There was a problem baking the animations.", e), "OK");
}
finally
{
if (bakeController)
{
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(bakeController));
}
}
}
