private List <AnimationLayerInfo> ReadLayers(BinaryReader reader)
{
List <AnimationLayerInfo> ret = new List <AnimationLayerInfo>();
int tcount = reader.ReadInt32();
for (int j = 0; j < tcount; j++)
{
var item = new AnimationLayerInfo();
item.ReadFromFile(reader);
ret.Add(item);
}
return(ret);
}
void AnalyzeStateMachine(AnimationLayerInfo pLayerInfo,
UnityEditor.Animations.AnimatorControllerLayer ownerLayer,
UnityEditor.Animations.AnimatorStateMachine stateMachine,
Animator animator,
SkinnedMeshRenderer[] meshRender,
int layer,
int bakeFPS,
int animationIndex)
{
var tmachineInfo = new AnimationStateMachineInfo()
{
layerIndex = pLayerInfo.index, index = pLayerInfo.machines.Count,
defaultName = stateMachine.defaultState != null ? stateMachine.defaultState.name : "",
machineName = stateMachine.name
};
pLayerInfo.machines.Add(tmachineInfo);
for (int i = 0; i != stateMachine.states.Length; ++i)
{
ChildAnimatorState state = stateMachine.states[i];
var tstateinfo = new AnimationStateInfo()
{
layerIndex = pLayerInfo.index, machineIndex = tmachineInfo.index, index = i
};
tstateinfo.SetData(state.state);
tmachineInfo.stateInfos.Add(tstateinfo);
AnimationClip clip = state.state.motion as AnimationClip;
bool needBake = false;
if (clip == null)
{
continue;
}
if (!generateAnims.TryGetValue(clip.name, out needBake))
{
continue;
}
foreach (var obj in generateInfo)
{
if (obj.info.animationName == clip.name)
{
needBake = false;
break;
}
}
if (!needBake)
{
continue;
}
AnimationBakeInfo bake = new AnimationBakeInfo();
bake.length = clip.averageDuration;
bake.animator = animator;
bake.animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
bake.meshRender = meshRender;
bake.layer = layer;
bake.info = new AnimationInfo();
bake.info.animationName = clip.name;
bake.info.animationNameHash = state.state.nameHash;
bake.info.animationIndex = animationIndex;
bake.info.totalFrame = (int)(bake.length * bakeFPS + 0.5f) + 1;
bake.info.totalFrame = Mathf.Clamp(bake.info.totalFrame, 1, bake.info.totalFrame);
bake.info.fps = bakeFPS;
bake.info.rootMotion = true;
bake.info.wrapMode = clip.isLooping ? WrapMode.Loop : clip.wrapMode;
if (bake.info.rootMotion)
{
bake.info.velocity = new Vector3[bake.info.totalFrame];
bake.info.angularVelocity = new Vector3[bake.info.totalFrame];
}
generateInfo.Add(bake);
animationIndex += bake.info.totalFrame;
totalFrame += bake.info.totalFrame;
bake.info.eventList = new List <AnimationEvent>();
//AnimationClip clip = state.state.motion as AnimationClip;
foreach (var evt in clip.events)
{
AnimationEvent aniEvent = new AnimationEvent();
aniEvent.function = evt.functionName;
aniEvent.floatParameter = evt.floatParameter;
aniEvent.intParameter = evt.intParameter;
aniEvent.stringParameter = evt.stringParameter;
aniEvent.time = evt.time;
if (evt.objectReferenceParameter != null)
{
aniEvent.objectParameter = evt.objectReferenceParameter.name;
}
else
{
aniEvent.objectParameter = "";
}
bake.info.eventList.Add(aniEvent);
}
cacheTransition.Add(state.state, state.state.transitions);
state.state.transitions = null;
cacheAnimationEvent.Add(clip, clip.events);
UnityEngine.AnimationEvent[] tempEvent = new UnityEngine.AnimationEvent[0];
UnityEditor.AnimationUtility.SetAnimationEvents(clip, tempEvent);
}
for (int i = 0; i != stateMachine.stateMachines.Length; ++i)
{
AnalyzeStateMachine(pLayerInfo, ownerLayer, stateMachine.stateMachines[i].stateMachine, animator, meshRender, layer, bakeFPS, animationIndex);
}
}
public RuntimeAnimatorLayer(AnimationLayerInfo pInfo)
{
layerInfo = pInfo;
}
void BakeWithAnimator()
{
if (generatedPrefab != null)
{
generatedObject = Instantiate(generatedPrefab);
Selection.activeGameObject = generatedObject;
generatedObject.transform.position = Vector3.zero;
generatedObject.transform.rotation = Quaternion.identity;
Animator animator = generatedObject.GetComponentInChildren <Animator>();
AnimationInstancing script = generatedObject.GetComponent <AnimationInstancing>();
Debug.Assert(script);
SkinnedMeshRenderer[] meshRender = generatedObject.GetComponentsInChildren <SkinnedMeshRenderer>();
List <Matrix4x4> bindPose = new List <Matrix4x4>(150);
Transform[] boneTransform = RuntimeHelper.MergeBone(meshRender, bindPose);
// calculate the bindpose of attached points
if (generatedFbx)
{
List <Transform> listExtra = new List <Transform>();
Transform[] trans = generatedFbx.GetComponentsInChildren <Transform>();
Transform[] bakedTrans = generatedObject.GetComponentsInChildren <Transform>();
foreach (var obj in selectExtraBone)
{
if (!obj.Value)
{
continue;
}
for (int i = 0; i != trans.Length; ++i)
{
Transform tran = trans[i] as Transform;
if (tran.name == obj.Key)
{
bindPose.Add(tran.localToWorldMatrix);
listExtra.Add(bakedTrans[i]);
}
}
}
Transform[] totalTransform = new Transform[boneTransform.Length + listExtra.Count];
System.Array.Copy(boneTransform, totalTransform, boneTransform.Length);
System.Array.Copy(listExtra.ToArray(), 0, totalTransform, boneTransform.Length, listExtra.Count);
boneTransform = totalTransform;
//boneTransform = boneTransform;
extraBoneInfo = new ExtraBoneInfo();
extraBoneInfo.extraBone = new string[listExtra.Count];
extraBoneInfo.extraBindPose = new Matrix4x4[listExtra.Count];
for (int i = 0; i != listExtra.Count; ++i)
{
extraBoneInfo.extraBone[i] = listExtra[i].name;
extraBoneInfo.extraBindPose[i] = bindPose[bindPose.Count - listExtra.Count + i];
}
}
Reset();
AddMeshVertex2Generate(meshRender, boneTransform, bindPose.ToArray());
Transform rootNode = meshRender[0].rootBone;
for (int j = 0; j != meshRender.Length; ++j)
{
meshRender[j].enabled = true;
}
animator.applyRootMotion = true;
totalFrame = 0;
//初始化数据
cacheTransition.Clear();
cacheAnimationEvent.Clear();
layerInfos.Clear();
AnimationInstancing instance = generatedPrefab.GetComponent <AnimationInstancing>();
if (instance == null)
{
Debug.LogError("You should select a prefab with AnimationInstancing component.");
return;
}
SetFileName(generatedPrefab);
var controller = animator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
var tlayers = controller.layers;
for (int i = 0; i < tlayers.Length; i++)
{
var layer = tlayers[i];
var tinfo = new AnimationLayerInfo()
{
name = layer.name, index = i
};
AnalyzeStateMachine(tinfo, layer, layer.stateMachine, animator, meshRender, 0, aniFps, 0);
layerInfos.Add(tinfo);
}
// UnityEditor.Animations.AnimatorControllerLayer layer = controller.layers[0];
//AnalyzeStateMachine(layer.stateMachine, animator, meshRender, 0, aniFps, 0);
generateCount = generateInfo.Count;
}
}
