public void Unplug()
{
if (IsPlugged())
{
GetPluggedPort().UnplugFrom(this);
}
plugged_port = null;
get_filter = GetFilter.DefaultValue;
}
protected Port RegisterOutputValue(Type type, string name, ActValue <object> action, bool display_port = true)
{
recently_modified.Add(name);
Port p;
if (outputs.TryGetValue(name, out p))
{
p.display_port = display_port;
IOutputValue output = p as IOutputValue;
if (output != null)
{
output.SetAction(action);
return((Port)output);
}
}
return(RegisterOutputPort(name, (ValuePort)CreateGenericInstance(typeof(OutputValue <>), type, this, type, action), display_port));
}
//Input -> Component
//Output -> Rigidbody
public void PlugTo(IPlugOut port)
{
if (CanPlug(port))
{
if (IsPlugged())
{
GetPluggedPort().UnplugFrom(this);
}
plugged_port = (IOutputValue)port;
if (typeof(T).IsAssignableFrom(((IOutputValue)port).valueType))
{
get_filter = GetFilter.Action;
}
else if (((IOutputValue)port).valueType.CanConvert(typeof(T)))
{
get_filter = GetFilter.ActionWithConverter;
}
port.AddPlug(this);
}
}
private void InputGUI()
{
Vector2 delta = current.delta;
switch (current.type)
{
case EventType.MouseDown:
GraphEditor.mouse_down_position = GraphEditor.mouse_position;
switch (current.button)
{
case 0:
if (current.alt)
{
break;
}
if (GraphEditor.hover_node)
{
if (current.clickCount >= 2)
{
if (GraphEditor.hover_node is MacroNode)
{
SetGraphAsset(((MacroNode)GraphEditor.hover_node).reference);
current.Use();
return;
}
else
{
EditorUtils.OpenScriptByType(GraphEditor.hover_node.type);
current.Use();
}
}
if (GraphEditor.hover_port)
{
if (current.control)
{
if (GraphEditor.hover_port is OutputAction)
{
UndoManager.RecordObject(GraphEditor.asset, string.Format("{0} Add Branch", GraphEditor.asset.name));
set_dirty = true;
QuickPlugPort(GraphEditor.hover_port, AddNode <Branch>(GraphEditor.mouse_position / GraphEditor.zoom - GraphEditor.scroll + new Vector2(60.0f, 0.0f)));
}
}
else
{
if (current.shift)
{
GraphEditor.can_drag_node = false;
GraphEditor.can_drag_port = false;
if (GraphEditor.hover_port is IPlug)
{
UndoManager.RecordObject(GraphEditor.asset, string.Format("{0} > {1}: {2} Unplug", GraphEditor.asset.name, GraphEditor.hover_node.name, GraphEditor.hover_port.name));
set_dirty = true;
((IPlug)GraphEditor.hover_port).Unplug();
}
current.Use();
}
else
{
GraphEditor.can_drag_node = false;
GraphEditor.can_drag_port = true;
SelectOnlyNode(GraphEditor.hover_node);
current.Use();
}
}
}
else
{
if (current.shift)
{
if (GraphEditor.hover_node.is_selected)
{
GraphEditor.can_drag_node = false;
DeselectNode(GraphEditor.hover_node);
current.Use();
}
else
{
GraphEditor.can_drag_node = true;
SelectNode(GraphEditor.hover_node);
current.Use();
}
}
else
{
if (GraphEditor.hover_node.is_selected)
{
GraphEditor.can_drag_node = true;
}
else
{
GraphEditor.can_drag_node = true;
SelectOnlyNode(GraphEditor.hover_node);
current.Use();
}
}
}
}
else if (editable_area.Contains(GraphEditor.mouse_position))
{
GraphEditor.can_select = true;
}
break;
case 1:
break;
case 2:
break;
}
break;
case EventType.MouseUp:
switch (current.button)
{
case 0:
if (GraphEditor.can_select && GraphEditor.is_select)
{
Rect select_box_in_scroll = new Rect(select_box.position / target_zoom, select_box.size / target_zoom);
List <Node> nodes = GraphEditor.graph.nodes.Where((n) => select_box_in_scroll.Overlaps(n.nodeRect)).ToList();
if (current.shift)
{
foreach (Node node in nodes)
{
if (node.is_selected)
{
DeselectNode(node);
}
else
{
SelectNode(node);
}
}
current.Use();
}
else
{
ClearSelection();
SelectNodes(nodes);
current.Use();
}
}
else
{
if (GraphEditor.hover_node)
{
if (GraphEditor.is_drag)
{
if (GraphEditor.drag_port)
{
if (GraphEditor.hover_port)
{
PlugPort(GraphEditor.drag_port, GraphEditor.hover_port);
}
else
{
QuickPlugPort(GraphEditor.drag_port, GraphEditor.hover_node);
}
current.Use();
}
}
else
{
if (!current.shift)
{
if (GraphEditor.selection.Count > 1)
{
SelectOnlyNode(GraphEditor.hover_node);
current.Use();
}
}
}
}
else if (!GraphEditor.is_scrolling)
{
ClearSelection();
}
if (GraphEditor.drag_port && !GraphEditor.hover_node)
{
InputAction in_act = GraphEditor.drag_port as InputAction;
OutputAction out_act = GraphEditor.drag_port as OutputAction;
IInputValue in_value = GraphEditor.drag_port as IInputValue;
IOutputValue out_value = GraphEditor.drag_port as IOutputValue;
if (in_act != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:in void");
}
else if (out_act != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:out void");
}
else if (in_value != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:out " + in_value.valueType.GetTypeName(false, true));
}
else if (out_value != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:in " + out_value.valueType.GetTypeName(false, true));
}
}
}
GraphEditor.can_select = false;
GraphEditor.is_select = false;
GraphEditor.is_scrolling = false;
GraphEditor.hover_node = null;
GraphEditor.drag_node = null;
if (!GraphEditor.waiting_for_new_node)
{
GraphEditor.is_drag = false;
GraphEditor.drag_port = null;
GraphEditor.can_drag_port = false;
}
GraphEditor.can_drag_node = false;
break;
case 1:
if (!GraphEditor.is_drag)
{
AdvancedSearchWindow.Init(GraphEditor.mouse_position);
current.Use();
}
GraphEditor.is_drag = false;
break;
case 2:
break;
}
break;
case EventType.MouseDrag:
switch (current.button)
{
case 0:
if (current.alt)
{
GraphEditor.is_drag = true;
GraphEditor.is_scrolling = true;
GraphEditor.scroll += delta;
break;
}
if (!GraphEditor.is_drag)
{
if (GraphEditor.can_drag_port && GraphEditor.hover_port)
{
GraphEditor.is_drag = true;
GraphEditor.can_drag_node = false;
GraphEditor.drag_port = GraphEditor.hover_port;
}
if (GraphEditor.can_drag_node && GraphEditor.hover_node)
{
GraphEditor.is_drag = true;
GraphEditor.can_drag_port = false;
GraphEditor.drag_node = GraphEditor.hover_node;
}
}
// ...
if (GraphEditor.is_drag)
{
if (GraphEditor.drag_node)
{
foreach (Node node in GraphEditor.selection)
{
node.position += delta;
}
}
}
else
{
if (GraphEditor.can_select)
{
GraphEditor.is_select = true;
}
}
break;
case 1:
GraphEditor.is_drag = true;
GraphEditor.is_scrolling = true;
GraphEditor.scroll += delta;
break;
case 2:
GraphEditor.is_drag = true;
GraphEditor.is_scrolling = true;
GraphEditor.scroll += delta;
break;
}
break;
case EventType.ScrollWheel:
if (!GraphEditor.is_drag)
{
float zoom_delta = 0.1f;
zoom_delta = current.delta.y < 0.0f ? zoom_delta : -zoom_delta;
target_zoom += zoom_delta;
target_zoom = Mathf.Clamp(target_zoom, 0.2f, 1.0f);
}
break;
case EventType.ValidateCommand:
switch (Event.current.commandName)
{
case ("Delete"):
DeleteSelectedNodes();
current.Use();
break;
case ("Duplicate"):
DuplicateSelectedNodes();
current.Use();
break;
case ("SelectAll"):
if (GraphEditor.selection.Count == GraphEditor.graph.nodeCount)
{
ClearSelection();
current.Use();
}
else
{
SelectNodes(GraphEditor.graph.nodes);
current.Use();
}
break;
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (DragAndDrop.objectReferences.Length > 0)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (current.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
GenericMenu generic_menu = new GenericMenu();
Type type;
string type_name;
foreach (UnityObject drag_obj in DragAndDrop.objectReferences)
{
if (drag_obj == null)
{
continue;
}
if (drag_obj is GraphAsset)
{
GraphAsset m_asset = (GraphAsset)drag_obj;
if (m_asset)
{
generic_menu.AddItem(new GUIContent(string.Format("Add {0} as Macro", m_asset.title.IsNullOrEmpty() ? m_asset.name : m_asset.title)), false, (obj) => {
AddMacro(m_asset, (Vector2)obj);
}, GraphEditor.mouse_position - GraphEditor.scroll);
}
}
else if (drag_obj is MonoScript)
{
MonoScript script = (MonoScript)drag_obj;
if (script)
{
type = script.GetClass();
type_name = type.GetTypeName();
generic_menu.AddItem(new GUIContent(string.Format("{0}/Expose {0} members", type_name)), false, (obj) => {
AddCustomNode <ReflectedObjectNode>((Vector2)obj, true, type);
}, GraphEditor.mouse_position - GraphEditor.scroll);
generic_menu.AddSeparator(string.Format("{0}/", type_name));
AddTypeMethodsToMenu(generic_menu, type, type_name);
if (type.IsSubclassOf(typeof(Node)) && !type.IsAbstract && !type.IsGenericType)
{
generic_menu.AddItem(new GUIContent(string.Format("Add {0} as Node", type_name)), false, (obj) => {
AddNode(type, (Vector2)obj);
}, GraphEditor.mouse_position - GraphEditor.scroll);
}
}
}
if (drag_obj is GraphAsset || drag_obj is MonoScript)
{
generic_menu.AddSeparator("");
}
type = drag_obj.GetType();
type_name = type.GetTypeName();
generic_menu.AddItem(new GUIContent(string.Format("Expose {0} members", type_name)), false, (obj) => {
AddCustomNode <ReflectedObjectNode>((Vector2)obj, true, type);
}, GraphEditor.mouse_position - GraphEditor.scroll);
AddTypeMethodsToMenu(generic_menu, type, type_name);
}
DragAndDrop.PrepareStartDrag();
generic_menu.ShowAsContext();
}
}
break;
case (EventType.KeyDown):
switch (current.keyCode)
{
case KeyCode.Space:
if (!current.control)
{
AdvancedSearchWindow.Init(position.size / 2.0f);
current.Use();
}
break;
case KeyCode.Delete:
DeleteSelectedNodes();
current.Use();
break;
case KeyCode.Home:
target_zoom = 1.0f;
GraphEditor.scroll = Vector2.zero;
current.Use();
break;
case KeyCode.PageDown:
GraphEditor.scroll -= new Vector2(0.0f, position.height);
current.Use();
break;
case KeyCode.PageUp:
GraphEditor.scroll += new Vector2(0.0f, position.height);
current.Use();
break;
}
break;
}
}
public NeuronInput(IOutputValue input, double weight)
{
this.input = input;
this.weight = weight;
}
public void addInput(IOutputValue n, double weight)
{
inputs.Add(new NeuronInput(n, weight));
}
