/// <summary>
/// Draws the node inspector.
/// <param name="target">The node that is being inspected.</param>
/// </summary>
public void DrawNode(ActionNode target)
{
// Create style?
if (s_Styles == null)
{
s_Styles = new NodeEditor.Styles();
}
if (target == null)
{
m_SerializedNode = null;
m_Target = null;
m_TargetContent = GUIContent.none;
m_TargetIconContent = GUIContent.none;
m_TargetType = string.Empty;
}
// The target node has changed?
else if (m_SerializedNode == null || m_SerializedNode.target != target)
{
m_SerializedNode = new SerializedNode(target);
m_Target = target;
Type targetType = m_Target.GetType();
m_TargetType = " (" + targetType.Name + ")";
var nodeInfo = AttributeUtility.GetAttribute <NodeInfoAttribute>(targetType, false) ?? new NodeInfoAttribute();
m_TargetContent = new GUIContent(target.name + m_TargetType, null, nodeInfo.description);
m_TargetIconContent = new GUIContent(IconUtility.GetIcon(targetType));
// Update Values
m_SerializedNode.Update();
}
// The serialized node is not null?
if (m_SerializedNode != null)
{
// Draw node title
this.DrawTitle();
if (m_Target != null && BehaviourWindow.IsVisible(m_Target.instanceID))
{
// Draw node properties
this.OnInspectorGUI();
// Update target content?
if (Event.current.type == EventType.Used && m_Target != null)
{
m_TargetContent.text = m_Target.name + m_TargetType;
}
}
}
}
/// <summary>
/// Behaviour Machine callback called whenever the active node changes.
/// </summary>
private void ActiveNodeChanged()
{
// Get the active node
ActionNode activeNode = this.GetActiveNode();
if (activeNode != null)
{
// Create an editor node for the active node
m_NodeEditor = activeNode == null ? null : NodeEditor.CreateEditor(activeNode.GetType());
}
// Repaint this inspector
this.Repaint();
}
/// <summary>
/// Reset the supplied node properties.
/// <param name="node">The node to be reseted.</param>
/// </summary>
public static void ResetNode(ActionNode node)
{
// Get the owner as an Uniyt object
var ownerUnityObj = node != null ? node.owner as UnityEngine.Object : null;
// Validate parameters
if (ownerUnityObj != null)
{
// Register Undo
#if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
Undo.RegisterUndo(ownerUnityObj, "Reset Node");
#else
Undo.RecordObject(ownerUnityObj, "Reset Node");
#endif
node.name = node.GetType().Name;
node.Reset();
node.OnValidate();
StateUtility.SetDirty(node.owner);
}
}
public static NodeLinkedList compile(LinkedListNode <Token> firstToken)
{
CompiledStatement cs = CompilerFactory.Instance.CreateCompiledStatement(firstToken);
Compiled = cs.compile(ref firstToken);
while (firstToken != null)
{
cs = CompilerFactory.Instance.CreateCompiledStatement(firstToken);
NodeLinkedList nll = cs.compile(ref firstToken);
Compiled.Add(nll);
}
ActionNode a = Compiled.First;
while (a != null)
{
Console.WriteLine(a.GetType());
a = a.Next;
}
return(Compiled);
}
/// <summary>
/// Updates the active node data.
/// <param name="activeNode">The active node.</param>
/// </summary>
void UpdateActiveNode(ActionNode activeNode)
{
var activeNodeType = activeNode != null?activeNode.GetType() : null;
// The active node type has changed?
if (activeNodeType != m_ActiveNodeType)
{
if (activeNode == null)
{
m_ActiveNodeType = null;
m_ActiveNodeInfo = null;
m_ActiveNodeIcon = null;
m_ActiveNodeTypeName = string.Empty;
return;
}
else
{
m_ActiveNodeType = activeNodeType;
m_ActiveNodeInfo = AttributeUtility.GetAttribute <NodeInfoAttribute>(m_ActiveNodeType, true) ?? new NodeInfoAttribute();
m_ActiveNodeIcon = IconUtility.GetIcon(m_ActiveNodeType);
m_ActiveNodeTypeName = " (" + m_ActiveNodeType.Name + ")";
}
}
}
/// <summary>
/// Class constructor. Create SerializedNode for inspected object.
/// <param name="target">The node to get the be inspected.</param>
/// </summary>
public SerializedNode(ActionNode target)
{
m_Target = target;
m_Type = m_Target.GetType();
m_RecreateData = true;
}
//
// Methods
//
/// <summary>
/// Handles the onGUI event.
/// </summary>
/// <param name="property">Property.</param>
/// <param name="node">Node.</param>
/// <param name="guiContent">GUI content.</param>
public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
{
//if (animatorSerialized == null || aniController == null) {
if (aniController == null)
{
//!!! Serialization never serialized Animator cos its initialized in Reset after
// NodePropertyIterator iter= property.serializedNode.GetIterator();
// iter.Find(attribute.animatorFieldName);
// animatorSerialized=iter.current;
// // if(animatorSerialized==null || animatorSerialized.value==null){
// Debug.LogError("AnimatorStateNodePropertyDrawer> No Animator component set on node parent GameObject");
// return;
// }
//runtimeContoller =( (Animator)animatorSerialized.value).runtimeAnimatorController;
Animator animator = node.GetType().GetField(attribute.animatorFieldName).GetValue(node) as Animator;
RuntimeAnimatorController runtimeContoller;
runtimeContoller = animator.runtimeAnimatorController;
if (runtimeContoller is AnimatorOverrideController)
{
aniController = ((AnimatorOverrideController)runtimeContoller).runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
}
else
{
aniController = runtimeContoller as UnityEditor.Animations.AnimatorController;
}
}
animatorStateDisplayOptions = MecanimUtility.GetDisplayOptions(aniController);
animatorStateValues = MecanimUtility.GetAnimatorStates(aniController);
if (property.value != null)
{
if (animatorStateValues.Length > 0)
{
animatorStateSelectedPrev = animatorStateSelected = animatorStateValues.FirstOrDefault((itm) => itm.nameHash == ((ws.winx.unity.AnimatorState)property.value).nameHash);
}
}
animatorStateSelected = EditorGUILayoutEx.CustomObjectPopup(guiContent, animatorStateSelected, animatorStateDisplayOptions, animatorStateValues); //,compare);
//TODO try Begin/End Check
if (animatorStateSelectedPrev != animatorStateSelected)
{
NodePropertyIterator iter = property.serializedNode.GetIterator();
iter.Find(attribute.layerIndexFieldName);
SerializedNodeProperty layerIndexSerialized = iter.current;
layerIndexSerialized.value = MecanimUtility.GetLayerIndex(aniController, animatorStateSelected);
layerIndexSerialized.ApplyModifiedValue();
ws.winx.unity.AnimatorState state = property.value as ws.winx.unity.AnimatorState;
if (state == null)
{
state = ScriptableObject.CreateInstance <ws.winx.unity.AnimatorState>();
}
state.motion = animatorStateSelected.motion;
state.nameHash = animatorStateSelected.nameHash;
state.layer = (int)layerIndexSerialized.value;
if (state.motion is UnityEditor.Animations.BlendTree)
{
BlendTree tree = (BlendTree)state.motion;
int blendParamsNum = tree.GetRecursiveBlendParamCount();
state.blendParamsHashes = new int[blendParamsNum];
for (int i = 0; i < blendParamsNum; i++)
{
state.blendParamsHashes[i] = Animator.StringToHash(tree.GetRecursiveBlendParam(i));
}
}
else
{
state.blendParamsHashes = null;
}
//property.value=state;
property.ValueChanged();
property.ApplyModifiedValue();
animatorStateSelectedPrev = animatorStateSelected;
}
if (animatorStateSelected.motion == null)
{
Debug.LogError("Selected state doesn't have Motion set");
}
}
/// <summary>
/// Draw a node.
/// <param name="rect">The rect to draw the node.</param>
/// <param name="index">The index of the node to be drawn.</param>
/// <param name="selected">The node is selected?</param>
/// <param name="focused">The node is being focused?</param>
/// </summary>
private void DrawNode(Rect rect, int index, bool selected, bool focused)
{
ActionNode[] nodes = m_ActionState.GetNodes();
if (index < 0 || index >= nodes.Length)
{
return;
}
// Get the node
ActionNode node = nodes[index];
Event current = Event.current;
switch (current.type)
{
case EventType.Repaint:
// Get the node id
int nodeId = node.instanceID;
// Create the gui content
var guiContent = new GUIContent(node.name, IconUtility.GetIcon(node.GetType()));
// Get the guiStyle
var guiStyle = InternalActionStateEditor.s_Styles.label;
// Set style color
if (node is ConditionNode)
{
guiStyle.normal.textColor = TreeGUI.Yellow;
guiStyle.focused.textColor = TreeGUI.Yellow;
}
else if (node is MissingNode)
{
guiStyle.normal.textColor = TreeGUI.Red;
guiStyle.focused.textColor = TreeGUI.Red;
}
else if (node is BranchNode)
{
guiStyle.normal.textColor = s_Styles.textColor;
guiStyle.focused.textColor = s_Styles.textColor;
}
// else if (node is ICallbackNode) {
// guiStyle.normal.textColor = TreeGUI.Blue;
// guiStyle.focused.textColor = TreeGUI.Blue;
// }
else
{
guiStyle.normal.textColor = TreeGUI.Green;
guiStyle.focused.textColor = TreeGUI.Green;
}
// Draw the node name and icon
Rect nodeRect = rect;
nodeRect.yMin += 1;
nodeRect.yMax -= 4;
guiStyle.Draw(nodeRect, guiContent, focused, focused, selected, focused);
// Draw visual debugging?
if (Application.isPlaying && m_NodeStatusTime.ContainsKey(nodeId))
{
var pingStyle = InternalActionStateEditor.s_Styles.ping;
var pingRect = nodeRect;
pingRect.xMax = pingStyle.CalcSize(guiContent).x + (guiContent.image.height > 16f ? 0f : 28f);
pingRect.xMin -= 8f;
pingRect.yMin += 1f;
pingRect.yMax -= 1f;
// pingRect.y += 1f;
// pingRect.height -= 2f;
// Get the delta time
var dt = (float)(EditorApplication.timeSinceStartup - m_NodeStatusTime[nodeId].time);
// Set gui color
Color oldColor = GUI.color;
switch (m_NodeStatusTime[nodeId].status)
{
case Status.Success:
GUI.color = new Color(0f, .8f, 0f, 1f - dt); // green
break;
case Status.Failure:
GUI.color = new Color(.8f, .8f, 0f, 1f - dt); // yellow
break;
case Status.Error:
GUI.color = new Color(.8f, 0f, 0f, 1f - dt); // red
break;
case Status.Running:
GUI.color = new Color(0f, 0f, 1f, .6f - dt); // blue
break;
}
// Draw ping for one second
if (dt >= 1f)
{
m_NodeStatusTime.Remove(nodeId);
}
// Draw ping
pingStyle.Draw(pingRect, guiContent, false, false, false, false);
// Restore old gui color
GUI.color = oldColor;
}
break;
case EventType.MouseDown:
if (current.button == 1 && rect.Contains(current.mousePosition))
{
NodeContextMenu(node);
current.Use();
}
break;
}
}
