public override Object CreateAsset()
{
var graph = CreateClassAsset();
var data = graph.gameObject.AddComponent <uNodeData>();
data.Namespace = graphNamespaces;
data.generatorSettings.usingNamespace = graphUsingNamespaces.ToArray();
CreateOverrideMembers(graph);
graph.Attributes = new AttributeData[] {
new AttributeData()
{
type = MemberData.CreateFromType(typeof(CustomEditor)),
value = new ValueData()
{
typeData = MemberData.CreateFromType(typeof(CustomEditor)),
value = new ConstructorValueData()
{
typeData = MemberData.CreateFromType(typeof(CustomEditor)),
parameters = new[] {
new ParameterValueData()
{
name = "inspectedType",
typeData = MemberData.CreateFromType(typeof(Type)),
value = editorType.Get <Type>()
}
}
},
},
}
};
return(graph);
}
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 ConstructorValueData(System.Reflection.ConstructorInfo ctor)
{
serializedType = new MemberData(ctor.DeclaringType);
System.Reflection.ParameterInfo[] param = ctor.GetParameters();
parameters = new ParameterValueData[param.Length];
for (int i = 0; i < param.Length; i++)
{
parameters[i] = new ParameterValueData()
{
name = param[i].Name,
typeData = MemberData.CreateFromType(param[i].ParameterType)
};
}
}
public CustomEditorCreator()
{
graphInheritFrom = MemberData.CreateFromType(typeof(Editor));
graphInheritFilter.Types.Add(typeof(Editor));
graphUsingNamespaces = new List <string>()
{
"UnityEngine",
"UnityEditor",
"System.Collections.Generic",
};
graphOverrideMembers = new List <MemberInfo>()
{
typeof(Editor).GetMethod(nameof(Editor.OnInspectorGUI))
};
}
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 MonobehaviourScriptCreator()
{
graphInheritFrom = MemberData.CreateFromType(typeof(MonoBehaviour));
graphInheritFilter.Types.Add(typeof(MonoBehaviour));
}
protected void CreateOverrideMembers(uNodeRoot graph)
{
foreach (var member in graphOverrideMembers)
{
if (member is MethodInfo method)
{
var func = CreateComponent <uNodeFunction>(method.Name, GetRootTransfrom(graph), (val) => {
val.Name = method.Name;
val.returnType = MemberData.CreateFromType(method.ReturnType);
val.parameters = method.GetParameters().Select(p => new ParameterData(p.Name, p.ParameterType)
{
value = p.DefaultValue
}).ToArray();
val.genericParameters = method.GetGenericArguments().Select(p => new GenericParameterData(p.Name)).ToArray();
});
CreateComponent <Nodes.NodeAction>("Entry", func, node => {
func.startNode = node;
});
}
else if (member is PropertyInfo property)
{
var prop = CreateComponent <uNodeProperty>(property.Name, GetRootTransfrom(graph), (val) => {
val.Name = property.Name;
val.type = MemberData.CreateFromType(property.PropertyType);
});
var getMethod = property.GetGetMethod(true);
var setMethod = property.GetSetMethod(true);
if (getMethod != null)
{
var func = CreateComponent <uNodeFunction>("Getter", GetRootTransfrom(graph), (val) => {
val.Name = getMethod.Name;
val.returnType = MemberData.CreateFromType(getMethod.ReturnType);
val.parameters = getMethod.GetParameters().Select(p => new ParameterData(p.Name, p.ParameterType)
{
value = p.DefaultValue
}).ToArray();
val.genericParameters = getMethod.GetGenericArguments().Select(p => new GenericParameterData(p.Name)).ToArray();
});
CreateComponent <Nodes.NodeAction>("Entry", func, node => {
func.startNode = node;
CreateComponent <NodeReturn>("Return", func, returnNode => {
node.onFinished = MemberData.CreateConnection(returnNode, true);
returnNode.returnValue = MemberData.CreateFromValue(null, property.PropertyType);
});
});
prop.getRoot = func;
}
if (setMethod != null)
{
var func = CreateComponent <uNodeFunction>("Setter", GetRootTransfrom(graph), (val) => {
val.Name = setMethod.Name;
val.returnType = MemberData.CreateFromType(setMethod.ReturnType);
val.parameters = setMethod.GetParameters().Select(p => new ParameterData(p.Name, p.ParameterType)
{
value = p.DefaultValue
}).ToArray();
val.genericParameters = setMethod.GetGenericArguments().Select(p => new GenericParameterData(p.Name)).ToArray();
});
CreateComponent <Nodes.NodeAction>("Entry", func, node => {
func.startNode = node;
});
prop.setRoot = func;
}
}
}
}
public static void ShowAddEventMenu(
Vector2 position,
Object instance,
Action <Block> addConditionEvent = null)
{
List <ItemSelector.CustomItem> customItems = new List <ItemSelector.CustomItem>();
var conditions = GetConditionMenus();
foreach (var c in conditions)
{
var type = c.type;
customItems.Add(new ItemSelector.CustomItem(c.name,
delegate() {
if (addConditionEvent != null)
{
Block act;
if (type.IsSubclassOf(typeof(Block)))
{
act = ReflectionUtils.CreateInstance(type) as Block;
}
else if (type.IsCastableTo(typeof(IDataNode <bool>)))
{
act = new HLCondition()
{
type = MemberData.CreateFromType(type)
};
}
else
{
throw new Exception("The type must inherith from Block or IDataNode<bool>");
}
addConditionEvent(act);
}
}, c.category));
}
ItemSelector.SortCustomItems(customItems);
FilterAttribute filter = new FilterAttribute()
{
InvalidTargetType = MemberData.TargetType.Values | MemberData.TargetType.Null,
MaxMethodParam = int.MaxValue,
Instance = true,
VoidType = false,
};
ItemSelector w = ItemSelector.ShowWindow(instance, filter, (member) => {
if (instance != null && !member.isStatic)
{
Type startType = member.startType;
if (startType != null && member.instance == null)
{
if (instance.GetType().IsCastableTo(startType))
{
member.instance = instance;
}
else if (member.IsTargetingUNode)
{
if (member.instance == null)
{
member.instance = instance;
}
}
else if (instance is Component)
{
if (startType == typeof(GameObject))
{
member.instance = (instance as Component).gameObject;
}
else if (startType.IsSubclassOf(typeof(Component)))
{
member.instance = (instance as Component).GetComponent(startType);
}
}
else if (instance is GameObject)
{
if (startType == typeof(GameObject))
{
member.instance = instance as GameObject;
}
else if (startType.IsSubclassOf(typeof(Component)))
{
member.instance = (instance as GameObject).GetComponent(startType);
}
}
if (member.instance == null && ReflectionUtils.CanCreateInstance(startType))
{
member.instance = ReflectionUtils.CreateInstance(startType);
}
}
if (member.instance == null)
{
member.instance = MemberData.none;
}
}
Condition condition = null;
System.Action addCondition = () => {
if (addConditionEvent != null)
{
addConditionEvent(condition);
}
};
switch (member.targetType)
{
case MemberData.TargetType.Constructor:
case MemberData.TargetType.Method: {
GenericMenu menu = new GenericMenu();
if (member.type == typeof(bool))
{
menu.AddItem(new GUIContent("Compare Return Value"), false, () => {
condition = onAddCompareValue(member);
addCondition();
});
}
menu.AddItem(new GUIContent("Equality Compare"), false, () => {
condition = onAddEqualityComparer(member);
addCondition();
});
menu.AddItem(new GUIContent("Is Compare"), false, () => {
condition = onAddIsComparer(member);
addCondition();
});
menu.ShowAsContext();
break;
}
case MemberData.TargetType.Field:
case MemberData.TargetType.Property:
case MemberData.TargetType.uNodeVariable:
case MemberData.TargetType.uNodeProperty:
case MemberData.TargetType.uNodeLocalVariable:
case MemberData.TargetType.uNodeGroupVariable: {
GenericMenu menu = new GenericMenu();
if (member.type == typeof(bool))
{
menu.AddItem(new GUIContent("Compare Return Value"), false, () => {
condition = onAddCompareValue(member);
addCondition();
});
}
menu.AddItem(new GUIContent("Equality Compare"), false, () => {
condition = onAddEqualityComparer(member);
addCondition();
});
menu.AddItem(new GUIContent("Is Compare"), false, () => {
condition = onAddIsComparer(member);
addCondition();
});
menu.ShowAsContext();
break;
}
default:
condition = onAddCompareValue(member);
addCondition();
break;
}
}, false, customItems).ChangePosition(position);
w.displayNoneOption = false;
w.displayCustomVariable = false;
w.customItems = customItems;
}
public static void ShowAddActionMenu(Vector2 position, Action <Events.Action> action, UnityEngine.Object instance, bool acceptCoroutine = false)
{
List <ItemSelector.CustomItem> customItems = new List <ItemSelector.CustomItem>();
var actions = GetActionMenus(acceptCoroutine);
foreach (var a in actions)
{
var type = a.type;
customItems.Add(new ItemSelector.CustomItem(a.name,
delegate() {
Events.Action act;
if (type.IsSubclassOf(typeof(Events.Action)))
{
act = ReflectionUtils.CreateInstance(type) as Events.Action;
}
else
{
act = new HLAction()
{
type = MemberData.CreateFromType(type)
};
}
action(act);
}, a.category));
}
ItemSelector.SortCustomItems(customItems);
FilterAttribute filter = new FilterAttribute()
{
InvalidTargetType = MemberData.TargetType.Values |
MemberData.TargetType.Null |
//MemberData.TargetType.Constructor |
MemberData.TargetType.SelfTarget,
MaxMethodParam = int.MaxValue,
Instance = true,
VoidType = true
};
ItemSelector w = ItemSelector.ShowWindow(instance, filter, (member) => {
if (!(member.instance is UnityEngine.Object) && instance != null && !member.isStatic)
{
Type startType = member.startType;
if (startType != null && member.instance == null)
{
if (instance.GetType().IsCastableTo(startType))
{
member.instance = instance;
}
else if (member.IsTargetingUNode)
{
if (member.instance == null)
{
member.instance = instance;
}
}
else if (instance is Component)
{
if (startType == typeof(GameObject))
{
member.instance = (instance as Component).gameObject;
}
else if (startType.IsSubclassOf(typeof(Component)))
{
member.instance = (instance as Component).GetComponent(startType);
}
}
else if (instance is GameObject)
{
if (startType == typeof(GameObject))
{
member.instance = instance as GameObject;
}
else if (startType.IsSubclassOf(typeof(Component)))
{
member.instance = (instance as GameObject).GetComponent(startType);
}
}
if (member.instance == null && ReflectionUtils.CanCreateInstance(startType))
{
member.instance = ReflectionUtils.CreateInstance(startType);
}
}
if (member.instance == null)
{
member.instance = MemberData.none;
}
}
switch (member.targetType)
{
case MemberData.TargetType.uNodeFunction:
case MemberData.TargetType.Constructor:
case MemberData.TargetType.Method: {
if (member.type != typeof(void))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Invoke"), false, () => {
action(onAddGetAction(member));
});
menu.AddItem(new GUIContent("Compare"), false, () => {
action(onAddCompareAction(member));
});
menu.ShowAsContext();
}
else
{
action(onAddGetAction(member));
}
break;
}
case MemberData.TargetType.Field:
case MemberData.TargetType.Property:
case MemberData.TargetType.uNodeProperty:
case MemberData.TargetType.uNodeVariable:
case MemberData.TargetType.uNodeLocalVariable:
case MemberData.TargetType.uNodeGroupVariable:
case MemberData.TargetType.uNodeParameter: {
GenericMenu menu = new GenericMenu();
var members = member.GetMembers();
if (members == null || members[members.Length - 1] == null || ReflectionUtils.CanGetMember(members[members.Length - 1]))
{
menu.AddItem(new GUIContent("Get"), false, () => {
action(onAddGetAction(member));
});
}
if (members == null || members[members.Length - 1] == null || ReflectionUtils.CanSetMember(members[members.Length - 1]))
{
menu.AddItem(new GUIContent("Set"), false, () => {
action(onAddSetAction(member));
});
}
menu.AddItem(new GUIContent("Compare"), false, () => {
action(onAddCompareAction(member));
});
menu.ShowAsContext();
break;
}
default:
throw new Exception("Unsupported target kind:" + member.targetType);
}
}, false, customItems).ChangePosition(position);
w.displayNoneOption = false;
w.displayCustomVariable = false;
w.customItems = customItems;
}
public ConstructorValueData(object value)
{
if (value == null)
{
throw new System.ArgumentNullException(nameof(value));
}
var type = value.GetType();
var ctors = type.GetConstructors();
if (ctors.Length > 0)
{
var ctor = ctors[0];
for (int i = 0; i < ctors.Length; i++)
{
if (ctors[i].GetParameters().Length == 0)
{
ctor = ctors[i];
break;
}
}
System.Reflection.ParameterInfo[] param = ctor.GetParameters();
parameters = new ParameterValueData[param.Length];
for (int i = 0; i < param.Length; i++)
{
parameters[i] = new ParameterValueData()
{
name = param[i].Name,
typeData = MemberData.CreateFromType(param[i].ParameterType)
};
}
var initializers = new List <ParameterValueData>();
var members = type.GetMembers(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
for (int i = 0; i < members.Length; i++)
{
var member = members[i];
if (member is System.Reflection.FieldInfo field)
{
var val = field.GetValue(value);
initializers.Add(new ParameterValueData()
{
name = field.Name,
typeData = MemberData.CreateFromType(field.FieldType),
value = val
});
}
else if (member is System.Reflection.PropertyInfo property)
{
if (property.CanRead && property.CanWrite)
{
var val = property.GetValue(value);
initializers.Add(new ParameterValueData()
{
name = property.Name,
typeData = MemberData.CreateFromType(property.PropertyType),
value = val
});
}
}
}
}
serializedType = new MemberData(value.GetType());
}
