static void DoLoadDoc() { try { progress = 0; Assembly[] assemblies = EditorReflectionUtility.GetAssemblies(); int index = 0; //EditorUtility.DisplayProgressBar("Loading Documentation", "", progress); //EditorProgressBar.ShowProgressBar("Loading Documentation", progress); foreach (Assembly assembly in assemblies) { try { if (Thread.CurrentThread.ThreadState == ThreadState.AbortRequested) { break; } //if(uNodePreference.GetPreference().assembly.ContainsKey(assembly.GetName().Name)) { XMLFromAssembly(assembly); } Thread.Sleep(1); } catch { continue; } index++; progress = (float)index / (float)assemblies.Length; //EditorProgressBar.ShowProgressBar("Loading Documentation", progress); //EditorUtility.DisplayProgressBar("Loading Documentation", "", progress); } } catch { } //EditorUtility.ClearProgressBar(); hasLoadDoc = true; isLoadDoc = false; }
/// <summary> /// Find command pin menu. /// </summary> /// <returns></returns> public static List <ControlFieldAttribute> FindControlsField() { if (_controlsField == null) { _controlsField = new List <ControlFieldAttribute>(); foreach (System.Reflection.Assembly assembly in EditorReflectionUtility.GetAssemblies()) { foreach (System.Type type in EditorReflectionUtility.GetAssemblyTypes(assembly)) { var atts = type.GetCustomAttributes(typeof(ControlFieldAttribute), true); if (atts.Length > 0) { foreach (var a in atts) { var control = a as ControlFieldAttribute; control.classType = type; _controlsField.Add(control); } } } } _controlsField.Sort((x, y) => Comparer <int> .Default.Compare(x.order, y.order)); } return(_controlsField); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { MemberData variable = PropertyDrawerUtility.GetActualObjectForSerializedProperty <MemberData>(property); FilterAttribute filter = null; if (fieldInfo.IsDefined(typeof(ObjectTypeAttribute), true)) { object pVariable = PropertyDrawerUtility.GetParentObjectFromSerializedProperty <object>(property); var fieldAttributes = fieldInfo.GetCustomAttributes(true); if (pVariable != null && ReflectionUtils.TryCorrectingAttribute(pVariable, ref fieldAttributes)) { filter = ReflectionUtils.GetAttribute <FilterAttribute>(fieldAttributes); } else { return; } } else if (fieldInfo.GetCustomAttributes(typeof(FilterAttribute), false).Length > 0) { filter = (FilterAttribute)fieldInfo.GetCustomAttributes(typeof(FilterAttribute), false)[0]; } if (fieldInfo.GetCustomAttributes(typeof(TooltipAttribute), false).Length > 0) { label.tooltip = ((TooltipAttribute)fieldInfo.GetCustomAttributes(typeof(TooltipAttribute), false)[0]).tooltip; } EditorReflectionUtility.RenderVariable(position, variable, label, property.serializedObject.targetObject, filter); }
public bool HasDeepMember() { if (nextValidation != null) { return(nextValidation()); } return(EditorReflectionUtility.ValidateNextMember(member, FilterAttribute.Default)); }
public static List <HierarchyDrawer> FindHierarchyDrawer() { if (_drawers == null) { _drawers = EditorReflectionUtility.GetListOfType <HierarchyDrawer>(); _drawers.Sort((x, y) => { return(CompareUtility.Compare(x.order, y.order)); }); } return(_drawers); }
public static List <GraphCreator> FindGraphCreators() { if (_graphCreators == null) { _graphCreators = EditorReflectionUtility.GetListOfType <GraphCreator>(); _graphCreators.Sort((x, y) => { return(CompareUtility.Compare(x.menuName, x.order, y.menuName, y.order)); }); } return(_graphCreators); }
/// <summary> /// Get the actual node view type. /// </summary> /// <param name="nodeType"></param> /// <returns></returns> public static Type GetNodeViewTypeFromType(Type nodeType) { if (nodeViewPerType == null) { nodeViewPerType = new Dictionary <Type, Type>(); foreach (var asm in EditorReflectionUtility.GetAssemblies()) { foreach (var type in EditorReflectionUtility.GetAssemblyTypes(asm)) { if (type.IsClass && !type.IsAbstract) { if (type.IsSubclassOf(typeof(UNodeView))) { if (type.GetCustomAttributes(typeof(NodeCustomEditor), true) is NodeCustomEditor[] attrs && attrs.Length > 0) { for (int i = 0; i < attrs.Length; i++) { Type nType = attrs[i].nodeType; nodeViewPerType[nType] = type; } } } } } } } Type oriType = nodeType; Type view = null; while (nodeType != typeof(UNodeView) && nodeType != typeof(object) && nodeType != typeof(BaseNodeView)) { if (nodeViewPerType.TryGetValue(nodeType, out view)) { if (oriType != nodeType) { nodeViewPerType[oriType] = view; } return(view); } else { nodeType = nodeType.BaseType; } } return(view); }
protected void DrawOverrideMembers(string label = "Override Members") { Type type = graphInheritFrom.Get <Type>(); if (type == null) { return; } VariableEditorUtility.DrawCustomList( graphOverrideMembers, label, drawElement: (position, index, element) => { EditorGUI.LabelField(position, NodeBrowser.GetRichMemberName(element)); }, addAction: (pos) => { var members = EditorReflectionUtility.GetOverrideMembers(type); GenericMenu menu = new GenericMenu(); for (int i = 0; i < members.Count; i++) { var member = members[i]; if (member is PropertyInfo) { menu.AddItem(new GUIContent("Properties/" + NodeBrowser.GetRichMemberName(member)), graphOverrideMembers.Contains(member), () => { graphOverrideMembers.Add(member); }); } else { menu.AddItem(new GUIContent("Methods/" + NodeBrowser.GetRichMemberName(member)), graphOverrideMembers.Contains(member), () => { graphOverrideMembers.Add(member); }); } } menu.ShowAsContext(); }, removeAction: (index) => { graphOverrideMembers.RemoveAt(index); } ); }
public static string GetRichMemberName(MemberInfo member) { if (uNodePreference.GetPreference().coloredItem) { Type type = member as Type; if (type != null) { if (type.IsEnum) { return(uNodeUtility.WrapTextWithColor(type.PrettyName(), uNodePreference.GetPreference().itemEnumColor, false)); } else if (type.IsInterface) { return(uNodeUtility.WrapTextWithColor(type.PrettyName(), uNodePreference.GetPreference().itemInterfaceColor, false)); } return(uNodeUtility.WrapTextWithColor(type.PrettyName(), uNodePreference.GetPreference().itemTypeColor, false)); } switch (member.MemberType) { case MemberTypes.Method: return(GetRichMethodName(member as MethodInfo, false)); case MemberTypes.Constructor: return(GetRichConstructorNames(member as ConstructorInfo)); } } switch (member.MemberType) { case MemberTypes.Method: return(EditorReflectionUtility.GetOverloadingMethodNames(member as MethodInfo, false)); case MemberTypes.Constructor: return(EditorReflectionUtility.GetOverloadingConstructorNames(member as ConstructorInfo)); case MemberTypes.TypeInfo: case MemberTypes.NestedType: return((member as Type).PrettyName()); } return(member.Name); }
public static List <FieldDecorator> FindDecorators() { if (_fieldDecorators == null) { _fieldDecorators = new List <FieldDecorator>(); foreach (var assembly in EditorReflectionUtility.GetAssemblies()) { try { foreach (System.Type type in EditorReflectionUtility.GetAssemblyTypes(assembly)) { if (type.IsSubclassOf(typeof(FieldDecorator)) && ReflectionUtils.CanCreateInstance(type)) { var control = ReflectionUtils.CreateInstance(type) as FieldDecorator; _fieldDecorators.Add(control); } } } catch { continue; } } _fieldDecorators.Sort((x, y) => CompareUtility.Compare(x.order, y.order)); } return(_fieldDecorators); }
/// <summary> /// Find all available graph converters /// </summary> /// <returns></returns> public static List <GraphConverter> FindGraphConverters() { if (_graphConverters == null) { _graphConverters = new List <GraphConverter>(); foreach (var assembly in EditorReflectionUtility.GetAssemblies()) { try { foreach (System.Type type in EditorReflectionUtility.GetAssemblyTypes(assembly)) { if (!type.IsAbstract && type.IsSubclassOf(typeof(GraphConverter))) { var converter = System.Activator.CreateInstance(type, true); _graphConverters.Add(converter as GraphConverter); } } } catch { continue; } } _graphConverters.Sort((x, y) => Comparer <int> .Default.Compare(x.order, y.order)); } return(_graphConverters); }
/// <summary> /// Find all graph system attributes. /// </summary> /// <returns></returns> public static List <GraphSystemAttribute> FindGraphSystemAttributes() { if (_graphSystems == null) { _graphSystems = new List <GraphSystemAttribute>(); foreach (var assembly in EditorReflectionUtility.GetAssemblies()) { try { foreach (System.Type type in EditorReflectionUtility.GetAssemblyTypes(assembly)) { if (type.IsDefined(typeof(GraphSystemAttribute), false)) { var menuItem = (GraphSystemAttribute)type.GetCustomAttributes(typeof(GraphSystemAttribute), false)[0]; menuItem.type = type; _graphSystems.Add(menuItem); } } } catch { continue; } } _graphSystems.Sort((x, y) => CompareUtility.Compare(x.menu, x.order, y.menu, y.order)); } return(_graphSystems); }
public override void OnInspectorGUI() { MultiArithmeticNode node = target as MultiArithmeticNode; DrawDefaultInspector(); VariableEditorUtility.DrawMembers(new GUIContent("Targets"), node.targets, node, new FilterAttribute(typeof(object)), (obj) => { node.targets = obj; }, () => { uNodeEditorUtility.RegisterUndo(node); var type = node.ReturnType(); if (type != typeof(object) && ReflectionUtils.CanCreateInstance(type)) { node.targets.Add(new MemberData(ReflectionUtils.CreateInstance(type))); } else if (node.targets.Count > 0) { node.targets.Add(new MemberData(node.targets[node.targets.Count - 1])); } else { node.targets.Add(new MemberData()); } }); if (GUILayout.Button(new GUIContent("Change Operator"))) { var customItems = new List <ItemSelector.CustomItem>(); { //Primitives customItems.AddRange(GetCustomItemForPrimitives(node, typeof(int))); customItems.AddRange(GetCustomItemForPrimitives(node, typeof(float))); } var ns = NodeGraph.GetOpenedGraphUsingNamespaces(); var preference = uNodePreference.GetPreference(); var assemblies = EditorReflectionUtility.GetAssemblies(); var includedAssemblies = uNodePreference.GetIncludedAssemblies(); foreach (var assembly in assemblies) { if (!includedAssemblies.Contains(assembly.GetName().Name)) { continue; } var operators = EditorReflectionUtility.GetOperators(assembly, (op) => { return(ns == null || ns.Contains(op.DeclaringType.Namespace)); }); if (operators.Count > 0) { foreach (var op in operators) { switch (op.Name) { case "op_Addition": { var parameters = op.GetParameters(); customItems.Add(GetCustomItem(node, parameters[0].ParameterType, parameters[1].ParameterType, op.DeclaringType, op.ReturnType, ArithmeticType.Add)); break; } case "op_Subtraction": { var parameters = op.GetParameters(); customItems.Add(GetCustomItem(node, parameters[0].ParameterType, parameters[1].ParameterType, op.DeclaringType, op.ReturnType, ArithmeticType.Subtract)); break; } case "op_Division": { var parameters = op.GetParameters(); customItems.Add(GetCustomItem(node, parameters[0].ParameterType, parameters[1].ParameterType, op.DeclaringType, op.ReturnType, ArithmeticType.Divide)); break; } case "op_Multiply": { var parameters = op.GetParameters(); customItems.Add(GetCustomItem(node, parameters[0].ParameterType, parameters[1].ParameterType, op.DeclaringType, op.ReturnType, ArithmeticType.Multiply)); break; } case "op_Modulus": { var parameters = op.GetParameters(); customItems.Add(GetCustomItem(node, parameters[0].ParameterType, parameters[1].ParameterType, op.DeclaringType, op.ReturnType, ArithmeticType.Modulo)); break; } } } } } customItems.Sort((x, y) => { if (x.category == y.category) { return(string.Compare(x.name, y.name)); } return(string.Compare(x.category, y.category)); }); if (customItems.Count > 0) { ItemSelector.ShowWindow(null, null, null, false, customItems). ChangePosition( GUIUtility.GUIToScreenRect(GUILayoutUtility.GetLastRect()) ).displayDefaultItem = false; } } }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { object variable = PropertyDrawerUtility.GetParentObjectFromSerializedProperty <object>(property); if (variable != null) { if (uNodeGUIUtility.IsHide(fieldInfo, variable)) { return; } } else { if (fieldInfo.IsDefined(typeof(HideAttribute), true)) { HideAttribute[] hide = fieldInfo.GetCustomAttributes(typeof(HideAttribute), true) as HideAttribute[]; foreach (HideAttribute ha in hide) { if (string.IsNullOrEmpty(ha.targetField)) { return; } } } } if (fieldInfo.IsDefined(typeof(TooltipAttribute), true)) { label.tooltip = ((TooltipAttribute)fieldInfo.GetCustomAttributes(typeof(TooltipAttribute), true)[0]).tooltip; } System.Type type = fieldInfo.FieldType; if (fieldInfo.FieldType.IsArray) { type = fieldInfo.FieldType.GetElementType(); } else if (fieldInfo.FieldType.IsGenericType) { System.Type[] gType = fieldInfo.FieldType.GetGenericArguments(); if (gType.Length == 1) { type = gType[0]; } } if (type == typeof(MemberData)) { MemberData obj = PropertyDrawerUtility.GetActualObjectForSerializedProperty <MemberData>(property); FilterAttribute filter = null; if (fieldInfo.GetCustomAttributes(typeof(FilterAttribute), false).Length > 0) { filter = (FilterAttribute)fieldInfo.GetCustomAttributes(typeof(FilterAttribute), false)[0]; } else if (fieldInfo.IsDefined(typeof(ObjectTypeAttribute), true)) { var fieldAttributes = fieldInfo.GetCustomAttributes(true); object pVariable = PropertyDrawerUtility.GetParentObjectFromSerializedProperty <object>(property); if (pVariable != null && ReflectionUtils.TryCorrectingAttribute(pVariable, ref fieldAttributes)) { filter = ReflectionUtils.GetAttribute <FilterAttribute>(fieldAttributes); } else { return; } } EditorReflectionUtility.RenderVariable(position, obj, label, property.serializedObject.targetObject, filter); } else { EditorGUI.PropertyField(position, property, label, true); } }
void Setup() { if (reflectionValue == null) { reflectionValue = MemberData.none; } if (filter == null) { filter = new FilterAttribute() { UnityReference = false, OnlyGetType = onlyGetType }; } if (onlyGetType) { filter = new FilterAttribute(filter) { OnlyGetType = onlyGetType } } ; if (filter.OnlyGetType) { filter.ValidTargetType = MemberData.TargetType.Type | MemberData.TargetType.Null; } if (targetObject) { uNodeRoot UNR = null; if (targetObject is uNodeRoot) { UNR = targetObject as uNodeRoot; } else if (targetObject is RootObject) { UNR = (targetObject as RootObject).owner; } else if (targetObject is NodeComponent) { UNR = (targetObject as NodeComponent).owner; } else if (targetObject is TransitionEvent) { UNR = (targetObject as TransitionEvent).owner; } if (UNR) { uNodeData data = UNR.GetComponent <uNodeData>(); if (data) { //Clear the default namespace usingNamespaces.Clear(); //Add graph namespaces foreach (var n in data.GetNamespaces()) { usingNamespaces.Add(n); } } if (UNR is IIndependentGraph graph) { if (data == null) { //Clear the default namespace usingNamespaces.Clear(); } foreach (var n in graph.UsingNamespaces) { usingNamespaces.Add(n); } } } } editorData.manager = new Manager(new TreeViewState()); editorData.manager.window = this; editorData.searchField = new SearchField(); editorData.searchField.downOrUpArrowKeyPressed += editorData.manager.SetFocusAndEnsureSelectedItem; editorData.searchField.autoSetFocusOnFindCommand = true; window = this; uNodeThreadUtility.Queue(DoSetup); } void DoSetup() { editorData.setup.Setup((progress) => { if (progress == 1) { uNodeThreadUtility.Queue(() => { var categories = new List <TreeViewItem>(); if (displayDefaultItem) { var categoryTree = new SelectorCategoryTreeView("#", "", uNodeEditorUtility.GetUIDFromString("[CATEG]#"), -1); categories.Add(categoryTree); var recentTree = new SelectorCategoryTreeView("Recently", "", uNodeEditorUtility.GetUIDFromString("[CATEG]#Recently"), -1); categories.Add(recentTree); if (displayNoneOption && filter.IsValidTarget(MemberData.TargetType.None)) { categoryTree.AddChild(new SelectorMemberTreeView(MemberData.none, "None", uNodeEditorUtility.GetUIDFromString("#None")) { icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.NullTypeIcon)) as Texture2D }); } if (!filter.SetMember) { if (!filter.IsValueTypes() && filter.IsValidTarget(MemberData.TargetType.Null) && !filter.OnlyGetType) { categoryTree.AddChild(new SelectorMemberTreeView(MemberData.Null, "Null", uNodeEditorUtility.GetUIDFromString("#Null")) { icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.NullTypeIcon)) as Texture2D }); } //if(!filter.OnlyGetType && filter.IsValidTarget(MemberData.TargetType.Values) && // (filter.Types == null || filter.Types.Count != 1 || filter.Types[0] != typeof(Type))) { // categoryTree.AddChild(new SelectorCallbackTreeView((cRect) => { // var screenRect = cRect.ToScreenRect(); // FilterAttribute F = new FilterAttribute(filter); // F.OnlyGetType = true; // ItemSelector w = null; // Action<MemberData> action = delegate (MemberData m) { // if(w != null) { // w.Close(); // //EditorGUIUtility.ExitGUI(); // } // if(filter.CanManipulateArray()) { // if(Event.current.button == 0) { // TypeSelectorWindow.ShowAsNew(Rect.zero, F, delegate (MemberData[] members) { // Type t = members[0].Get<Type>(); // SelectValues(t); // }, m).ChangePosition(screenRect); // } else { // CommandWindow.CreateWindow(screenRect, (items) => { // var member = CompletionEvaluator.CompletionsToMemberData(items); // if(member != null) { // Type t = member.Get<Type>(); // SelectValues(t); // return true; // } // return false; // }, new CompletionEvaluator.CompletionSetting() { // validCompletionKind = CompletionKind.Type | CompletionKind.Namespace | CompletionKind.Keyword, // }); // } // } else { // Type t = m.Get<Type>(); // SelectValues(t); // } // }; // w = ShowAsNew(targetObject, F, action, true).ChangePosition(screenRect); // }, "Values", uNodeEditorUtility.GetUIDFromString("#Values"), -1) { // icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.ValueIcon)) as Texture2D // }); //} } if (displayRecentItem) { var listRecentItems = new List <TreeViewItem>(); if (uNodeEditor.SavedData.recentItems != null) { foreach (var recent in uNodeEditor.SavedData.recentItems) { if (recent != null && recent.info != null) { if (recent.info is Type) { listRecentItems.Add(new TypeTreeView(recent.info as Type, recent.GetHashCode(), -1)); } else if (!filter.OnlyGetType && (recent.isStatic || filter.DisplayInstanceOnStatic)) { listRecentItems.Add(new MemberTreeView(recent.info, recent.GetHashCode(), -1)); } } } } while (listRecentItems.Count > 10) { listRecentItems.RemoveAt(listRecentItems.Count - 1); } if (listRecentItems.Count > 0) { foreach (var item in listRecentItems) { if (item is MemberTreeView) { var tree = item as MemberTreeView; if (!(tree.member is Type)) { tree.displayName = tree.member.DeclaringType.Name + "." + tree.displayName; } } recentTree.AddChild(item); } recentTree.expanded = false; } } if (!filter.OnlyGetType && filter.UnityReference) { if (reflectionValue != null && reflectionValue.GetInstance() != null && !(reflectionValue.GetInstance() is IGraphSystem) && !(reflectionValue.GetInstance() is INode)) { categories.Add(TreeFunction.CreateTargetItem(reflectionValue.GetInstance(), "Target Reference", filter)); } categories.AddRange(TreeFunction.CreateGraphItem(targetObject, reflectionValue, filter)); } if (filter.UnityReference) { categories.AddRange(TreeFunction.CreateRootItem(targetObject, filter)); } categories.AddRange(TreeFunction.CreateCustomItem(customItems)); if (filter.DisplayDefaultStaticType) { categoryTree.AddChild(new SelectorGroupedTreeView(() => { var result = new List <TreeViewItem>(); result.Add(new SelectorSearchTreeView((prog) => { var treeResult = new List <TreeViewItem>(); var sp = new SearchProgress(); prog?.Invoke(sp); var allTypes = GetAllTypes((currProgress) => { prog?.Invoke(currProgress); }, true, true); sp.info = "Setup Items"; for (int i = 0; i < allTypes.Count; i++) { var pair = allTypes[i]; var nsTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[CATEG-SEARCH]" + pair.Key), -1); foreach (var type in pair.Value) { nsTree.AddChild(new TypeTreeView(type, type.GetHashCode(), -1)); } treeResult.Add(nsTree); sp.progress = (float)i / (float)allTypes.Count; prog?.Invoke(sp); } return(treeResult); }, "Search All Types", uNodeEditorUtility.GetUIDFromString("[SAT]"), -1)); var nestedNS = new HashSet <string>(); //var excludedNs = uNodePreference.GetExcludedNamespace(); var namespaces = new List <string>(EditorReflectionUtility.GetNamespaces()); namespaces.Sort(); namespaces.RemoveAll(i => /*excludedNs.Contains(i) ||*/ i == null || i.Contains(".")); foreach (var ns in namespaces) { result.Add(new NamespaceTreeView(ns, uNodeEditorUtility.GetUIDFromString("[N]" + ns), -1)); } //var nsTypes = GetNamespaceTypes(namespaces); //foreach(var pair in nsTypes) { // var nsTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[Nested-NS]" + pair.Key), -1); // foreach(var ns in nestedNS) { // if(ns.StartsWith(pair.Key)) { // nsTree.AddChild(new NamespaceTreeView(ns, uNodeEditorUtility.GetUIDFromString("[N]" + ns), -1)); // } // } // foreach(var type in pair.Value) { // nsTree.AddChild(new TypeTreeView(type, type.GetHashCode(), -1)); // } // //nsTree.children.Sort((x, y) => string.Compare(x.displayName, y.displayName)); // nsTree.expanded = false; // result.Add(nsTree); //} return(result); }, "All Namespaces", uNodeEditorUtility.GetUIDFromString("[ALL-NS]"), -1) { icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.NamespaceIcon)) as Texture2D }); categoryTree.AddChild(new SelectorGroupedTreeView(() => { var result = new List <TreeViewItem>(); var favorites = uNodeEditor.SavedData.favoriteItems; if (favorites != null) //Favorite Type and Members { var typeTrees = new List <TypeTreeView>(); var memberTrees = new List <MemberTreeView>(); foreach (var fav in favorites) { if (fav.info != null && window.filter.IsValidMember(fav.info)) { if (fav.info is Type type) { typeTrees.Add(new TypeTreeView(type)); } else { var tree = new MemberTreeView(fav.info); tree.displayName = tree.member.DeclaringType.Name + "." + tree.displayName; memberTrees.Add(tree); } } } typeTrees.Sort((x, y) => string.Compare(x.displayName, y.displayName)); memberTrees.Sort((x, y) => string.Compare(x.displayName, y.displayName)); var typeCategory = new SelectorCategoryTreeView("Types", "", uNodeEditorUtility.GetUIDFromString("[TYPES]"), -1); foreach (var tree in typeTrees) { typeCategory.AddChild(tree); } var memberCategory = new SelectorCategoryTreeView("Members", "", uNodeEditorUtility.GetUIDFromString("[MEMBERS]"), -1); foreach (var tree in memberTrees) { memberCategory.AddChild(tree); } if (typeCategory.hasChildren) { result.Add(typeCategory); } if (memberCategory.hasChildren) { result.Add(memberCategory); } } { //Favorite Namespaces var nsTrees = new List <NamespaceTreeView>(); foreach (var fav in uNodeEditor.SavedData.favoriteNamespaces) { nsTrees.Add(new NamespaceTreeView(fav, uNodeEditorUtility.GetUIDFromString("[NS-FAV]" + fav), -1)); } nsTrees.Sort((x, y) => string.Compare(x.displayName, y.displayName)); var nsCategory = new SelectorCategoryTreeView("Namespaces", "", uNodeEditorUtility.GetUIDFromString("[NS]"), -1); foreach (var tree in nsTrees) { nsCategory.AddChild(tree); } if (nsCategory.hasChildren) { result.Add(nsCategory); } } return(result); }, "Favorites", uNodeEditorUtility.GetUIDFromString("[fav]"), -1) { icon = uNodeGUIUtility.Styles.favoriteIconOn }); var namespaceTrees = new SelectorCategoryTreeView("Types", "", uNodeEditorUtility.GetUIDFromString("[NS]"), -1); if (displayGeneralType) { var categTree = new SelectorCategoryTreeView("General", "", uNodeEditorUtility.GetUIDFromString("[GENERAL]"), -1); var items = TreeFunction.GetGeneralTrees(); items.ForEach(tree => categTree.AddChild(tree)); namespaceTrees.AddChild(categTree); } if (filter.DisplayRuntimeType) { var runtimeItems = TreeFunction.GetRuntimeItems(); var runtimeTypes = new Dictionary <string, List <TypeTreeView> >(); foreach (var item in runtimeItems) { var ns = item.type.Namespace; if (string.IsNullOrEmpty(ns) || ns == RuntimeType.RuntimeNamespace) { ns = "Generated Type"; } List <TypeTreeView> list; if (!runtimeTypes.TryGetValue(ns, out list)) { list = new List <TypeTreeView>(); runtimeTypes[ns] = list; } list.Add(item); } foreach (var pair in runtimeTypes) { var categTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[RT]" + pair.Key), -1); var items = pair.Value; items.ForEach(tree => categTree.AddChild(tree)); namespaceTrees.AddChild(categTree); } } var typeList = editorData.setup.typeList; foreach (var pair in typeList) { var nsTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[CATEG]" + pair.Key), -1); foreach (var type in pair.Value) { nsTree.AddChild(new TypeTreeView(type, type.GetHashCode(), -1)); } namespaceTrees.AddChild(nsTree); } categories.Add(namespaceTrees); } }
public static Assembly CompileFromFile(params string[] files) { var csharpParserType = EditorBinding.csharpParserType; if (csharpParserType != null) { //var method = csharpParserType.GetMethod("CompileScript", new Type[] { typeof(IEnumerable<string>) }); //if(method != null) { // List<string> scripts = new List<string>(); // foreach(var file in files) { // scripts.Add(File.ReadAllText(file)); // } // var compileResult = method.Invoke(null, new object[] { scripts as IEnumerable<string> }) as CompileResult; // if(compileResult.assembly == null) { // //compileResult.LogErrors(); // throw new Exception(compileResult.GetErrorMessage()); // } // return compileResult.assembly; //} var method = csharpParserType.GetMethod("CompileFiles", new Type[] { typeof(IEnumerable <string>) }); if (method != null) { var compileResult = method.Invoke(null, new object[] { files as IEnumerable <string> }) as CompileResult; if (compileResult.assembly == null) { //compileResult.LogErrors(); throw new Exception(compileResult.GetErrorMessage()); } return(compileResult.assembly); } } #if !NET_STANDARD_2_0 var provider = new Microsoft.CSharp.CSharpCodeProvider(); var param = new System.CodeDom.Compiler.CompilerParameters(); foreach (var assembly in EditorReflectionUtility.GetAssemblies()) { try { if (!string.IsNullOrEmpty(assembly.Location)) { param.ReferencedAssemblies.Add(assembly.Location); } } catch { continue; } } // Generate a dll in memory param.GenerateExecutable = false; param.GenerateInMemory = true; param.TreatWarningsAsErrors = false; param.IncludeDebugInformation = true; //No Waring //param.WarningLevel = 0; // Compile the source var result = provider.CompileAssemblyFromFile(param, files); if (result.Errors.Count > 0) { var msg = new System.Text.StringBuilder(); bool hasError = false; foreach (System.CodeDom.Compiler.CompilerError error in result.Errors) { //Debug.LogError("Error (" + error.ErrorNumber + "): " + error.ErrorText + "\n"); if (error.IsWarning) { Debug.LogWarningFormat("Warning ({0}): {1}\nin line: {2}", error.ErrorNumber, error.ErrorText, error.Line); } else { hasError = true; msg.AppendFormat("Error ({0}): {1}\nin line: {2}:{3}\nin file:{4}\n", error.ErrorNumber, error.ErrorText, error.Line, error.Column, error.FileName); } } if (hasError) { throw new Exception(msg.ToString()); } } // Return the assembly return(result.CompiledAssembly); #else Debug.Log("Compiling script is disable due to unsupported in .NET Standard 2.0, change API compativility level to .NET 4.x to enable it or import CSharp Parser add-ons to compile with Roslyn instead."); return(null); #endif }
public static CompileResult CompileScript(params string[] source) { var csharpParserType = EditorBinding.csharpParserType; if (csharpParserType != null) { var method = csharpParserType.GetMethod("CompileScript", new Type[] { typeof(IEnumerable <string>) }); if (method != null) { return(method.Invoke(null, new object[] { source as IEnumerable <string> }) as CompileResult); } } #if !NET_STANDARD_2_0 var provider = new Microsoft.CSharp.CSharpCodeProvider(); var param = new System.CodeDom.Compiler.CompilerParameters(); foreach (var assembly in EditorReflectionUtility.GetAssemblies()) { try { if (!string.IsNullOrEmpty(assembly.Location)) { param.ReferencedAssemblies.Add(assembly.Location); } } catch { continue; } } // Generate a dll in memory param.GenerateExecutable = false; param.GenerateInMemory = true; param.TreatWarningsAsErrors = false; param.IncludeDebugInformation = true; Directory.CreateDirectory(tempGeneratedFolder); param.TempFiles = new System.CodeDom.Compiler.TempFileCollection(tempGeneratedFolder, true); //No Waring //param.WarningLevel = 0; // Compile the source var result = provider.CompileAssemblyFromSource(param, source); List <CompileResult.CompileError> compileErrors = new List <CompileResult.CompileError>(); if (result.Errors.Count > 0) { foreach (System.CodeDom.Compiler.CompilerError error in result.Errors) { compileErrors.Add(new CompileResult.CompileError() { fileName = error.FileName, isWarning = error.IsWarning, errorText = error.ErrorText, errorNumber = error.ErrorNumber, errorLine = error.Line, errorColumn = error.Column, }); } } // Return the assembly return(new CompileResult() { assembly = result.CompiledAssembly, errors = compileErrors, }); #else Debug.Log("Compiling script is disable due to unsupported in .NET Standard 2.0, change API compativility level to .NET 4.x to enable it or import CSharp Parser add-ons to compile with Roslyn instead."); return(new CompileResult()); #endif }
public override IList <ItemSelector.CustomItem> GetItems(Node source, MemberData data, System.Type type) { var items = new List <ItemSelector.CustomItem>(); if (type.IsPrimitive && type != typeof(bool) && type != typeof(char)) { string typeName = type.PrettyName(); items.Add(new ItemSelector.CustomItem(string.Format("Add ({0}, {0})", typeName), () => { NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultiArithmeticNode n) => { n.targets[0] = data; n.targets[1] = new MemberData(ReflectionUtils.CreateInstance(type)); n.operatorType = ArithmeticType.Add; graph.Refresh(); }); }, "Operator") { icon = uNodeEditorUtility.GetTypeIcon(type) }); items.Add(new ItemSelector.CustomItem(string.Format("Subtract ({0}, {0})", typeName), () => { NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultiArithmeticNode n) => { n.targets[0] = data; n.targets[1] = new MemberData(ReflectionUtils.CreateInstance(type)); n.operatorType = ArithmeticType.Subtract; graph.Refresh(); }); }, "Operator") { icon = uNodeEditorUtility.GetTypeIcon(type) }); items.Add(new ItemSelector.CustomItem(string.Format("Divide ({0}, {0})", typeName), () => { NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultiArithmeticNode n) => { n.targets[0] = data; n.targets[1] = new MemberData(ReflectionUtils.CreateInstance(type)); n.operatorType = ArithmeticType.Divide; graph.Refresh(); }); }, "Operator") { icon = uNodeEditorUtility.GetTypeIcon(type) }); items.Add(new ItemSelector.CustomItem(string.Format("Multiply ({0}, {0})", typeName), () => { NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultiArithmeticNode n) => { n.targets[0] = data; n.targets[1] = new MemberData(ReflectionUtils.CreateInstance(type)); n.operatorType = ArithmeticType.Multiply; graph.Refresh(); }); }, "Operator") { icon = uNodeEditorUtility.GetTypeIcon(type) }); items.Add(new ItemSelector.CustomItem(string.Format("Modulo ({0}, {0})", typeName), () => { NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultiArithmeticNode n) => { n.targets[0] = data; n.targets[1] = new MemberData(ReflectionUtils.CreateInstance(type)); n.operatorType = ArithmeticType.Modulo; graph.Refresh(); }); }, "Operator") { icon = uNodeEditorUtility.GetTypeIcon(type) }); } var preference = uNodePreference.GetPreference(); var assemblies = EditorReflectionUtility.GetAssemblies(); var includedAssemblies = uNodePreference.GetIncludedAssemblies(); var ns = graph.editorData.GetNamespaces(); foreach (var assembly in assemblies) { if (!includedAssemblies.Contains(assembly.GetName().Name)) { continue; } var operators = EditorReflectionUtility.GetOperators(assembly, (op) => { return(ns.Contains(op.DeclaringType.Namespace)); }); if (operators.Count > 0) { foreach (var op in operators) { switch (op.Name) { case "op_Addition": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ArithmeticType.Add)); break; } case "op_Subtraction": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ArithmeticType.Subtract)); break; } case "op_Division": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ArithmeticType.Divide)); break; } case "op_Multiply": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ArithmeticType.Multiply)); break; } case "op_Modulus": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ArithmeticType.Modulo)); break; } } } } } items.Sort((x, y) => string.Compare(x.name, y.name)); return(items); }
private void ResolveMethodTooltip(MethodBase methodBase, int numOfOverload, List <GUIContent> contents) { if (methodBase is MethodInfo) { contents.Add(new GUIContent( EditorReflectionUtility.GetOverloadingMethodNames(methodBase as MethodInfo), uNodeEditorUtility.GetIcon(methodBase))); } else if (methodBase is ConstructorInfo) { contents.Add(new GUIContent( EditorReflectionUtility.GetOverloadingConstructorNames(methodBase as ConstructorInfo), uNodeEditorUtility.GetIcon(methodBase))); } var mType = ReflectionUtils.GetMemberType(methodBase); #region Docs if (uNodePreference.GetPreference().showDocumentation&& XmlDoc.hasLoadDoc) { XmlElement documentation = XmlDoc.XMLFromMember(methodBase); if (documentation != null) { contents.Add(new GUIContent("Documentation ▼ " + documentation["summary"].InnerText.Trim().AddLineInFirst())); } var parameters = methodBase.GetParameters(); if (parameters.Length > 0) { for (int x = 0; x < parameters.Length; x++) { Type PType = parameters[x].ParameterType; if (PType != null) { contents.Add(new GUIContent(parameters[x].Name + " : " + uNodeUtility.GetDisplayName(PType), uNodeEditorUtility.GetTypeIcon(PType))); if (documentation != null && documentation["param"] != null) { XmlNode paramDoc = null; XmlNode doc = documentation["param"]; while (doc.NextSibling != null) { if (doc.Attributes["name"] != null && doc.Attributes["name"].Value.Equals(parameters[x].Name)) { paramDoc = doc; break; } doc = doc.NextSibling; } if (paramDoc != null && !string.IsNullOrEmpty(paramDoc.InnerText)) { contents.Add(new GUIContent(paramDoc.InnerText.Trim())); } } } } } } #endregion //contents.Add(new GUIContent("Return : " + mType.PrettyName(true), uNodeEditorUtility.GetTypeIcon(mType))); if (numOfOverload > 0) { contents.Add(new GUIContent("▲ " + (overrideIndex + 1).ToString() + " of " + numOfOverload + " ▼")); } }
void InitializeView() { if (data.block == null) { return; } if (data.block is Events.HLAction || data.block is Events.HLCondition) { InitializeHLBlock(data.block); return; } var fields = EditorReflectionUtility.GetFields(data.block.GetType()); if (fields != null && fields.Length > 0) { for (int idx = 0; idx < fields.Length; idx++) { FieldInfo field = fields[idx]; if (uNodeGUIUtility.IsHide(field, data.block)) { continue; } Type type = field.FieldType; if (type == typeof(MemberData)) { MemberData member = field.GetValueOptimized(data.block) as MemberData; object[] fieldAttribute = field.GetCustomAttributes(true); if (!ReflectionUtils.TryCorrectingAttribute(data.block, ref fieldAttribute)) { continue; } var filter = ReflectionUtils.GetAttribute <FilterAttribute>(fieldAttribute); if (member == null) { if (filter != null && !filter.SetMember && !filter.OnlyGetType && ReflectionUtils.CanCreateInstance(filter.GetActualType())) { member = new MemberData(ReflectionUtils.CreateInstance(filter.GetActualType())); } else if (filter != null && !filter.SetMember && !filter.OnlyGetType) { member = MemberData.none; } field.SetValueOptimized(data.block, member); Repaint(); } bool hasDependencies = EditorReflectionUtility.HasFieldDependencies(new string[] { field.Name }, fields); var port = AddPort(new PortData() { getPortName = () => ObjectNames.NicifyVariableName(field.Name), getPortType = () => filter?.GetActualType() ?? typeof(object), getPortValue = () => field.GetValueOptimized(data.block), filter = filter, onValueChanged = (obj) => { RegisterUndo(); member = obj as MemberData; field.SetValueOptimized(data.block, member); Repaint(); if (hasDependencies) { owner.nodeView.MarkRepaint(); } }, }); port.Add(new ControlView(port.portData.InstantiateControl(true), true)); } else if (type == typeof(MultipurposeMember)) { InitMultipurposeMember(field); } else { object fieldVal = field.GetValueOptimized(data.block); object[] fieldAttribute = field.GetCustomAttributes(true); if (!ReflectionUtils.TryCorrectingAttribute(data.block, ref fieldAttribute)) { continue; } bool hasDependencies = EditorReflectionUtility.HasFieldDependencies(new string[] { field.Name }, fields); var filter = ReflectionUtils.GetAttribute <FilterAttribute>(fieldAttribute); ControlConfig config = new ControlConfig() { owner = owner.nodeView, value = fieldVal, type = type, filter = filter, onValueChanged = (obj) => { RegisterUndo(); field.SetValueOptimized(data.block, obj); Repaint(); if (hasDependencies) { owner.nodeView.MarkRepaint(); } }, }; var valueControl = UIElementUtility.CreateControl(type, config, true); AddControl(field.Name, new ControlView(valueControl, true)); if (fieldVal is IList <MemberData> ) { IList <MemberData> members = fieldVal as IList <MemberData>; if (members != null) { for (int i = 0; i < members.Count; i++) { int index = i; var member = members[i]; if (member == null) { if (filter != null && !filter.SetMember && !filter.OnlyGetType && ReflectionUtils.CanCreateInstance(filter.GetActualType())) { member = new MemberData(ReflectionUtils.CreateInstance(filter.GetActualType())); } else { member = MemberData.none; } members[index] = member; field.SetValueOptimized(data.block, members); Repaint(); } var port = AddPort(new PortData() { getPortName = () => "Element " + index.ToString(), getPortType = () => filter?.GetActualType() ?? typeof(object), getPortValue = () => (field.GetValueOptimized(data.block) as IList <MemberData>)[index], filter = filter, onValueChanged = (obj) => { RegisterUndo(); member = obj as MemberData; members[index] = member; field.SetValueOptimized(data.block, members); Repaint(); }, }); port.Add(new ControlView(port.portData.InstantiateControl(true), true)); } } } else if (fieldVal is IList) { IList list = fieldVal as IList; if (list != null) { for (int i = 0; i < list.Count; i++) { int index = i; var element = list[i]; ControlConfig cfg = new ControlConfig() { owner = owner.nodeView, value = fieldVal, type = type, filter = filter, onValueChanged = (obj) => { RegisterUndo(); field.SetValueOptimized(data.block, obj); Repaint(); }, }; var elementControl = UIElementUtility.CreateControl(type, cfg, true); AddControl("Element " + index, new ControlView(elementControl, true)); } } } } } } }
public void Init() { //int typeCount = 0; Dictionary <string, List <Type> > typeMaps = new Dictionary <string, List <Type> >(); var namespaces = uNodePreference.GetBrowserNamespaceList(); var excludedNS = uNodePreference.GetExcludedNamespace(); var excludedTypes = uNodePreference.GetExcludedTypes(); foreach (var assembly in EditorReflectionUtility.GetAssemblies()) { string assemblyName = assembly.GetName().Name; foreach (var type in EditorReflectionUtility.GetAssemblyTypes(assembly)) { if (type.IsNotPublic || !type.IsVisible || type.IsEnum || type.IsInterface || type.IsCOMObject || type.IsAutoClass || type.IsGenericType || type.Name.StartsWith("<") || type.IsCastableTo(typeof(Delegate)) || type.IsDefined(typeof(ObsoleteAttribute), true) || excludedTypes.Contains(type.FullName)) { continue; } string ns = type.Namespace; //if(ns.StartsWith("Unity.") || ns.Contains("Experimental") || ns.Contains("Internal")) { // continue; //} if (string.IsNullOrEmpty(ns)) { ns = "global"; } else if (!namespaces.Contains(ns)) { continue; } if (excludedNS.Contains(ns)) { continue; } List <Type> types; if (!typeMaps.TryGetValue(ns, out types)) { types = new List <Type>(); typeMaps[ns] = types; } types.Add(type); //typeCount++; } } //this.typeCount = typeCount; typeList = typeMaps.ToList(); foreach (var list in typeList) { list.Value.Sort((x, y) => string.Compare(x.Name, y.Name)); } typeList.Sort((x, y) => { if (x.Key == "global") { if (y.Key == "global") { return(0); } return(-1); } else if (y.Key == "global") { return(1); } if (x.Key.StartsWith("Unity")) { if (y.Key.StartsWith("Unity")) { return(string.Compare(x.Key, y.Key)); } return(-1); } else if (y.Key.StartsWith("Unity")) { return(1); } return(string.Compare(x.Key, y.Key)); }); }
public override IList <ItemSelector.CustomItem> GetItems(Node source, MemberData data, System.Type type) { var items = new List <ItemSelector.CustomItem>(); if (type.IsPrimitive && type != typeof(bool) && type != typeof(char)) //Primitives { items.AddRange(GetCustomItemForPrimitives(type, data)); } else { items.Add(GetItem(type, type, type, typeof(bool), data, ComparisonType.Equal)); items.Add(GetItem(type, type, type, typeof(bool), data, ComparisonType.NotEqual)); } var preference = uNodePreference.GetPreference(); var assemblies = EditorReflectionUtility.GetAssemblies(); var includedAssemblies = uNodePreference.GetIncludedAssemblies(); var ns = graph.editorData.GetNamespaces(); foreach (var assembly in assemblies) { if (!includedAssemblies.Contains(assembly.GetName().Name)) { continue; } var operators = EditorReflectionUtility.GetOperators(assembly, (op) => { return(ns.Contains(op.DeclaringType.Namespace)); }); if (operators.Count > 0) { foreach (var op in operators) { switch (op.Name) { //case "op_Equality": { // var parameters = op.GetParameters(); // if(parameters[0].ParameterType != type && parameters[1].ParameterType != type) // break; // items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ComparisonType.Equal)); // break; //} //case "op_Inequality": { // var parameters = op.GetParameters(); // if(parameters[0].ParameterType != type && parameters[1].ParameterType != type) // break; // items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ComparisonType.NotEqual)); // break; //} case "op_LessThan": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ComparisonType.LessThan)); break; } case "op_GreaterThan": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ComparisonType.GreaterThan)); break; } case "op_LessThanOrEqual": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ComparisonType.LessThanOrEqual)); break; } case "op_GreaterThanOrEqual": { var parameters = op.GetParameters(); if (parameters[0].ParameterType != type && parameters[1].ParameterType != type) { break; } items.Add(GetItem(type, parameters[0].ParameterType, parameters[1].ParameterType, op.ReturnType, data, ComparisonType.GreaterThanOrEqual)); break; } } } } } items.Sort((x, y) => string.Compare(x.name, y.name)); return(items); }
protected override void InitializeView() { HLNode node = targetNode as HLNode; node.Refresh(); var instance = node.instance; if (instance == null) { return; } if (instance is IStateNode || instance is IStateCoroutineNode) { AddOutputFlowPort( new PortData() { portID = nameof(node.onSuccess), onValueChanged = (o) => { RegisterUndo(); node.onSuccess = o as MemberData; }, getPortName = () => "Success", getPortType = () => typeof(FlowInput), getPortValue = () => node.onSuccess, getPortTooltip = () => "Flow to execute on success", } ); AddOutputFlowPort( new PortData() { portID = nameof(node.onFailure), onValueChanged = (o) => { RegisterUndo(); node.onFailure = o as MemberData; }, getPortName = () => "Failure", getPortType = () => typeof(FlowInput), getPortValue = () => node.onFailure, getPortTooltip = () => "Flow to execute on failure", } ); } if (node.IsFlowNode()) //Flow input { nodeFlowPort = AddInputFlowPort( new PortData() { portID = UGraphView.SelfPortID, getPortName = () => "", getConnection = () => { return(new MemberData(node, MemberData.TargetType.FlowNode)); }, } ); AddOutputFlowPort( new PortData() { portID = "onFinished", onValueChanged = (o) => { RegisterUndo(); node.onFinished = o as MemberData; }, getPortName = () => instance is IStateNode || instance is IStateCoroutineNode ? "Finished" : "", getPortType = () => typeof(FlowInput), getPortValue = () => node.onFinished, } ); } if (node.CanGetValue() || node.CanSetValue()) //Value output { nodeValuePort = AddOutputValuePort( new PortData() { portID = UGraphView.SelfPortID, getPortName = () => "Out", getPortType = () => node.ReturnType(), getPortValue = () => node, getConnection = () => { return(new MemberData(node, MemberData.TargetType.ValueNode)); }, } ); } Type type = instance.GetType(); var fields = EditorReflectionUtility.GetFields(type); foreach (var field in fields) { if (field.IsDefined(typeof(NonSerializedAttribute)) || field.IsDefined(typeof(HideAttribute))) { continue; } var option = field.GetCustomAttribute(typeof(NodePortAttribute), true) as NodePortAttribute; if (option != null && option.hideInNode) { continue; } var val = node.initializers.FirstOrDefault(d => d.name == field.Name); if (val == null) { val = new FieldValueData() { name = field.Name, value = MemberData.CreateFromValue(field.GetValue(instance), field.FieldType), }; node.initializers.Add(val); } AddInputValuePort( new PortData() { portID = field.Name, onValueChanged = (o) => { RegisterUndo(); val.value = o as MemberData; }, getPortName = () => option != null ? option.name : field.Name, getPortType = () => field.FieldType, getPortValue = () => val.value, getPortTooltip = () => { var tooltip = field.GetCustomAttribute(typeof(TooltipAttribute), true) as TooltipAttribute; return(tooltip != null ? tooltip.tooltip : string.Empty); }, }); } }
private void BuildContextualMenu(ContextualMenuPopulateEvent evt) { if (config.type != null) { if (config.filter == null || !config.filter.SetMember && config.filter.IsValidTarget(MemberData.TargetType.Values)) { evt.menu.AppendAction("To Default", (e) => { if (config.type == typeof(Type)) { member = new MemberData(typeof(object)); } else if (config.type is RuntimeType) { member = MemberData.CreateFromValue(null, config.type); } else { member = new MemberData(ReflectionUtils.CanCreateInstance(config.type) ? ReflectionUtils.CreateInstance(config.type) : null) { startType = config.type, targetTypeName = config.type.FullName, }; } config.OnValueChanged(member); config.owner.OnValueChanged(); config.owner.MarkRepaint(); UpdateControl(); uNodeEditor.GUIChanged(); }, DropdownMenuAction.AlwaysEnabled); if (config.type == typeof(object)) { var types = EditorReflectionUtility.GetCommonType(); foreach (var t in types) { evt.menu.AppendAction("To Value/" + t.PrettyName(), (e) => { member = new MemberData(ReflectionUtils.CanCreateInstance(t) ? ReflectionUtils.CreateInstance(t) : null) { startType = t, targetTypeName = t.FullName, }; config.OnValueChanged(member); config.owner.OnValueChanged(); config.owner.MarkRepaint(); UpdateControl(); uNodeEditor.GUIChanged(); }, DropdownMenuAction.AlwaysEnabled); } } else if (config.type == typeof(Type)) { var mPos = NodeGraph.openedGraph.GetMousePosition(); evt.menu.AppendAction("Change Type", (e) => { TypeSelectorWindow.ShowWindow(mPos, new FilterAttribute() { OnlyGetType = true }, delegate(MemberData[] types) { uNodeEditorUtility.RegisterUndo(config.owner.targetNode); member.CopyFrom(types[0]); config.OnValueChanged(member); config.owner.OnValueChanged(); config.owner.MarkRepaint(); UpdateControl(); uNodeEditor.GUIChanged(); }, new TypeItem[1] { member }).targetObject = config.owner.targetNode; }, DropdownMenuAction.AlwaysEnabled); } if (!config.type.IsValueType) { evt.menu.AppendAction("To Null", (e) => { uNodeEditorUtility.RegisterUndo(config.owner.targetNode); member.CopyFrom(MemberData.Null); config.OnValueChanged(member); config.owner.OnValueChanged(); config.owner.MarkRepaint(); UpdateControl(); uNodeEditor.GUIChanged(); }, DropdownMenuAction.AlwaysEnabled); } } } }
public virtual void AddChildNodes(NodeComponent nodeComponent, TreeViewItem parentTree, IList <TreeViewItem> rows) { var fields = EditorReflectionUtility.GetFields(nodeComponent.GetType()); foreach (var field in fields) { var fieldType = field.FieldType; if (field.IsDefinedAttribute(typeof(FieldConnectionAttribute))) { var attributes = EditorReflectionUtility.GetAttributes(field); var FCA = ReflectionUtils.GetAttribute <FieldConnectionAttribute>(attributes); bool isFlow = nodeComponent is Node && (nodeComponent as Node).IsFlowNode(); if (FCA.hideOnFlowNode && isFlow) { continue; } if (FCA.hideOnNotFlowNode && !isFlow) { continue; } if (fieldType == typeof(MemberData)) { if (FCA.isFlowConnection) { MemberData member = field.GetValueOptimized(nodeComponent) as MemberData; if (member != null) { if (!FCA.isFinishedFlow && field.Name != nameof(MultipurposeNode.onFinished)) { if (FCA.displayFlowInHierarchy) { var flowItem = CreateFlowTree( nodeComponent, field.Name, member, FCA.label != null ? FCA.label.text : field.Name ); parentTree.AddChild(flowItem); rows.Add(flowItem); manager.AddNodeTree(member, flowItem, rows); } else { manager.AddNodeTree(member, parentTree, rows); } } else { manager.AddNodeTree(member, parentTree, rows, false); } } } } else if (fieldType == typeof(List <MemberData>) && FCA.isFlowConnection) { List <MemberData> members = field.GetValueOptimized(nodeComponent) as List <MemberData>; if (members != null && members.Count > 0) { foreach (var member in members) { if (member != null && member.isAssigned && member.IsTargetingPinOrNode) { Node n = member.GetTargetNode(); if (n != null) { manager.AddNodes(n, parentTree, rows, isChildren: !FCA.isFinishedFlow && field.Name != nameof(MultipurposeNode.onFinished)); } } } } } } else if (fieldType == typeof(EventData)) { var blocks = field.GetValueOptimized(nodeComponent) as EventData; AddBlocks(blocks, field.Name, parentTree, rows); } } }
public void PasteNode(Vector3 position) { if (nodeToCopy == null || nodeToCopy.Count == 0) { return; } if (uNodeEditorUtility.IsPrefab(editorData.graph.gameObject)) { throw new Exception("Editing graph prefab dirrectly is not supported."); } uNodeEditorUtility.RegisterUndo(editorData.graph, "Paste Node"); uNodeRoot UNR = editorData.graph; float progress = 0; int loopIndex = 0; if (nodeToCopy.Count > 5) { EditorUtility.DisplayProgressBar("Loading", "", progress); } Vector2 center = Vector2.zero; int centerLength = 0; Dictionary <uNodeComponent, uNodeComponent> CopyedObjectMap = new Dictionary <uNodeComponent, uNodeComponent>(EqualityComparer <uNodeComponent> .Default); foreach (uNodeComponent comp in nodeToCopy) { if (comp == null || comp is EventNode && editorData.selectedGroup != null) { continue; } Node node = comp as Node; if (!CopyedObjectMap.ContainsKey(comp)) { uNodeComponent com = Object.Instantiate(comp); com.gameObject.name = com.gameObject.name.Replace("(Clone)", ""); if (editorData.selectedGroup == null) { if (editorData.selectedRoot) { com.transform.parent = editorData.selectedRoot.transform; } else { com.transform.parent = NodeEditorUtility.GetNodeRoot(UNR).transform; } } else { com.transform.parent = editorData.selectedGroup.transform; } int index = 0; string nm = com.gameObject.name.TrimEnd(numberChar); while (true) { bool flag = false; string gName = com.gameObject.name; foreach (Transform t in com.transform.parent) { if (t != com.transform) { if (t.gameObject.name.Equals(gName)) { flag = true; break; } } } if (flag) { com.gameObject.name = nm + index.ToString(); index++; continue; } break; } CopyedObjectMap.Add(comp, com); if (comp is IMacro || comp is ISuperNode) { var fields = EditorReflectionUtility.GetFields(comp.GetType()); foreach (var field in fields) { if (field.FieldType == typeof(List <Nodes.MacroPortNode>)) { var value = field.GetValueOptimized(comp) as List <Nodes.MacroPortNode>; if (value != null) { var sourceValue = field.GetValueOptimized(com) as List <Nodes.MacroPortNode>; for (int i = 0; i < value.Count; i++) { if (value[i] == null) { continue; } CopyedObjectMap.Add(value[i], sourceValue[i]); } } } } } } if (node != null) { center.x += node.editorRect.x; center.y += node.editorRect.y; centerLength++; } else { BaseEventNode met = comp as BaseEventNode; if (met != null) { center.x += met.editorRect.x; center.y += met.editorRect.y; centerLength++; } } loopIndex++; progress = (float)loopIndex / (float)nodeToCopy.Count; if (nodeToCopy.Count > 5) { EditorUtility.DisplayProgressBar("Loading", "", progress); } } progress = 0; center /= centerLength; HashSet <uNodeComponent> needReflectedComponent = new HashSet <uNodeComponent>(); uNodeRoot compEvent = null; foreach (uNodeComponent com in nodeToCopy) { uNodeComponent comp = null; if (CopyedObjectMap.ContainsKey(com)) { comp = CopyedObjectMap[com]; if (comp == null) { loopIndex++; progress = (float)loopIndex / (float)nodeToCopy.Count; if (nodeToCopy.Count > 5) { EditorUtility.DisplayProgressBar("Loading", "", progress); } continue; } if (comp as Node) { Node node = comp as Node; Func <object, bool> validation = delegate(object o) { if (o is MemberData) { MemberData member = o as MemberData; if (member.IsTargetingPinOrNode) { NodeComponent n = member.GetInstance() as NodeComponent; if (n && n is uNodeComponent) { if (CopyedObjectMap.ContainsKey(n)) { member.instance = CopyedObjectMap[n] as NodeComponent; n.owner = UNR; return(true); } else if (n.owner != UNR || n.transform.parent != node.transform.parent) { member.instance = null; n.owner = UNR; return(true); } //return true; } } } return(false); }; if (node as StateNode) { StateNode eventNode = node as StateNode; TransitionEvent[] TE = eventNode.GetTransitions(); foreach (TransitionEvent n in TE) { var tn = n.GetTargetNode(); if (tn == null) { continue; } if (CopyedObjectMap.ContainsKey(tn)) { n.target = MemberData.CreateConnection(CopyedObjectMap[tn] as Node, true); n.owner = UNR; } else if (n.owner != UNR || tn != null && tn.owner != UNR || tn != null && tn.transform.parent != node.transform.parent) { n.target = MemberData.none; n.owner = UNR; } } } else if (node is IMacro || node is ISuperNode) { var fields = EditorReflectionUtility.GetFields(comp.GetType()); foreach (var field in fields) { if (field.FieldType == typeof(List <Nodes.MacroPortNode>)) { var value = field.GetValueOptimized(comp) as List <Nodes.MacroPortNode>; if (value != null) { foreach (var v in value) { AnalizerUtility.AnalizeObject(v, validation); } } } } } AnalizerUtility.AnalizeObject(node, validation); node.editorRect = new Rect(node.editorRect.x - center.x + position.x, node.editorRect.y - center.y + position.y, node.editorRect.width, node.editorRect.height); if (node.owner != UNR) { node.owner = UNR; } } else if (comp is BaseEventNode) { BaseEventNode method = comp as BaseEventNode; var flows = method.GetFlows(); for (int i = 0; i < flows.Count; i++) { var tn = flows[i].GetTargetNode(); if (tn != null && CopyedObjectMap.ContainsKey(tn)) { flows[i] = new MemberData(CopyedObjectMap[flows[i].GetTargetNode()], MemberData.TargetType.FlowNode); } else if (method.owner != UNR) { flows[i] = MemberData.none; } } method.owner = UNR; method.editorRect = new Rect(method.editorRect.x - center.x + position.x, method.editorRect.y - center.y + position.y, method.editorRect.width, method.editorRect.height); } } loopIndex++; progress = (float)loopIndex / (float)nodeToCopy.Count; if (nodeToCopy.Count > 5) { EditorUtility.DisplayProgressBar("Loading", "", progress); } } if (nodeToCopy.Count > 5) { EditorUtility.ClearProgressBar(); } if (needReflectedComponent.Count > 0) { NodeEditorUtility.PerformReflectComponent(needReflectedComponent.ToList(), compEvent, UNR); } foreach (KeyValuePair <uNodeComponent, uNodeComponent> keys in CopyedObjectMap) { if (keys.Value != null) { Undo.RegisterCreatedObjectUndo(keys.Value.gameObject, "Paste Node"); } } //allCopyedEvent.Clear(); Refresh(); }
void InitializeHLBlock(Block block) { if (block is Events.HLAction action) { Type type = action.type.startType; if (type != null) { var fields = EditorReflectionUtility.GetFields(type); foreach (var field in fields) { if (field.IsDefined(typeof(NonSerializedAttribute)) || field.IsDefined(typeof(HideAttribute))) { continue; } var option = field.GetCustomAttribute(typeof(NodePortAttribute), true) as NodePortAttribute; if (option != null && option.hideInNode) { continue; } var val = action.initializers.FirstOrDefault(d => d.name == field.Name); if (val == null) { val = new FieldValueData() { name = field.Name, value = MemberData.CreateFromValue(field.GetValueOptimized(ReflectionUtils.CreateInstance(type)), field.FieldType), }; action.initializers.Add(val); } var port = AddPort(new PortData() { portID = field.Name, getPortName = () => option != null ? option.name : field.Name, getPortType = () => field.FieldType, getPortValue = () => val.value, onValueChanged = (obj) => { RegisterUndo(); val.value = obj as MemberData; Repaint(); }, getPortTooltip = () => { var tooltip = field.GetCustomAttribute(typeof(TooltipAttribute), true) as TooltipAttribute; return(tooltip != null ? tooltip.tooltip : string.Empty); }, }); port.Add(new ControlView(port.portData.InstantiateControl(true), true)); } } } else if (block is Events.HLCondition condition) { Type type = condition.type.startType; if (type != null) { var fields = EditorReflectionUtility.GetFields(type); foreach (var field in fields) { if (field.IsDefined(typeof(NonSerializedAttribute)) || field.IsDefined(typeof(HideAttribute))) { continue; } var option = field.GetCustomAttribute(typeof(NodePortAttribute), true) as NodePortAttribute; if (option != null && option.hideInNode) { continue; } var val = condition.initializers.FirstOrDefault(d => d.name == field.Name); if (val == null) { val = new FieldValueData() { name = field.Name, value = MemberData.CreateFromValue(field.GetValueOptimized(ReflectionUtils.CreateInstance(type)), field.FieldType), }; condition.initializers.Add(val); } var port = AddPort(new PortData() { portID = field.Name, getPortName = () => option != null ? option.name : field.Name, getPortType = () => field.FieldType, getPortValue = () => val.value, onValueChanged = (obj) => { RegisterUndo(); val.value = obj as MemberData; Repaint(); }, getPortTooltip = () => { var tooltip = field.GetCustomAttribute(typeof(TooltipAttribute), true) as TooltipAttribute; return(tooltip != null ? tooltip.tooltip : string.Empty); }, }); port.Add(new ControlView(port.portData.InstantiateControl(true), true)); } } } }