Exemple #1
0
        private static List <ItemSelector.CustomItem> GetCustomItemForPrimitives(MultiArithmeticNode source, Type type)
        {
            var items = new List <ItemSelector.CustomItem>();

            items.Add(GetCustomItem(source, type, type, type, type, ArithmeticType.Add));
            items.Add(GetCustomItem(source, type, type, type, type, ArithmeticType.Divide));
            items.Add(GetCustomItem(source, type, type, type, type, ArithmeticType.Modulo));
            items.Add(GetCustomItem(source, type, type, type, type, ArithmeticType.Multiply));
            items.Add(GetCustomItem(source, type, type, type, type, ArithmeticType.Subtract));
            return(items);
        }
Exemple #2
0
 private static ItemSelector.CustomItem GetCustomItem(MultiArithmeticNode source, Type param1, Type param2, Type declaredType, Type returnType, ArithmeticType operatorType)
 {
     return(new ItemSelector.CustomItem(string.Format(operatorType.ToString() + " ({0}, {1})", param1.PrettyName(), param2.PrettyName()), () => {
         uNodeEditorUtility.RegisterUndo(source);
         source.operatorType = operatorType;
         while (source.targets.Count > 2)
         {
             source.targets.RemoveAt(source.targets.Count - 1);
         }
         source.targets[0].CopyFrom(new MemberData(ReflectionUtils.CreateInstance(param1)));
         source.targets[1].CopyFrom(new MemberData(ReflectionUtils.CreateInstance(param2)));
         uNodeGUIUtility.GUIChanged(source);
     }, declaredType.PrettyName() + " : Operator")
     {
         icon = uNodeEditorUtility.GetTypeIcon(returnType)
     });
 }
Exemple #3
0
        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;
                }
            }
        }