/// <summary>
/// <para>Utility function to remove an entry transition from the state machine.</para>
/// </summary>
/// <param name="transition">The transition to remove.</param>
public bool RemoveEntryTransition(AnimatorTransition transition)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
AnimatorStateMachine.\u003CRemoveEntryTransition\u003Ec__AnonStorey19 transitionCAnonStorey19 = new AnimatorStateMachine.\u003CRemoveEntryTransition\u003Ec__AnonStorey19();
// ISSUE: reference to a compiler-generated field
transitionCAnonStorey19.transition = transition;
// ISSUE: reference to a compiler-generated method
if (!new List <AnimatorTransition>((IEnumerable <AnimatorTransition>) this.entryTransitions).Any <AnimatorTransition>(new Func <AnimatorTransition, bool>(transitionCAnonStorey19.\u003C\u003Em__21)))
{
return(false);
}
this.undoHandler.DoUndo((UnityEngine.Object) this, "Entry Transition Removed");
AnimatorTransition[] entryTransitions = this.entryTransitions;
// ISSUE: reference to a compiler-generated field
ArrayUtility.Remove <AnimatorTransition>(ref entryTransitions, transitionCAnonStorey19.transition);
this.entryTransitions = entryTransitions;
// ISSUE: reference to a compiler-generated field
if (MecanimUtilities.AreSameAsset((UnityEngine.Object) this, (UnityEngine.Object)transitionCAnonStorey19.transition))
{
// ISSUE: reference to a compiler-generated field
Undo.DestroyObjectImmediate((UnityEngine.Object)transitionCAnonStorey19.transition);
}
return(true);
}
public static bool StateMachineRelativePath(AnimatorStateMachine parent, AnimatorStateMachine toFind, ref List <AnimatorStateMachine> hierarchy)
{
hierarchy.Add(parent);
bool result;
if (parent == toFind)
{
result = true;
}
else
{
ChildAnimatorStateMachine[] childStateMachines = AnimatorStateMachine.StateMachineCache.GetChildStateMachines(parent);
for (int i = 0; i < childStateMachines.Length; i++)
{
if (MecanimUtilities.StateMachineRelativePath(childStateMachines[i].stateMachine, toFind, ref hierarchy))
{
result = true;
return(result);
}
}
hierarchy.Remove(parent);
result = false;
}
return(result);
}
public void RemoveTransition(AnimatorStateTransition transition)
{
this.undoHandler.DoUndo(this, "Transition removed");
AnimatorStateTransition[] transitions = this.transitions;
ArrayUtility.Remove <AnimatorStateTransition>(ref transitions, transition);
this.transitions = transitions;
if (MecanimUtilities.AreSameAsset(this, transition))
{
Undo.DestroyObjectImmediate(transition);
}
}
internal static void DestroyBlendTreeRecursive(BlendTree blendTree)
{
for (int i = 0; i < blendTree.children.Length; i++)
{
BlendTree blendTree2 = blendTree.children[i].motion as BlendTree;
if (blendTree2 != null && MecanimUtilities.AreSameAsset(blendTree, blendTree2))
{
MecanimUtilities.DestroyBlendTreeRecursive(blendTree2);
}
}
Undo.DestroyObjectImmediate(blendTree);
}
internal static void DestroyBlendTreeRecursive(BlendTree blendTree)
{
for (int index = 0; index < blendTree.children.Length; ++index)
{
BlendTree motion = blendTree.children[index].motion as BlendTree;
if ((Object)motion != (Object)null && MecanimUtilities.AreSameAsset((Object)blendTree, (Object)motion))
{
MecanimUtilities.DestroyBlendTreeRecursive(motion);
}
}
Undo.DestroyObjectImmediate((Object)blendTree);
}
/// <summary>
/// <para>Utility function to remove a transition from the state.</para>
/// </summary>
/// <param name="transition">Transition to remove.</param>
public void RemoveTransition(AnimatorStateTransition transition)
{
this.undoHandler.DoUndo((UnityEngine.Object) this, "Transition removed");
AnimatorStateTransition[] transitions = this.transitions;
ArrayUtility.Remove <AnimatorStateTransition>(ref transitions, transition);
this.transitions = transitions;
if (!MecanimUtilities.AreSameAsset((UnityEngine.Object) this, (UnityEngine.Object)transition))
{
return;
}
Undo.DestroyObjectImmediate((UnityEngine.Object)transition);
}
private void RemoveLayerInternal(int index, ref AnimatorControllerLayer[] layerVector)
{
if (layerVector[index].syncedLayerIndex == -1 && layerVector[index].stateMachine != null)
{
this.undoHandler.DoUndo(layerVector[index].stateMachine, "Layer removed");
layerVector[index].stateMachine.Clear();
if (MecanimUtilities.AreSameAsset(this, layerVector[index].stateMachine))
{
Undo.DestroyObjectImmediate(layerVector[index].stateMachine);
}
}
ArrayUtility.Remove <AnimatorControllerLayer>(ref layerVector, layerVector[index]);
}
public bool RemoveStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorTransition transition)
{
this.undoHandler.DoUndo(this, "StateMachine Transition Removed");
AnimatorTransition[] stateMachineTransitions = this.GetStateMachineTransitions(sourceStateMachine);
int num = stateMachineTransitions.Length;
ArrayUtility.Remove <AnimatorTransition>(ref stateMachineTransitions, transition);
this.SetStateMachineTransitions(sourceStateMachine, stateMachineTransitions);
if (MecanimUtilities.AreSameAsset(this, transition))
{
Undo.DestroyObjectImmediate(transition);
}
return(num != stateMachineTransitions.Length);
}
/// <summary>
/// <para>Utility function to remove an outgoing transition from source state machine.</para>
/// </summary>
/// <param name="transition">The transition to remove.</param>
/// <param name="sourceStateMachine">The source state machine.</param>
public bool RemoveStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorTransition transition)
{
this.undoHandler.DoUndo((UnityEngine.Object) this, "StateMachine Transition Removed");
AnimatorTransition[] machineTransitions = this.GetStateMachineTransitions(sourceStateMachine);
int length = machineTransitions.Length;
ArrayUtility.Remove <AnimatorTransition>(ref machineTransitions, transition);
this.SetStateMachineTransitions(sourceStateMachine, machineTransitions);
if (MecanimUtilities.AreSameAsset((UnityEngine.Object) this, (UnityEngine.Object)transition))
{
Undo.DestroyObjectImmediate((UnityEngine.Object)transition);
}
return(length != machineTransitions.Length);
}
public bool RemoveEntryTransition(AnimatorTransition transition)
{
if (new List <AnimatorTransition>(this.entryTransitions).Any((AnimatorTransition t) => t == transition))
{
this.undoHandler.DoUndo(this, "Entry Transition Removed");
AnimatorTransition[] entryTransitions = this.entryTransitions;
ArrayUtility.Remove <AnimatorTransition>(ref entryTransitions, transition);
this.entryTransitions = entryTransitions;
if (MecanimUtilities.AreSameAsset(this, transition))
{
Undo.DestroyObjectImmediate(transition);
}
return(true);
}
return(false);
}
public static bool StateMachineRelativePath(AnimatorStateMachine parent, AnimatorStateMachine toFind, ref List <AnimatorStateMachine> hierarchy)
{
hierarchy.Add(parent);
if ((Object)parent == (Object)toFind)
{
return(true);
}
for (int index = 0; index < parent.stateMachines.Length; ++index)
{
if (MecanimUtilities.StateMachineRelativePath(parent.stateMachines[index].stateMachine, toFind, ref hierarchy))
{
return(true);
}
}
hierarchy.Remove(parent);
return(false);
}
public bool RemoveStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorTransition transition)
{
undoHandler.DoUndo(this, "StateMachine Transition Removed");
AnimatorTransition[] transitionsVector = GetStateMachineTransitions(sourceStateMachine);
int baseSize = transitionsVector.Length;
ArrayUtility.Remove(ref transitionsVector, transition);
SetStateMachineTransitions(sourceStateMachine, transitionsVector);
if (MecanimUtilities.AreSameAsset(this, transition))
{
Undo.DestroyObjectImmediate(transition);
}
return(baseSize != transitionsVector.Length);
}
public bool RemoveEntryTransition(AnimatorTransition transition)
{
if ((new List <AnimatorTransition>(entryTransitions)).Any(t => t == transition))
{
undoHandler.DoUndo(this, "Entry Transition Removed");
AnimatorTransition[] transitionsVector = entryTransitions;
ArrayUtility.Remove(ref transitionsVector, transition);
entryTransitions = transitionsVector;
if (MecanimUtilities.AreSameAsset(this, transition))
{
Undo.DestroyObjectImmediate(transition);
}
return(true);
}
return(false);
}
public bool RemoveAnyStateTransition(AnimatorStateTransition transition)
{
bool result;
if (new List <AnimatorStateTransition>(this.anyStateTransitions).Any((AnimatorStateTransition t) => t == transition))
{
this.undoHandler.DoUndo(this, "AnyState Transition Removed");
AnimatorStateTransition[] anyStateTransitions = this.anyStateTransitions;
ArrayUtility.Remove <AnimatorStateTransition>(ref anyStateTransitions, transition);
this.anyStateTransitions = anyStateTransitions;
if (MecanimUtilities.AreSameAsset(this, transition))
{
Undo.DestroyObjectImmediate(transition);
}
result = true;
}
else
{
result = false;
}
return(result);
}
public void RemoveLayer(int index)
{
this.undoHandler.DoUndo(this, "Layer removed");
AnimatorControllerLayer[] layers = this.layers;
if (layers[index].syncedLayerIndex == -1 && layers[index].stateMachine != null)
{
layers[index].stateMachine.Clear();
if (MecanimUtilities.AreSameAsset(this, layers[index].stateMachine))
{
Undo.DestroyObjectImmediate(layers[index].stateMachine);
}
}
AnimatorControllerLayer[] array = layers;
for (int i = 0; i < array.Length; i++)
{
AnimatorControllerLayer animatorControllerLayer = array[i];
if (animatorControllerLayer.syncedLayerIndex == index)
{
animatorControllerLayer.syncedLayerIndex = -1;
}
}
ArrayUtility.Remove <AnimatorControllerLayer>(ref layers, layers[index]);
this.layers = layers;
}
