public override void OnClick(Node source, Vector2 mousePosition)
{
FilterAttribute filter = new FilterAttribute();
filter.HideTypes.Add(typeof(void));
filter.MaxMethodParam = int.MaxValue;
filter.SetMember = true;
filter.Public = true;
filter.Instance = true;
filter.Static = false;
filter.DisplayDefaultStaticType = false;
var customItems = ItemSelector.MakeCustomItems(source.ReturnType(), filter, source.ReturnType().PrettyName());
if (customItems != null)
{
ItemSelector w = ItemSelector.ShowWindow(source, MemberData.none, filter, delegate(MemberData value) {
value.instance = new MemberData(source, MemberData.TargetType.ValueNode);
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultipurposeNode n) => {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = value;
MemberDataUtility.UpdateMultipurposeMember(n.target);
NodeEditorUtility.AddNewNode(graph.editorData, null, null,
new Vector2(mousePositionOnCanvas.x + n.editorRect.width + 150, mousePositionOnCanvas.y),
(NodeSetValue SV) => {
SV.target = new MemberData(n, MemberData.TargetType.ValueNode);
});
});
graph.Refresh();
}, customItems).ChangePosition(GUIUtility.GUIToScreenPoint(mousePosition));
w.displayDefaultItem = false;
}
}
public override void OnClick(Node source, Vector2 mousePosition)
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (CacheNode n) => {
n.target = MemberData.CreateConnection(source, false);
});
graph.Refresh();
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("Assign to anonymous function");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "Assign to anonymous function");
}
MemberData m = data.member;
NodeEditorUtility.AddNewNode <NodeAnonymousFunction>(graph.editorData, null, null,
new Vector2(source.editorRect.x - 100, source.editorRect.y),
(node) => {
var method = type.GetMethod("Invoke");
if (method != null)
{
node.returnType = new MemberData(method.ReturnType);
foreach (var p in method.GetParameters())
{
node.parameterTypes.Add(new MemberData(p.ParameterType));
}
}
m.CopyFrom(new MemberData(node, MemberData.TargetType.ValueNode));
graph.Refresh();
});
graph.Refresh();
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("Promote to node");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "Promote to node");
}
MemberData m = data.member;
if (data.portType != null && (!m.isAssigned || m.type == null))
{
if (ReflectionUtils.CanCreateInstance(data.portType))
{
m.CopyFrom(new MemberData(ReflectionUtils.CreateInstance(data.portType)));
}
else
{
m.CopyFrom(MemberData.CreateFromValue(null, data.portType));
}
}
NodeEditorUtility.AddNewNode <MultipurposeNode>(graph.editorData, null, null, new Vector2(source.editorRect.x - 100, source.editorRect.y), (node) => {
node.target.target = new MemberData(m);
MemberDataUtility.UpdateMultipurposeMember(node.target);
m.CopyFrom(new MemberData(node, MemberData.TargetType.ValueNode));
});
graph.Refresh();
}
public override void OnClick(Node source, Vector2 mousePosition)
{
var type = source.ReturnType();
if (type.IsSubclassOf(typeof(System.MulticastDelegate)))
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(EventHook n) {
n.target = new MemberData(source, MemberData.TargetType.ValueNode);
});
}
else
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(NodeSetValue n) {
n.target = new MemberData(source, MemberData.TargetType.ValueNode);
if (type.IsSubclassOf(typeof(System.MulticastDelegate)))
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(NodeLambda node) {
n.value = new MemberData(node, MemberData.TargetType.ValueNode);
n.setType = SetType.Add;
node.delegateType = MemberData.CreateFromType(type);
});
}
else if (ReflectionUtils.CanCreateInstance(type))
{
n.value = new MemberData(ReflectionUtils.CreateInstance(type), MemberData.TargetType.Values);
}
});
}
graph.Refresh();
}
public override void OnClick(Vector2 mousePosition)
{
NodeEditorUtility.AddNewNode <MacroPortNode>(graph.editorData, null, null, mousePositionOnCanvas, (node) => {
node.gameObject.name = "flow" + Random.Range(0, 255);
node.kind = PortKind.FlowInput;
});
graph.Refresh();
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(MacroPortNode n) {
data.member.CopyFrom(MemberData.CreateConnection(n, true));
n.gameObject.name = data.portName;
n.kind = uNode.PortKind.FlowOutput;
n.editorRect = source.editorRect;
n.editorRect.y += source.editorRect.height + 100;
});
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(MacroPortNode n) {
data.member.CopyFrom(MemberData.CreateConnection(n, false));
n.type = new MemberData(data.portType);
n.gameObject.name = data.portName;
n.kind = uNode.PortKind.ValueInput;
n.editorRect = source.editorRect;
n.editorRect.x -= 100;
});
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(MacroPortNode n) {
n.type = new MemberData(data.portType);
n.target = data.getConnection();
n.gameObject.name = data.portName;
n.kind = uNode.PortKind.ValueOutput;
n.editorRect = source.editorRect;
n.editorRect.x += source.editorRect.width + 100;
});
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(MacroPortNode n) {
n.target = data.getConnection();
n.gameObject.name = data.portName;
n.kind = uNode.PortKind.FlowInput;
n.editorRect = source.editorRect;
n.editorRect.y -= 100;
});
graph.Refresh();
}
public override void OnClick(Node source, Vector2 mousePosition)
{
ComparisonNode node = source as ComparisonNode;
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (ConditionNode n) => {
n.Condition.AddBlockRange(BlockUtility.GetConditionBlockFromNode(source));
n.editorRect = node.editorRect;
RefactorUtility.RetargetNode(node, n);
});
NodeEditorUtility.RemoveNode(graph.editorData, node);
graph.Refresh();
}
public override void OnClick(Node source, Vector2 mousePosition)
{
ORNode node = source as ORNode;
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultiORNode n) => {
n.targets[0] = node.targetA;
n.targets[1] = node.targetB;
n.editorRect = node.editorRect;
RefactorUtility.RetargetValueNode(node, n);
});
NodeEditorUtility.RemoveNode(graph.editorData, node);
graph.Refresh();
}
public override void OnClick(Node source, Vector2 mousePosition)
{
MultipurposeNode node = source as MultipurposeNode;
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (NodeAction n) => {
n.Action.AddBlockRange(BlockUtility.GetActionBlockFromNode(source));
n.onFinished = node.onFinished;
n.editorRect = node.editorRect;
RefactorUtility.RetargetNode(node, n);
});
NodeEditorUtility.RemoveNode(graph.editorData, node);
graph.Refresh();
}
public virtual Node Setup(Vector2 mousePosition)
{
Node node = null;
NodeEditorUtility.AddNewNode <T>(
graph.editorData,
mousePosition,
(n) => {
OnNodeCreated(n);
node = n;
graph.Refresh();
});
return(node);
}
public override Node CreateNode()
{
Node node = leftNode;
NodeEditorUtility.AddNewNode <MakeArrayNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.elementType = new MemberData(rightType.GetElementType());
nod.values[0] = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
return(node);
}
public override IList <ItemSelector.CustomItem> GetItems(Node source, MemberData data, System.Type type)
{
var items = new List <ItemSelector.CustomItem>();
items.Add(new ItemSelector.CustomItem("IF", () => {
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (NodeIf n) => {
n.condition = data;
graph.Refresh();
});
}, "Flows")
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon))
});
return(items);
}
public override Node CreateNode()
{
Node node = leftNode;
NodeEditorUtility.AddNewNode <ASNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.compactDisplay = true;
nod.type = new MemberData(rightType);
nod.target = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
return(node);
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("To value node");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "To value node");
}
var member = data.member;
NodeEditorUtility.AddNewNode <MultipurposeNode>(graph.editorData, null, null, new Vector2(source.editorRect.x - 100, source.editorRect.y), (node) => {
node.target.target = MemberData.CreateFromValue(ReflectionUtils.CreateInstance(filter.Types[0]), filter.Types[0]);
MemberDataUtility.UpdateMultipurposeMember(node.target);
member.CopyFrom(MemberData.CreateConnection(node, false));
});
graph.Refresh();
}
public override Node CreateNode()
{
Node node = leftNode;
if (rightType.IsCastableTo(typeof(Vector3)))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(typeof(Quaternion).GetProperty("eulerAngles"));
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
return(node);
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("Assign to lambda");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "Assign to lambda");
}
MemberData m = data.member;
NodeEditorUtility.AddNewNode <NodeLambda>(graph.editorData, null, null,
new Vector2(source.editorRect.x - 100, source.editorRect.y),
(node) => {
node.delegateType = MemberData.CreateFromType(type);
m.CopyFrom(new MemberData(node, MemberData.TargetType.ValueNode));
graph.Refresh();
});
graph.Refresh();
}
public override void OnClick(Node source, Vector2 mousePosition)
{
NodeIf node = source as NodeIf;
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (NodeValidation n) => {
var action = new EqualityCompare();
action.target = new MultipurposeMember(node.condition);
action.value = new MemberData(true);
n.Validation.AddBlock(action, EventActionData.EventType.Event);
n.onTrue = node.onTrue;
n.onFalse = node.onFalse;
n.onFinished = node.onFinished;
n.editorRect = node.editorRect;
RefactorUtility.RetargetNode(node, n);
});
NodeEditorUtility.RemoveNode(graph.editorData, node);
graph.Refresh();
}
public override Node CreateNode()
{
Node node = leftNode;
if (rightType == typeof(Quaternion))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
typeof(Quaternion).GetMethod("Euler", new Type[] { typeof(Vector3) })
);
nod.target.parameters = new MemberData[] {
new MemberData(node, MemberData.TargetType.ValueNode)
};
node = nod;
});
}
return(node);
}
private ItemSelector.CustomItem GetItem(Type type, Type param1, Type param2, Type returnType, MemberData data, ComparisonType operatorType)
{
return(new ItemSelector.CustomItem(string.Format(operatorType.ToString() + " ({0}, {1})", param1.PrettyName(), param2.PrettyName()), () => {
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (ComparisonNode n) => {
if (param1.IsCastableTo(type))
{
n.targetA = data;
n.targetB = new MemberData(ReflectionUtils.CreateInstance(param1));
}
else
{
n.targetA = new MemberData(ReflectionUtils.CreateInstance(param2));
n.targetB = data;
}
n.operatorType = operatorType;
graph.Refresh();
});
}, "Operator")
{
icon = uNodeEditorUtility.GetTypeIcon(returnType)
});
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("Assign to contructor node");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "Assign to contructor node");
}
var member = data.member;
NodeEditorUtility.AddNewNode <MultipurposeNode>(graph.editorData, null, null, new Vector2(source.editorRect.x - 100, source.editorRect.y), (node) => {
var type = filter.GetActualType();
var ctors = type.GetConstructors();
if (ctors != null && ctors.Length > 0)
{
System.Reflection.ConstructorInfo ctor = null;
foreach (var c in ctors)
{
if (ctor == null)
{
ctor = c;
}
else if (ctor.GetParameters().Length < c.GetParameters().Length)
{
ctor = c;
}
}
node.target.target = new MemberData(ctor);
}
else
{
node.target.target = new MemberData(type.Name + ".ctor", type, MemberData.TargetType.Constructor);
}
MemberDataUtility.UpdateMultipurposeMember(node.target);
member.CopyFrom(new MemberData(node, MemberData.TargetType.ValueNode));
});
graph.Refresh();
}
public void ShowNodeMenu(Vector2 position, FilterAttribute filter = null, Action <Node> onAddNode = null, bool flowNodes = true)
{
var valueMenuPos = GetMenuPosition();
if (filter == null)
{
filter = new FilterAttribute();
//filter.CanSelectType = true;
//filter.HideTypes.Add(typeof(void));
}
else
{
filter = new FilterAttribute(filter);
}
filter.DisplayInstanceOnStatic = true;
filter.MaxMethodParam = int.MaxValue;
filter.Public = true;
filter.Instance = true;
if (flowNodes)
{
filter.VoidType = true;
}
ItemSelector w = ItemSelector.ShowWindow(editorData.selectedGroup ?? editorData.selectedRoot as UnityEngine.Object ?? editorData.graph, new MemberData(editorData.selectedGroup ?? editorData.selectedRoot as UnityEngine.Object ?? editorData.graph, MemberData.TargetType.SelfTarget), filter, delegate(MemberData value) {
NodeEditorUtility.AddNewNode <MultipurposeNode>(editorData, null, null, position, delegate(MultipurposeNode n) {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = value;
MemberDataUtility.UpdateMultipurposeMember(n.target);
if (onAddNode != null)
{
onAddNode(n);
}
Refresh();
});
}).ChangePosition(valueMenuPos);
w.displayNoneOption = false;
w.displayCustomVariable = false;
if (filter.SetMember)
{
return; //Return on set member is true.
}
List <ItemSelector.CustomItem> customItems = new List <ItemSelector.CustomItem>();
foreach (NodeMenu menuItem in NodeEditorUtility.FindNodeMenu())
{
if (filter.OnlyGetType && menuItem.type != typeof(Type))
{
continue;
}
bool isFlowNode = !menuItem.type.IsSubclassOf(typeof(ValueNode));
if (editorData.selectedRoot && menuItem.HideOnFlow || !flowNodes && isFlowNode)
{
continue;
}
if (isFlowNode && filter.SetMember || !filter.IsValidTarget(MemberData.TargetType.FlowNode))
{
continue;
}
if (!isFlowNode && !filter.IsValidTarget(MemberData.TargetType.ValueNode))
{
continue;
}
if (editorData.selectedGroup && (menuItem.HideOnGroup))
{
continue;
}
if (menuItem.HideOnStateMachine && !editorData.selectedRoot && !editorData.selectedGroup)
{
continue;
}
if (menuItem.returnType != null && menuItem.returnType != typeof(object) && !filter.IsValidType(menuItem.returnType))
{
continue;
}
if (menuItem.IsCoroutine && !editorData.supportCoroutine)
{
continue;
}
customItems.Add(new ItemSelector.CustomItem(menuItem.name, delegate() {
NodeEditorUtility.AddNewNode <Node>(editorData, menuItem.name.Split(' ')[0], menuItem.type, position, onAddNode);
Refresh();
}, menuItem.category.Replace("/", "."))
{
icon = isFlowNode ? uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)) : null,
tooltip = new GUIContent(menuItem.tooltip),
});
}
#region Flow
if (flowNodes && !filter.SetMember && filter.IsValidType(typeof(void)))
{
if (!(!editorData.selectedRoot && !editorData.selectedGroup))
{
customItems.Add(new ItemSelector.CustomItem("Continue", delegate() {
NodeEditorUtility.AddNewNode <NodeJumpStatement>(
editorData,
"Continue",
position,
delegate(NodeJumpStatement n) {
n.statementType = JumpStatementType.Continue;
});
Refresh();
}, "JumpStatement")
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)),
});
customItems.Add(new ItemSelector.CustomItem("Break", delegate() {
NodeEditorUtility.AddNewNode <NodeJumpStatement>(
editorData,
"Break",
position,
delegate(NodeJumpStatement n) {
n.statementType = JumpStatementType.Break;
});
Refresh();
}, "JumpStatement")
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)),
});
}
if (editorData.selectedRoot)
{
customItems.Add(new ItemSelector.CustomItem("Return", delegate() {
NodeEditorUtility.AddNewNode <NodeReturn>(
editorData,
"Return",
position,
delegate(NodeReturn n) {
});
Refresh();
}, "Return")
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)),
});
}
}
#endregion
if (filter.IsValidTarget(MemberData.TargetType.ValueNode))
{
if (filter.IsValidType(typeof(Type)))
{
customItems.Add(new ItemSelector.CustomItem("typeof()", delegate() {
var win = TypeSelectorWindow.ShowWindow(Vector2.zero, new FilterAttribute()
{
OnlyGetType = true, DisplayRuntimeType = false
}, delegate(MemberData[] types) {
NodeEditorUtility.AddNewNode <MultipurposeNode>(
editorData,
position,
delegate(MultipurposeNode n) {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = types[0];
if (onAddNode != null)
{
onAddNode(n);
}
Refresh();
});
});
win.targetObject = editorData.selectedGroup ?? editorData.selectedRoot as UnityEngine.Object ?? editorData.graph;
win.ChangePosition(valueMenuPos);
}, "Data"));
}
var nodeMenuItems = NodeEditorUtility.FindCreateNodeCommands();
foreach (var n in nodeMenuItems)
{
n.graph = this;
n.filter = filter;
if (!n.IsValid())
{
continue;
}
customItems.Add(new ItemSelector.CustomItem(n.name, () => {
var createdNode = n.Setup(position);
if (onAddNode != null)
{
onAddNode(createdNode);
}
}, n.category)
{
icon = uNodeEditorUtility.GetTypeIcon(n.icon),
});
}
}
w.customItems = customItems;
}
public override void OnClick(Node source, Vector2 mousePosition)
{
MacroNode node = source as MacroNode;
string path = EditorUtility.SaveFilePanelInProject("Export to macro asset",
"New Macro.prefab",
"prefab",
"Please enter a file name to save the macro to");
if (path.Length != 0)
{
Undo.RegisterFullObjectHierarchyUndo(node, "");
Undo.RegisterFullObjectHierarchyUndo(node.owner, "");
var tmpMacro = Object.Instantiate(node);
GameObject go = new GameObject("New Macro");
var macro = go.AddComponent <uNodeMacro>();
macro.Variables.AddRange(tmpMacro.Variables);
if (macro.RootObject == null)
{
macro.RootObject = new GameObject("Root");
macro.RootObject.transform.SetParent(macro.transform);
}
var behaviors = tmpMacro.GetComponentsInChildren <MonoBehaviour>(true);
AnalizerUtility.RetargetNodeOwner(tmpMacro.owner, macro, behaviors, (obj) => {
MemberData member = obj as MemberData;
if (member != null && member.targetType == MemberData.TargetType.uNodeVariable && member.GetInstance() as Object == tmpMacro)
{
member.RefactorUnityObject(new Object[] { tmpMacro }, new Object[] { macro });
}
});
for (int i = 0; i < tmpMacro.transform.childCount; i++)
{
tmpMacro.transform.GetChild(i).SetParent(macro.RootObject.transform);
i--;
}
macro.Refresh();
#if UNITY_2018_3_OR_NEWER
GameObject prefab = PrefabUtility.SaveAsPrefabAsset(go, path);
#else
GameObject prefab = PrefabUtility.CreatePrefab(path, go);
#endif
AssetDatabase.SaveAssets();
Object.DestroyImmediate(go);
Object.DestroyImmediate(tmpMacro.gameObject);
var macroAsset = prefab.GetComponent <uNodeMacro>();
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (LinkedMacroNode n) => {
n.macroAsset = macroAsset;
n.editorRect = node.editorRect;
NodeEditorUtility.AddNewObject(graph.editorData.graph, "pins", n.transform, (pin) => {
n.pinObject = pin;
n.Refresh();
RefactorUtility.RetargetNode(node, n);
if (n.inputFlows.Count == node.inputFlows.Count)
{
for (int i = 0; i < n.inputFlows.Count; i++)
{
RefactorUtility.RetargetNode(node.inputFlows[i], n.inputFlows[i]);
}
}
if (n.inputValues.Count == node.inputValues.Count)
{
for (int i = 0; i < n.inputValues.Count; i++)
{
n.inputValues[i].target = new MemberData(node.inputValues[i].target);
}
}
if (n.outputFlows.Count == node.outputFlows.Count)
{
for (int i = 0; i < n.outputFlows.Count; i++)
{
n.outputFlows[i].target = new MemberData(node.outputFlows[i].target);
}
}
if (n.outputValues.Count == node.outputValues.Count)
{
for (int i = 0; i < n.outputValues.Count; i++)
{
RefactorUtility.RetargetNode(node.outputValues[i], n.outputValues[i]);
}
}
});
});
NodeEditorUtility.RemoveNode(graph.editorData, node);
}
graph.Refresh();
}
public override void OnClick(Vector2 mousePosition)
{
NodeEditorUtility.AddNewNode <Nodes.ActivateTransition>(graph.editorData, null, null, mousePositionOnCanvas, null);
graph.Refresh();
}
public override void OnClick(Node source, Vector2 mousePosition)
{
var rType = source.ReturnType();
FilterAttribute filter = new FilterAttribute {
VoidType = true,
MaxMethodParam = int.MaxValue,
Public = true,
Instance = true,
Static = false,
UnityReference = false,
InvalidTargetType = MemberData.TargetType.Null | MemberData.TargetType.Values,
// DisplayDefaultStaticType = false
ValidateMember = (member) => {
if (member is System.Reflection.MethodInfo)
{
var parameters = (member as System.Reflection.MethodInfo).GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
if (rType.IsCastableTo(parameters[i].ParameterType))
{
return(true);
}
}
}
return(false);
},
};
List <ItemSelector.CustomItem> customItems = null;
if (rType.IsCastableTo(typeof(IGraphSystem)) && source is MultipurposeNode)
{
MultipurposeNode multipurposeNode = source as MultipurposeNode;
if (multipurposeNode.target != null && multipurposeNode.target.target != null && (multipurposeNode.target.target.targetType == MemberData.TargetType.SelfTarget || multipurposeNode.target.target.targetType == MemberData.TargetType.Values))
{
var sTarget = multipurposeNode.target.target.startTarget;
if (sTarget is IGraphSystem)
{
customItems = ItemSelector.MakeCustomItems(sTarget as Object);
customItems.AddRange(ItemSelector.MakeCustomItems(typeof(uNodeRoot), sTarget, filter, "Inherit Member"));
}
}
}
bool flag = false;
if (customItems == null)
{
if (rType is RuntimeType)
{
customItems = ItemSelector.MakeCustomItems((rType as RuntimeType).GetRuntimeMembers(), filter);
if (rType.BaseType != null)
{
customItems.AddRange(ItemSelector.MakeCustomItems(rType.BaseType, filter, "Inherit Member"));
}
}
else
{
customItems = ItemSelector.MakeCustomItems(rType, filter, " " + rType.PrettyName());
}
var usedNamespaces = source.owner.GetNamespaces().ToHashSet();
if (usedNamespaces != null)
{
customItems.AddRange(ItemSelector.MakeExtensionItems(rType, usedNamespaces, filter, "Extensions"));
flag = true;
}
var customInputItems = NodeEditorUtility.FindCustomInputPortItems();
if (customInputItems != null && customInputItems.Count > 0)
{
var mData = new MemberData(source, MemberData.TargetType.ValueNode);
foreach (var c in customInputItems)
{
c.graph = graph;
c.mousePositionOnCanvas = mousePositionOnCanvas;
if (c.IsValidPort(rType, PortAccessibility.OnlyGet))
{
var items = c.GetItems(source, mData, rType);
if (items != null)
{
customItems.AddRange(items);
}
}
}
}
}
if (customItems != null)
{
filter.Static = false;
customItems.Sort((x, y) => {
if (x.category != y.category)
{
return(string.Compare(x.category, y.category));
}
return(string.Compare(x.name, y.name));
});
ItemSelector w = ItemSelector.ShowWindow(source, MemberData.none, filter, delegate(MemberData value) {
flag = flag && value.targetType == MemberData.TargetType.Method && !rType.IsCastableTo(value.startType);
if (!flag && !value.isStatic)
{
value.instance = new MemberData(source, MemberData.TargetType.ValueNode);
}
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(MultipurposeNode n) {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = value;
MemberDataUtility.UpdateMultipurposeMember(n.target);
if (flag)
{
var pTypes = value.ParameterTypes;
if (pTypes != null)
{
int paramIndex = 0;
MemberData param = null;
for (int i = 0; i < pTypes.Length; i++)
{
var types = pTypes[i];
if (types != null)
{
for (int y = 0; y < types.Length; y++)
{
if (rType.IsCastableTo(types[y]))
{
param = new MemberData(source, MemberData.TargetType.ValueNode);
break;
}
paramIndex++;
}
if (param != null)
{
break;
}
}
}
if (n.target.parameters.Length > paramIndex && param != null)
{
n.target.parameters[paramIndex] = param;
}
}
}
});
graph.Refresh();
}, customItems).ChangePosition(GUIUtility.GUIToScreenPoint(mousePosition));
w.displayRecentItem = false;
w.displayNoneOption = false;
}
}
public override Node CreateNode()
{
Node node = leftNode;
#region RaycastHit2D
if (rightType == typeof(Collider2D))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
typeof(RaycastHit2D).GetProperty("collider")
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType == typeof(Transform))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
typeof(RaycastHit2D).GetProperty("transform")
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType == typeof(Rigidbody2D))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
typeof(RaycastHit2D).GetProperty("rigidbody")
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType == typeof(GameObject))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
new MemberInfo[] {
typeof(RaycastHit2D),
typeof(RaycastHit2D).GetProperty("collider"),
typeof(Collider).GetProperty("gameObject"),
}
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType.IsCastableTo(typeof(Component)))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
new MemberInfo[] {
typeof(RaycastHit2D),
typeof(RaycastHit2D).GetProperty("collider"),
typeof(Collider).GetMethod("GetComponent", Type.EmptyTypes).MakeGenericMethod(rightType),
}
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType == typeof(float))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
typeof(RaycastHit2D).GetProperty("distance")
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType == typeof(Vector3))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
typeof(RaycastHit2D).GetProperty("point")
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
#endregion
return(node);
}
public override Node CreateNode()
{
Node node = leftNode;
if (leftType == typeof(Transform))
{
if (rightType == typeof(Vector3))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(typeof(Transform).GetProperty("position"));
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
return(node);
}
else if (rightType == typeof(Quaternion))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(typeof(Transform).GetProperty("rotation"));
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
return(node);
}
}
if (rightType == typeof(GameObject))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(typeof(Component).GetProperty("gameObject"));
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType == typeof(Transform))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(typeof(Component).GetProperty("transform"));
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
else if (rightType.IsCastableTo(typeof(Component)))
{
NodeEditorUtility.AddNewNode <MultipurposeNode>(
NodeGraph.openedGraph.editorData,
new Vector2(rightNode.editorRect.x - 250, rightNode.editorRect.y),
(nod) => {
nod.target.target = new MemberData(
typeof(Component).GetMethod("GetComponent", Type.EmptyTypes).MakeGenericMethod(rightType)
);
nod.target.target.instance = new MemberData(node, MemberData.TargetType.ValueNode);
node = nod;
});
}
return(node);
}
