private void SendEvents(Animator animator, AnimEventType eventType)
{
var receiver = animator.GetComponent <AnimEventReceiver>();
if (receiver != null)
{
var exitEvents = _animEvents.Where(e => e.eventType == eventType);
foreach (var exitEvent in exitEvents)
{
receiver.SendEvent(animator, exitEvent);
}
}
}
/// <summary>
/// Gets all the anim event mappings for the given animator controller.
/// </summary>
private static CodeObjectCreateExpression CreateWithEventMappings(AnimatorController animatorController, CodeExpression layerDeclarations)
{
Dictionary <AnimatorState, AnimatorControllerLayer> layerMap = new Dictionary <AnimatorState, AnimatorControllerLayer>();
Dictionary <AnimEventType, List <AnimatorState> > bindings = new Dictionary <AnimEventType, List <AnimatorState> >();
Func <StateMachineBehaviour[], AnimEventBinder> containsBehaviour = (behaviourSet) =>
{
for (int i = 0; i < behaviourSet.Length; i++)
{
if (behaviourSet[i].GetType() == typeof(AnimEventBinder))
{
return((AnimEventBinder)behaviourSet[i]);
}
}
return(null);
};
Func <AnimatorControllerLayer, AnimatorState, int> getFullPathHash = (layer, state) =>
{
return(Animator.StringToHash(layer.name + "." + state.name));
};
for (int l = 0; l < animatorController.layers.Length; l++)
{
for (int s = 0; s < animatorController.layers[l].stateMachine.states.Length; s++)
{
AnimEventBinder binder = containsBehaviour(animatorController.layers[l].stateMachine.states[s].state.behaviours);
if (binder != null)
{
for (int a = 0; a < binder.animEventTypes.Length; a++)
{
if (!bindings.ContainsKey(binder.animEventTypes[a]))
{
bindings.Add(binder.animEventTypes[a], new List <AnimatorState>());
}
bindings[binder.animEventTypes[a]].Add(animatorController.layers[l].stateMachine.states[s].state);
layerMap.Add(animatorController.layers[l].stateMachine.states[s].state, animatorController.layers[l]);
}
}
}
}
AnimEventType[] boundAnimEvents = new AnimEventType[bindings.Keys.Count];
int[][] hashSets = new int[boundAnimEvents.Length][];
CodeFieldReferenceExpression[] eventsRefs = new CodeFieldReferenceExpression[boundAnimEvents.Length];
CodePrimitiveExpression[][] hashRefs = new CodePrimitiveExpression[hashSets.Length][];
CodeArrayCreateExpression[] subarrays = new CodeArrayCreateExpression[hashRefs.Length];
bindings.Keys.CopyTo(boundAnimEvents, 0);
for (int i = 0; i < boundAnimEvents.Length; i++)
{
hashSets[i] = new int[bindings[boundAnimEvents[i]].Count];
for (int s = 0; s < hashSets[i].Length; s++)
{
hashSets[i][s] = getFullPathHash(layerMap[bindings[boundAnimEvents[i]][s]], bindings[boundAnimEvents[i]][s]);
}
eventsRefs[i] = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(AnimEventType)), boundAnimEvents[i].ToString());
hashRefs[i] = new CodePrimitiveExpression[hashSets[i].Length];
for (int h = 0; h < hashSets[i].Length; i++)
{
hashRefs[i][h] = new CodePrimitiveExpression(hashSets[i][h]);
}
subarrays[i] = new CodeArrayCreateExpression(typeof(int[]), hashRefs[i]);
}
CodeExpression hashesMultiArrayDeclaration;
// If subarrays.Length == 0, CodeDOM will "optimize" this argument straight into a type mismatch!
// This is a hack that works around that by making sure we explicitly declare an empty array-of-arrays,
// if need be.
if (subarrays.Length > 0)
{
hashesMultiArrayDeclaration = new CodeArrayCreateExpression(typeof(int[][]), subarrays);
}
else
{
hashesMultiArrayDeclaration = new CodeSnippetExpression("new int[0][]");
}
return(new CodeObjectCreateExpression(typeof(AnimatorMetadata), new CodeExpression[] { layerDeclarations,
new CodeArrayCreateExpression(typeof(AnimEventType), eventsRefs), hashesMultiArrayDeclaration }));
}
public AnimEventResolver(AnimEventType _animEventType, int[] _hashes)
{
animEventType = _animEventType;
animsHashes = _hashes;
}
