public bool OnSelectEntry(SearchTreeEntry SearchTreeEntry, SearchWindowContext context)
{
Node node = null;
switch (SearchTreeEntry.name)
{
case "Clip":
node = new ClipNodeUI();
break;
case "Layer Mixer":
node = new LayerMixerNodeUI();
break;
case "Mixer":
node = new MixerNodeUI();
break;
case "1D Blendspace":
node = new Blendspace1DNodeUI();
break;
case "2D Blendspace":
node = new Blendspace2DNodeUI();
break;
case "State Machine":
node = new StateMachineNodeUI();
break;
case "Wildcard":
node = new WildcardNodeUI();
break;
case "Output":
node = new OutputNodeUI();
GraphView.OutputIndicatorNode = (OutputNodeUI)node;
break;
default:
break;
}
if (node is BaseNodeUI baseNode)
{
baseNode.ID = Guid.NewGuid().ToString();
}
GraphView.AddNode(node, context.screenMousePosition);
return(true);
}
public void LoadStateMachine(StateMachineNodeUI stateMachineUI)
{
CreateGraphView();
void SetNodePositionAndExpansion(Node node, NodeVisualInfo info)
{
node.SetPosition(new Rect(info.Position, Vector2.zero));
node.expanded = info.IsExpanded;
}
NodeUI = stateMachineUI;
var stateMachine = (StateMachineNode)stateMachineUI.StateMachineNodeAsset.Data;
var parameterMap = new Dictionary <Parameter, ParameterNodeUI>();
var valueProviderMap = new Dictionary <IValueProvider, StateMachineBaseNodeUI>();
foreach (var parameter in stateMachine.Parameters.Values)
{
var parameterNode = new ParameterNodeUI();
GraphView.AddNode(parameterNode);
SetNodePositionAndExpansion(parameterNode, stateMachineUI.StateMachineNodeAsset.ParameterMap[parameter.Id]);
parameterNode.LoadData(parameter);
parameterMap.Add(parameter, parameterNode);
valueProviderMap.Add(parameter.ValueProvider, parameterNode);
}
var stateToNodeMap = new Dictionary <State, StateNodeUI>();
var nodeToStateMap = new Dictionary <StateNodeUI, State>();
for (int i = 0; i < stateMachine.States.Count; i++)
{
string stateName = stateMachine.States.KeyAt(i);
State state = stateMachine.States.At(i);
var stateNode = new StateNodeUI();
stateNode.Name = stateName;
GraphView.AddNode(stateNode);
SetNodePositionAndExpansion(stateNode, stateMachineUI.StateMachineNodeAsset.StateMap[state.Id]);
stateToNodeMap.Add(state, stateNode);
nodeToStateMap.Add(stateNode, state);
valueProviderMap.Add(state.Time, stateNode);
valueProviderMap.Add(state.PreviousTime, stateNode);
valueProviderMap.Add(state.NormalizedTime, stateNode);
valueProviderMap.Add(state.PreviousNormalizedTime, stateNode);
}
var anyStateMap = new Dictionary <AnyState, AnyStateNodeUI>();
for (int i = 0; i < stateMachine.AnyStates.Items.Count; i++)
{
string anyStateName = stateMachine.AnyStates.Items.KeyAt(i);
AnyState anyState = stateMachine.AnyStates.Items.At(i);
//if (anyState == null) { continue; }
var anyStateNode = new AnyStateNodeUI();
anyStateNode.Name = anyStateName;
GraphView.AddNode(anyStateNode);
SetNodePositionAndExpansion(anyStateNode, stateMachineUI.StateMachineNodeAsset.AnyStateMap[anyState.Id]);
anyStateNode.LoadData(GraphView, anyState, stateToNodeMap);
anyStateMap.Add(anyState, anyStateNode);
foreach (var transition in anyState.ExitTransitions)
{
var transitionConnection = (TransitionConnectionUI)CreateConnection(anyStateNode, stateToNodeMap[transition.DestinationState], false);
LoadTransitionInfo(transitionConnection.Transitions[transitionConnection.Transitions.Count - 1], transition);
}
}
if (NodeUI.StateMachineNodeAsset.AnyStatePriorityManager != null)
{
var anyStatePriorityManagerNode = new AnyStatePriorityManagerNodeUI();
GraphView.AddNode(anyStatePriorityManagerNode);
SetNodePositionAndExpansion(anyStatePriorityManagerNode, stateMachineUI.StateMachineNodeAsset.AnyStatePriorityManager);
anyStatePriorityManagerNode.LoadData(GraphView, stateMachine.AnyStates.Items.Values, anyStateMap);
}
foreach (var state in stateMachine.States.Values)
{
foreach (var transition in state.ExitTransitions)
{
StateNodeUI stateNode = stateToNodeMap[(State)transition.SourceState];
var transitionConnection = (TransitionConnectionUI)CreateConnection(stateNode, stateToNodeMap[transition.DestinationState], false);
LoadTransitionInfo(transitionConnection.Transitions[transitionConnection.Transitions.Count - 1], transition);
}
}
void LoadTransitionInfo(TransitionInfo transitionInfo, Transition transition)
{
transitionInfo.DurationType = transition.DurationType;
transitionInfo.Duration = transition.Duration;
transitionInfo.OffsetType = transition.OffsetType;
transitionInfo.Offset = transition.Offset;
transitionInfo.InterruptionSource = transition.InterruptionSource;
transitionInfo.OrderedInterruption = transition.OrderedInterruption;
transitionInfo.InterruptableByAnyState = transition.InterruptableByAnyState;
transitionInfo.PlayAfterTransition = transition.PlayAfterTransition;
transition.Conditions.ForEach(condition =>
{
TransitionInfoCondition infoCondition = new TransitionInfoCondition();
transitionInfo.Conditions.Add(infoCondition);
if (condition.ValueProvider == null)
{
return;
}
StateMachineBaseNodeUI node = valueProviderMap[condition.ValueProvider];
if (node is StateNodeUI stateNode)
{
State state = nodeToStateMap[stateNode];
infoCondition.ProviderSourceType = ValueProviderSourceType.State;
infoCondition.State = stateNode;
infoCondition.StateValueProvider = condition.ValueProvider == state.PreviousTime ? StateValueProviders.PreviousTime
: condition.ValueProvider == state.Time ? StateValueProviders.Time
: condition.ValueProvider == state.NormalizedTime ? StateValueProviders.NormalizedTime
: StateValueProviders.PreviousNormalizedTime;
FloatConditionEvaluator floatEvaluator = (FloatConditionEvaluator)condition.Evaluator;
infoCondition.FloatComparison = floatEvaluator.Comparison;
infoCondition.FloatComparisonValue = floatEvaluator.ComparisonValue;
}
else
{
ParameterNodeUI parameterNode = (ParameterNodeUI)node;
infoCondition.ProviderSourceType = ValueProviderSourceType.Parameter;
infoCondition.Parameter = parameterNode;
switch (condition.Evaluator)
{
case BoolConditionEvaluator boolEvaluator:
infoCondition.BoolComparisonValue = boolEvaluator.ComparisonValue == Bool.True;
break;
case IntConditionEvaluator intEvaluator:
infoCondition.IntComparison = intEvaluator.Comparison;
infoCondition.IntComparisonValue = intEvaluator.ComparisonValue;
break;
case FloatConditionEvaluator floatEvaluator:
infoCondition.FloatComparison = floatEvaluator.Comparison;
infoCondition.FloatComparisonValue = floatEvaluator.ComparisonValue;
break;
}
}
});
}
EntryNodeUI entryStateNode = new EntryNodeUI();
GraphView.AddNode(entryStateNode);
GraphView.EntryNode = entryStateNode;
if (NodeUI.StateMachineNodeAsset.EntryState != null)
{
SetNodePositionAndExpansion(entryStateNode, NodeUI.StateMachineNodeAsset.EntryState);
}
entryStateNode.LoadData(GraphView, stateMachine.EntryState, stateToNodeMap);
}
private void OpenAnimationGraphAsset(AnimationGraphAsset asset)
{
AnimationGraphAsset = asset;
_closeButton.style.display = DisplayStyle.Flex;
_assetName.style.display = DisplayStyle.Flex;
_assetName.text = asset.name;
_closeToAssetNameSpacer.style.display = DisplayStyle.Flex;
_assetNameToSaveSpacer.style.display = DisplayStyle.Flex;
rootVisualElement.Remove(GraphView);
CreateGraphView();
Dictionary <NodeAsset, BaseNodeUI> nodeMap = new Dictionary <NodeAsset, BaseNodeUI>();
asset.Nodes.ForEach(n =>
{
BaseNodeUI nodeUI = null;
switch (n.Data)
{
case ClipNode clipNode:
nodeUI = new ClipNodeUI();
break;
case MixerNode mixerNode:
nodeUI = new MixerNodeUI();
break;
case LayerMixerNode layerMixerNode:
nodeUI = new LayerMixerNodeUI();
break;
case Blendspace1DNode blendspace1DNode:
nodeUI = new Blendspace1DNodeUI();
break;
case Blendspace2DNode blendspace2DNode:
nodeUI = new Blendspace2DNodeUI();
break;
case StateMachineNode stateMachineNode:
nodeUI = new StateMachineNodeUI();
break;
case WildcardNode wildcardNode:
nodeUI = new WildcardNodeUI();
break;
default:
break;
}
if (nodeUI != null)
{
GraphView.AddNode(nodeUI);
nodeUI.SetPosition(new Rect(n.Position, Vector2.zero));
nodeUI.expanded = n.IsExpanded;
nodeMap.Add(n, nodeUI);
}
});
foreach (var entry in nodeMap)
{
entry.Value.LoadData(GraphView, entry.Key, nodeMap);
}
if (asset.OutputIndicatorNode != null)
{
var outputIndicatorNode = new OutputNodeUI();
GraphView.OutputIndicatorNode = outputIndicatorNode;
GraphView.AddNode(outputIndicatorNode);
outputIndicatorNode.SetPosition(new Rect(asset.OutputIndicatorNode.Position, Vector2.zero));
outputIndicatorNode.expanded = asset.OutputIndicatorNode.IsExpanded;
if (asset.OutputNode != null)
{
BaseNodeUI outputNode = nodeMap[asset.OutputNode];
Edge edge = new Edge {
output = outputNode.OutputPort, input = outputIndicatorNode.InputPort
};
edge.input.Connect(edge);
edge.output.Connect(edge);
GraphView.AddElement(edge);
GraphView.OutputNode = outputNode;
}
}
}