コード例 #1
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
 /// <summary> Draws an input and an output port on the same line </summary>
 public static void PortPair(xNode.NodePort input, xNode.NodePort output)
 {
     GUILayout.BeginHorizontal();
     NodeEditorGUILayout.PortField(input, GUILayout.MinWidth(0));
     NodeEditorGUILayout.PortField(output, GUILayout.MinWidth(0));
     GUILayout.EndHorizontal();
 }
コード例 #2
0
ファイル: NodeGraphEditor.cs プロジェクト: Your-Die/xNode
        /// <summary> Returned gradient is used to color noodles </summary>
        /// <param name="output"> The output this noodle comes from. Never null. </param>
        /// <param name="input"> The output this noodle comes from. Can be null if we are dragging the noodle. </param>
        public virtual Gradient GetNoodleGradient(xNode.NodePort output, xNode.NodePort input)
        {
            Gradient grad = new Gradient();

            // If dragging the noodle, draw solid, slightly transparent
            if (input == null)
            {
                Color a = GetTypeColor(output.ValueType);
                grad.SetKeys(
                    new GradientColorKey[] { new GradientColorKey(a, 0f) },
                    new GradientAlphaKey[] { new GradientAlphaKey(0.6f, 0f) }
                    );
            }
            // If normal, draw gradient fading from one input color to the other
            else
            {
                Color a = GetTypeColor(output.ValueType);
                Color b = GetTypeColor(input.ValueType);
                // If any port is hovered, tint white
                if (window.hoveredPort == output || window.hoveredPort == input)
                {
                    a = Color.Lerp(a, Color.white, 0.8f);
                    b = Color.Lerp(b, Color.white, 0.8f);
                }
                grad.SetKeys(
                    new GradientColorKey[] { new GradientColorKey(a, 0f), new GradientColorKey(b, 1f) },
                    new GradientAlphaKey[] { new GradientAlphaKey(1f, 0f), new GradientAlphaKey(1f, 1f) }
                    );
            }
            return(grad);
        }
コード例 #3
0
ファイル: NodeEditorAction.cs プロジェクト: Your-Die/xNode
        /// <summary> Attempt to connect dragged output to target node </summary>
        public void AutoConnect(xNode.Node node)
        {
            if (this.autoConnectOutput == null)
            {
                return;
            }

            // Find input port of same type
            xNode.NodePort inputPort =
                node.Ports.FirstOrDefault(x => x.IsInput && x.ValueType == this.autoConnectOutput.ValueType);
            // Fallback to input port
            if (inputPort == null)
            {
                inputPort = node.Ports.FirstOrDefault(x => x.IsInput);
            }
            // Autoconnect if connection is compatible
            if (inputPort != null && inputPort.CanConnectTo(this.autoConnectOutput))
            {
                this.autoConnectOutput.Connect(inputPort);
            }

            // Save changes
            EditorUtility.SetDirty(this.graph);
            if (NodeEditorPreferences.GetSettings().autoSave)
            {
                AssetDatabase.SaveAssets();
            }
            this.autoConnectOutput = null;
        }
コード例 #4
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
        /// <summary> Add a port field to previous layout element. </summary>
        public static void AddPortField(xNode.NodePort port)
        {
            if (port == null)
            {
                return;
            }
            Rect rect = new Rect();

            // If property is an input, display a regular property field and put a port handle on the left side
            if (port.Direction == xNode.NodePort.IO.Input)
            {
                rect = GUILayoutUtility.GetLastRect();
                float paddingLeft = NodeEditorResources.styles.inputPort.padding.left;
                rect.position = rect.position - new Vector2(16 + paddingLeft, 0);
                // If property is an output, display a text label and put a port handle on the right side
            }
            else if (port.Direction == xNode.NodePort.IO.Output)
            {
                rect          = GUILayoutUtility.GetLastRect();
                rect.width   += NodeEditorResources.styles.outputPort.padding.right;
                rect.position = rect.position + new Vector2(rect.width, 0);
            }

            rect.size = new Vector2(16, 16);

            Color backgroundColor = NodeEditorWindow.current.graphEditor.GetPortBackgroundColor(port);
            Color col             = NodeEditorWindow.current.graphEditor.GetPortColor(port);

            DrawPortHandle(rect, backgroundColor, col);

            // Register the handle position
            Vector2 portPos = rect.center;

            NodeEditor.portPositions[port] = portPos;
        }
コード例 #5
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
 /// <summary> Make a field for a serialized property. Automatically displays relevant node port. </summary>
 public static void PropertyField(SerializedProperty property, GUIContent label, bool includeChildren = true, params GUILayoutOption[] options)
 {
     if (property == null)
     {
         throw new NullReferenceException();
     }
     xNode.Node     node = property.serializedObject.targetObject as xNode.Node;
     xNode.NodePort port = node.GetPort(property.name);
     PropertyField(property, label, port, includeChildren);
 }
コード例 #6
0
ファイル: NodeGraphEditor.cs プロジェクト: Your-Die/xNode
        /// <summary> Override to display custom tooltips </summary>
        public virtual string GetPortTooltip(xNode.NodePort port)
        {
            Type   portType = port.ValueType;
            string tooltip  = "";

            tooltip = portType.PrettyName();
            if (port.IsOutput)
            {
                object obj = port.node.GetValue(port);
                tooltip += " = " + (obj != null ? obj.ToString() : "null");
            }
            return(tooltip);
        }
コード例 #7
0
ファイル: NodeEditorWindow.cs プロジェクト: Your-Die/xNode
        private void OnEnable()
        {
            // Reload portConnectionPoints if there are any
            int length = _references.Length;

            if (length == _rects.Length)
            {
                for (int i = 0; i < length; i++)
                {
                    xNode.NodePort nodePort = _references[i].GetNodePort();
                    if (nodePort != null)
                    {
                        _portConnectionPoints.Add(nodePort, _rects[i]);
                    }
                }
            }
        }
コード例 #8
0
        /// <summary> Show right-click context menu for hovered port </summary>
        void ShowPortContextMenu(xNode.NodePort hoveredPort)
        {
            GenericMenu contextMenu = new GenericMenu();

            foreach (var port in hoveredPort.GetConnections())
            {
                var name  = port.node.name;
                var index = hoveredPort.GetConnectionIndex(port);
                contextMenu.AddItem(new GUIContent($"Disconnect({name})"), false, () => hoveredPort.Disconnect(index));
            }

            contextMenu.AddItem(new GUIContent("Clear Connections"), false, () => hoveredPort.ClearConnections());
            contextMenu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
            if (NodeEditorPreferences.GetSettings().autoSave)
            {
                AssetDatabase.SaveAssets();
            }
        }
コード例 #9
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
        /// <summary> Is this port part of a DynamicPortList? </summary>
        public static bool IsDynamicPortListPort(xNode.NodePort port)
        {
            string[] parts = port.fieldName.Split(' ');
            if (parts.Length != 2)
            {
                return(false);
            }
            Dictionary <string, ReorderableList> cache;

            if (reorderableListCache.TryGetValue(port.node, out cache))
            {
                ReorderableList list;
                if (cache.TryGetValue(parts[0], out list))
                {
                    return(true);
                }
            }
            return(false);
        }
コード例 #10
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
        /// <summary> Make a simple port field. </summary>
        public static void PortField(Vector2 position, xNode.NodePort port)
        {
            if (port == null)
            {
                return;
            }

            Rect rect = new Rect(position, new Vector2(16, 16));

            Color backgroundColor = NodeEditorWindow.current.graphEditor.GetPortBackgroundColor(port);
            Color col             = NodeEditorWindow.current.graphEditor.GetPortColor(port);

            DrawPortHandle(rect, backgroundColor, col);

            // Register the handle position
            Vector2 portPos = rect.center;

            NodeEditor.portPositions[port] = portPos;
        }
コード例 #11
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
        /// <summary> Make a simple port field. </summary>
        public static void PortField(GUIContent label, xNode.NodePort port, params GUILayoutOption[] options)
        {
            if (port == null)
            {
                return;
            }
            if (options == null)
            {
                options = new GUILayoutOption[] { GUILayout.MinWidth(30) }
            }
            ;
            Vector2    position = Vector3.zero;
            GUIContent content  = label != null ? label : new GUIContent(ObjectNames.NicifyVariableName(port.fieldName));

            // If property is an input, display a regular property field and put a port handle on the left side
            if (port.Direction == xNode.NodePort.IO.Input)
            {
                // Display a label
                EditorGUILayout.LabelField(content, options);

                Rect  rect        = GUILayoutUtility.GetLastRect();
                float paddingLeft = NodeEditorResources.styles.inputPort.padding.left;
                position = rect.position - new Vector2(16 + paddingLeft, 0);
            }
            // If property is an output, display a text label and put a port handle on the right side
            else if (port.Direction == xNode.NodePort.IO.Output)
            {
                // Display a label
                EditorGUILayout.LabelField(content, NodeEditorResources.OutputPort, options);

                Rect rect = GUILayoutUtility.GetLastRect();
                rect.width += NodeEditorResources.styles.outputPort.padding.right;
                position    = rect.position + new Vector2(rect.width, 0);
            }
            PortField(position, port);
        }
コード例 #12
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
        private static ReorderableList CreateReorderableList(string fieldName, List <xNode.NodePort> dynamicPorts, SerializedProperty arrayData, Type type, SerializedObject serializedObject, xNode.NodePort.IO io, xNode.Node.ConnectionType connectionType, xNode.Node.TypeConstraint typeConstraint, Action <ReorderableList> onCreation)
        {
            bool hasArrayData = arrayData != null && arrayData.isArray;

            xNode.Node      node  = serializedObject.targetObject as xNode.Node;
            ReorderableList list  = new ReorderableList(dynamicPorts, null, true, true, true, true);
            string          label = arrayData != null ? arrayData.displayName : ObjectNames.NicifyVariableName(fieldName);

            list.drawElementCallback =
                (Rect rect, int index, bool isActive, bool isFocused) => {
                xNode.NodePort port = node.GetPort(fieldName + " " + index);
                if (hasArrayData && arrayData.propertyType != SerializedPropertyType.String)
                {
                    if (arrayData.arraySize <= index)
                    {
                        EditorGUI.LabelField(rect, "Array[" + index + "] data out of range");
                        return;
                    }
                    SerializedProperty itemData = arrayData.GetArrayElementAtIndex(index);
                    EditorGUI.PropertyField(rect, itemData, true);
                }
                else
                {
                    EditorGUI.LabelField(rect, port != null ? port.fieldName : "");
                }
                if (port != null)
                {
                    Vector2 pos = rect.position + (port.IsOutput ? new Vector2(rect.width + 6, 0) : new Vector2(-36, 0));
                    NodeEditorGUILayout.PortField(pos, port);
                }
            };
            list.elementHeightCallback =
                (int index) => {
                if (hasArrayData)
                {
                    if (arrayData.arraySize <= index)
                    {
                        return(EditorGUIUtility.singleLineHeight);
                    }
                    SerializedProperty itemData = arrayData.GetArrayElementAtIndex(index);
                    return(EditorGUI.GetPropertyHeight(itemData));
                }
                else
                {
                    return(EditorGUIUtility.singleLineHeight);
                }
            };
            list.drawHeaderCallback =
                (Rect rect) => {
                EditorGUI.LabelField(rect, label);
            };
            list.onSelectCallback =
                (ReorderableList rl) => {
                reorderableListIndex = rl.index;
            };
            list.onReorderCallback =
                (ReorderableList rl) => {
                bool hasRect    = false;
                bool hasNewRect = false;
                Rect rect       = Rect.zero;
                Rect newRect    = Rect.zero;
                // Move up
                if (rl.index > reorderableListIndex)
                {
                    for (int i = reorderableListIndex; i < rl.index; ++i)
                    {
                        xNode.NodePort port     = node.GetPort(fieldName + " " + i);
                        xNode.NodePort nextPort = node.GetPort(fieldName + " " + (i + 1));
                        port.SwapConnections(nextPort);

                        // Swap cached positions to mitigate twitching
                        hasRect    = NodeEditorWindow.current.portConnectionPoints.TryGetValue(port, out rect);
                        hasNewRect = NodeEditorWindow.current.portConnectionPoints.TryGetValue(nextPort, out newRect);
                        NodeEditorWindow.current.portConnectionPoints[port]     = hasNewRect ? newRect : rect;
                        NodeEditorWindow.current.portConnectionPoints[nextPort] = hasRect ? rect : newRect;
                    }
                }
                // Move down
                else
                {
                    for (int i = reorderableListIndex; i > rl.index; --i)
                    {
                        xNode.NodePort port     = node.GetPort(fieldName + " " + i);
                        xNode.NodePort nextPort = node.GetPort(fieldName + " " + (i - 1));
                        port.SwapConnections(nextPort);

                        // Swap cached positions to mitigate twitching
                        hasRect    = NodeEditorWindow.current.portConnectionPoints.TryGetValue(port, out rect);
                        hasNewRect = NodeEditorWindow.current.portConnectionPoints.TryGetValue(nextPort, out newRect);
                        NodeEditorWindow.current.portConnectionPoints[port]     = hasNewRect ? newRect : rect;
                        NodeEditorWindow.current.portConnectionPoints[nextPort] = hasRect ? rect : newRect;
                    }
                }
                // Apply changes
                serializedObject.ApplyModifiedProperties();
                serializedObject.Update();

                // Move array data if there is any
                if (hasArrayData)
                {
                    arrayData.MoveArrayElement(reorderableListIndex, rl.index);
                }

                // Apply changes
                serializedObject.ApplyModifiedProperties();
                serializedObject.Update();
                NodeEditorWindow.current.Repaint();
                EditorApplication.delayCall += NodeEditorWindow.current.Repaint;
            };
            list.onAddCallback =
                (ReorderableList rl) => {
                // Add dynamic port postfixed with an index number
                string newName = fieldName + " 0";
                int    i       = 0;
                while (node.HasPort(newName))
                {
                    newName = fieldName + " " + (++i);
                }

                if (io == xNode.NodePort.IO.Output)
                {
                    node.AddDynamicOutput(type, connectionType, xNode.Node.TypeConstraint.None, newName);
                }
                else
                {
                    node.AddDynamicInput(type, connectionType, typeConstraint, newName);
                }
                serializedObject.Update();
                EditorUtility.SetDirty(node);
                if (hasArrayData)
                {
                    arrayData.InsertArrayElementAtIndex(arrayData.arraySize);
                }
                serializedObject.ApplyModifiedProperties();
            };
            list.onRemoveCallback =
                (ReorderableList rl) => {
                var indexedPorts = node.DynamicPorts.Select(x => {
                    string[] split = x.fieldName.Split(' ');
                    if (split != null && split.Length == 2 && split[0] == fieldName)
                    {
                        int i = -1;
                        if (int.TryParse(split[1], out i))
                        {
                            return(new { index = i, port = x });
                        }
                    }
                    return(new { index = -1, port = (xNode.NodePort)null });
                }).Where(x => x.port != null);
                dynamicPorts = indexedPorts.OrderBy(x => x.index).Select(x => x.port).ToList();

                int index = rl.index;

                if (dynamicPorts[index] == null)
                {
                    Debug.LogWarning("No port found at index " + index + " - Skipped");
                }
                else if (dynamicPorts.Count <= index)
                {
                    Debug.LogWarning("DynamicPorts[" + index + "] out of range. Length was " + dynamicPorts.Count + " - Skipped");
                }
                else
                {
                    // Clear the removed ports connections
                    dynamicPorts[index].ClearConnections();
                    // Move following connections one step up to replace the missing connection
                    for (int k = index + 1; k < dynamicPorts.Count(); k++)
                    {
                        for (int j = 0; j < dynamicPorts[k].ConnectionCount; j++)
                        {
                            xNode.NodePort other = dynamicPorts[k].GetConnection(j);
                            dynamicPorts[k].Disconnect(other);
                            dynamicPorts[k - 1].Connect(other);
                        }
                    }
                    // Remove the last dynamic port, to avoid messing up the indexing
                    node.RemoveDynamicPort(dynamicPorts[dynamicPorts.Count() - 1].fieldName);
                    serializedObject.Update();
                    EditorUtility.SetDirty(node);
                }

                if (hasArrayData && arrayData.propertyType != SerializedPropertyType.String)
                {
                    if (arrayData.arraySize <= index)
                    {
                        Debug.LogWarning("Attempted to remove array index " + index + " where only " + arrayData.arraySize + " exist - Skipped");
                        Debug.Log(rl.list[0]);
                        return;
                    }
                    arrayData.DeleteArrayElementAtIndex(index);
                    // Error handling. If the following happens too often, file a bug report at https://github.com/Siccity/xNode/issues
                    if (dynamicPorts.Count <= arrayData.arraySize)
                    {
                        while (dynamicPorts.Count <= arrayData.arraySize)
                        {
                            arrayData.DeleteArrayElementAtIndex(arrayData.arraySize - 1);
                        }
                        UnityEngine.Debug.LogWarning("Array size exceeded dynamic ports size. Excess items removed.");
                    }
                    serializedObject.ApplyModifiedProperties();
                    serializedObject.Update();
                }
            };

            if (hasArrayData)
            {
                int dynamicPortCount = dynamicPorts.Count;
                while (dynamicPortCount < arrayData.arraySize)
                {
                    // Add dynamic port postfixed with an index number
                    string newName = arrayData.name + " 0";
                    int    i       = 0;
                    while (node.HasPort(newName))
                    {
                        newName = arrayData.name + " " + (++i);
                    }
                    if (io == xNode.NodePort.IO.Output)
                    {
                        node.AddDynamicOutput(type, connectionType, typeConstraint, newName);
                    }
                    else
                    {
                        node.AddDynamicInput(type, connectionType, typeConstraint, newName);
                    }
                    EditorUtility.SetDirty(node);
                    dynamicPortCount++;
                }
                while (arrayData.arraySize < dynamicPortCount)
                {
                    arrayData.InsertArrayElementAtIndex(arrayData.arraySize);
                }
                serializedObject.ApplyModifiedProperties();
                serializedObject.Update();
            }
            if (onCreation != null)
            {
                onCreation(list);
            }
            return(list);
        }
コード例 #13
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
 public static bool IsInstancePortListPort(xNode.NodePort port)
 {
     return(IsDynamicPortListPort(port));
 }
コード例 #14
0
ファイル: NodeGraphEditor.cs プロジェクト: Your-Die/xNode
 /// <summary> Returned color is used to color ports </summary>
 public virtual Color GetPortColor(xNode.NodePort port)
 {
     return(GetTypeColor(port.ValueType));
 }
コード例 #15
0
ファイル: NodeEditorAction.cs プロジェクト: Your-Die/xNode
        private void InsertDuplicateNodes(xNode.Node[] nodes, Vector2 topLeft)
        {
            if (nodes == null || nodes.Length == 0)
            {
                return;
            }

            // Get top-left node
            Vector2 topLeftNode = nodes.Select(x => x.position)
                                  .Aggregate((x, y) => new Vector2(Mathf.Min(x.x, y.x), Mathf.Min(x.y, y.y)));
            Vector2 offset = topLeft - topLeftNode;

            UnityEngine.Object[] newNodes = new UnityEngine.Object[nodes.Length];
            Dictionary <xNode.Node, xNode.Node> substitutes = new Dictionary <xNode.Node, xNode.Node>();

            for (int i = 0; i < nodes.Length; i++)
            {
                xNode.Node srcNode = nodes[i];
                if (srcNode == null)
                {
                    continue;
                }

                // Check if user is allowed to add more of given node type
                xNode.Node.DisallowMultipleNodesAttribute disallowAttrib;
                Type nodeType = srcNode.GetType();
                if (NodeEditorUtilities.GetAttrib(nodeType, out disallowAttrib))
                {
                    int typeCount = this.graph.nodes.Count(x => x.GetType() == nodeType);
                    if (typeCount >= disallowAttrib.max)
                    {
                        continue;
                    }
                }

                xNode.Node newNode = this.graphEditor.CopyNode(srcNode);
                substitutes.Add(srcNode, newNode);
                newNode.position = srcNode.position + offset;
                newNodes[i]      = newNode;
            }

            // Walk through the selected nodes again, recreate connections, using the new nodes
            for (int i = 0; i < nodes.Length; i++)
            {
                xNode.Node srcNode = nodes[i];
                if (srcNode == null)
                {
                    continue;
                }
                foreach (xNode.NodePort port in srcNode.Ports)
                {
                    for (int c = 0; c < port.ConnectionCount; c++)
                    {
                        xNode.NodePort inputPort =
                            port.Direction == xNode.NodePort.IO.Input ? port : port.GetConnection(c);
                        xNode.NodePort outputPort =
                            port.Direction == xNode.NodePort.IO.Output ? port : port.GetConnection(c);

                        xNode.Node newNodeIn, newNodeOut;
                        if (substitutes.TryGetValue(inputPort.node, out newNodeIn) &&
                            substitutes.TryGetValue(outputPort.node, out newNodeOut))
                        {
                            newNodeIn.UpdatePorts();
                            newNodeOut.UpdatePorts();
                            inputPort  = newNodeIn.GetInputPort(inputPort.fieldName);
                            outputPort = newNodeOut.GetOutputPort(outputPort.fieldName);
                        }

                        if (!inputPort.IsConnectedTo(outputPort))
                        {
                            inputPort.Connect(outputPort);
                        }
                    }
                }
            }

            EditorUtility.SetDirty(this.graph);
            // Select the new nodes
            Selection.objects = newNodes;
        }
コード例 #16
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
 /// <summary> Make a simple port field. </summary>
 public static void PortField(xNode.NodePort port, params GUILayoutOption[] options)
 {
     PortField(null, port, options);
 }
コード例 #17
0
ファイル: NodeGraphEditor.cs プロジェクト: Your-Die/xNode
 /// <summary> The returned color is used to color the background of the door.
 /// Usually used for outer edge effect </summary>
 public virtual Color GetPortBackgroundColor(xNode.NodePort port)
 {
     return(Color.gray);
 }
コード例 #18
0
        /// <summary> Draws all connections </summary>
        public void DrawConnections()
        {
            Vector2 mousePos = Event.current.mousePosition;
            List <RerouteReference> selection = this.preBoxSelectionReroute != null
                ? new List <RerouteReference>(this.preBoxSelectionReroute)
                : new List <RerouteReference>();

            this.hoveredReroute = new RerouteReference();

            List <Vector2> gridPoints = new List <Vector2>(2);

            Color col = GUI.color;

            foreach (xNode.Node node in this.graph.nodes)
            {
                //If a null node is found, return. This can happen if the nodes associated script is deleted. It is currently not possible in Unity to delete a null asset.
                if (node == null)
                {
                    continue;
                }

                // Draw full connections and output > reroute
                foreach (xNode.NodePort output in node.Outputs)
                {
                    //Needs cleanup. Null checks are ugly
                    if (!this._portConnectionPoints.TryGetValue(output, out var fromRect))
                    {
                        continue;
                    }

                    Color portColor = this.graphEditor.GetPortColor(output);
                    for (int k = 0; k < output.ConnectionCount; k++)
                    {
                        xNode.NodePort input = output.GetConnection(k);

                        Gradient     noodleGradient  = this.graphEditor.GetNoodleGradient(output, input);
                        float        noodleThickness = this.graphEditor.GetNoodleThickness(output, input);
                        NoodlePath   noodlePath      = this.graphEditor.GetNoodlePath(output, input);
                        NoodleStroke noodleStroke    = this.graphEditor.GetNoodleStroke(output, input);

                        // Error handling
                        if (input == null)
                        {
                            continue; //If a script has been updated and the port doesn't exist, it is removed and null is returned. If this happens, return.
                        }
                        if (!input.IsConnectedTo(output))
                        {
                            input.Connect(output);
                        }
                        if (!this._portConnectionPoints.TryGetValue(input, out var toRect))
                        {
                            continue;
                        }

                        List <Vector2> reroutePoints = output.GetReroutePoints(k);

                        gridPoints.Clear();
                        gridPoints.Add(fromRect.center);
                        gridPoints.AddRange(reroutePoints);
                        gridPoints.Add(toRect.center);
                        this.DrawNoodle(noodleGradient, noodlePath, noodleStroke, noodleThickness, gridPoints);

                        // Loop through reroute points again and draw the points
                        for (int i = 0; i < reroutePoints.Count; i++)
                        {
                            RerouteReference rerouteRef = new RerouteReference(output, k, i);
                            // Draw reroute point at position
                            Rect rect = new Rect(reroutePoints[i], new Vector2(12, 12));
                            rect.position = new Vector2(rect.position.x - 6, rect.position.y - 6);
                            rect          = this.GridToWindowRect(rect);

                            // Draw selected reroute points with an outline
                            if (this.selectedReroutes.Contains(rerouteRef))
                            {
                                GUI.color = NodeEditorPreferences.GetSettings().highlightColor;
                                GUI.DrawTexture(rect, NodeEditorResources.dotOuter);
                            }

                            GUI.color = portColor;
                            GUI.DrawTexture(rect, NodeEditorResources.dot);
                            if (rect.Overlaps(this.selectionBox))
                            {
                                selection.Add(rerouteRef);
                            }
                            if (rect.Contains(mousePos))
                            {
                                this.hoveredReroute = rerouteRef;
                            }
                        }
                    }
                }
            }

            GUI.color = col;
            if (Event.current.type != EventType.Layout && currentActivity == NodeActivity.DragGrid)
            {
                this.selectedReroutes = selection;
            }
        }
コード例 #19
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
 /// <summary> Make a field for a serialized property. Manual node port override. </summary>
 public static void PropertyField(SerializedProperty property, xNode.NodePort port, bool includeChildren = true, params GUILayoutOption[] options)
 {
     PropertyField(property, null, port, includeChildren, options);
 }
コード例 #20
0
ファイル: NodeEditorAction.cs プロジェクト: Your-Die/xNode
        public void Controls()
        {
            this.wantsMouseMove = true;
            var e = Event.current;

            switch (e.type)
            {
            case EventType.DragUpdated:
            case EventType.DragPerform:
                DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
                if (e.type == EventType.DragPerform)
                {
                    DragAndDrop.AcceptDrag();
                    this.graphEditor.OnDropObjects(DragAndDrop.objectReferences);
                }

                break;

            case EventType.MouseMove:
                //Keyboard commands will not get correct mouse position from Event
                this.lastMousePosition = e.mousePosition;
                break;

            case EventType.ScrollWheel:
                var oldZoom = this.zoom;
                if (e.delta.y > 0)
                {
                    this.zoom += 0.1f * this.zoom;
                }
                else
                {
                    this.zoom -= 0.1f * this.zoom;
                }
                if (NodeEditorPreferences.GetSettings().zoomToMouse)
                {
                    this.panOffset += (1 - oldZoom / this.zoom) * (this.WindowToGridPosition(e.mousePosition) + this.panOffset);
                }
                break;

            case EventType.MouseDrag:
                switch (e.button)
                {
                case 0:
                {
                    if (this.IsDraggingPort)
                    {
                        // Set target even if we can't connect, so as to prevent auto-conn menu from opening erroneously
                        if (this.IsHoveringPort && this.hoveredPort.IsInput && !this.draggedOutput.IsConnectedTo(this.hoveredPort))
                        {
                            this.draggedOutputTarget = this.hoveredPort;
                        }
                        else
                        {
                            this.draggedOutputTarget = null;
                        }

                        this.Repaint();
                    }
                    else if (currentActivity == NodeActivity.HoldNode)
                    {
                        this.RecalculateDragOffsets(e);
                        currentActivity = NodeActivity.DragNode;
                        this.Repaint();
                    }

                    switch (currentActivity)
                    {
                    case NodeActivity.DragNode:
                    {
                        // Holding ctrl inverts grid snap
                        var gridSnap = NodeEditorPreferences.GetSettings().gridSnap;
                        if (e.control)
                        {
                            gridSnap = !gridSnap;
                        }

                        var mousePos = this.WindowToGridPosition(e.mousePosition);
                        // Move selected nodes with offset
                        for (var i = 0; i < Selection.objects.Length; i++)
                        {
                            if (!(Selection.objects[i] is xNode.Node node))
                            {
                                continue;
                            }

                            Undo.RecordObject(node, "Moved Node");
                            var initial = node.position;
                            node.position = mousePos + dragOffset[i];
                            if (gridSnap)
                            {
                                node.position.x = (Mathf.Round((node.position.x + 8) / 16) * 16) - 8;
                                node.position.y = (Mathf.Round((node.position.y + 8) / 16) * 16) - 8;
                            }

                            // Offset portConnectionPoints instantly if a node is dragged so they aren't delayed by a frame.
                            var offset = node.position - initial;
                            if (!(offset.sqrMagnitude > 0))
                            {
                                continue;
                            }

                            foreach (var output in node.Outputs)
                            {
                                if (this.portConnectionPoints.TryGetValue(output, out var rect))
                                {
                                    rect.position += offset;
                                    this.portConnectionPoints[output] = rect;
                                }
                            }

                            foreach (var input in node.Inputs)
                            {
                                if (this.portConnectionPoints.TryGetValue(input, out var rect))
                                {
                                    rect.position += offset;
                                    this.portConnectionPoints[input] = rect;
                                }
                            }
                        }

                        // Move selected reroutes with offset
                        for (var i = 0; i < this.selectedReroutes.Count; i++)
                        {
                            var pos = mousePos + dragOffset[Selection.objects.Length + i];
                            if (gridSnap)
                            {
                                pos.x = (Mathf.Round(pos.x / 16) * 16);
                                pos.y = (Mathf.Round(pos.y / 16) * 16);
                            }

                            this.selectedReroutes[i].SetPoint(pos);
                        }

                        this.Repaint();
                        break;
                    }

                    case NodeActivity.HoldGrid:
                        currentActivity             = NodeActivity.DragGrid;
                        this.preBoxSelection        = Selection.objects;
                        this.preBoxSelectionReroute = this.selectedReroutes.ToArray();
                        this.dragBoxStart           = this.WindowToGridPosition(e.mousePosition);
                        this.Repaint();
                        break;

                    case NodeActivity.DragGrid:
                    {
                        var boxStartPos = this.GridToWindowPosition(this.dragBoxStart);
                        var boxSize     = e.mousePosition - boxStartPos;
                        if (boxSize.x < 0)
                        {
                            boxStartPos.x += boxSize.x;
                            boxSize.x      = Mathf.Abs(boxSize.x);
                        }

                        if (boxSize.y < 0)
                        {
                            boxStartPos.y += boxSize.y;
                            boxSize.y      = Mathf.Abs(boxSize.y);
                        }

                        this.selectionBox = new Rect(boxStartPos, boxSize);
                        this.Repaint();
                        break;
                    }
                    }

                    break;
                }

                case 1:
                case 2:
                {
                    //check drag threshold for larger screens
                    if (e.delta.magnitude > this.dragThreshold)
                    {
                        this.panOffset += e.delta * this.zoom;
                        isPanning       = true;
                    }

                    break;
                }
                }

                break;

            case EventType.MouseDown:
                this.Repaint();
                if (e.button == 0)
                {
                    this.draggedOutputReroutes.Clear();

                    if (this.IsHoveringPort)
                    {
                        if (this.hoveredPort.IsOutput)
                        {
                            this.draggedOutput     = this.hoveredPort;
                            this.autoConnectOutput = this.hoveredPort;
                        }
                        else
                        {
                            this.hoveredPort.VerifyConnections();
                            this.autoConnectOutput = null;
                            if (this.hoveredPort.IsConnected)
                            {
                                var node   = this.hoveredPort.node;
                                var output = this.hoveredPort.Connection;
                                var outputConnectionIndex = output.GetConnectionIndex(this.hoveredPort);
                                this.draggedOutputReroutes = output.GetReroutePoints(outputConnectionIndex);
                                this.hoveredPort.Disconnect(output);
                                this.draggedOutput       = output;
                                this.draggedOutputTarget = this.hoveredPort;
                                if (NodeEditor.onUpdateNode != null)
                                {
                                    NodeEditor.onUpdateNode(node);
                                }
                            }
                        }
                    }
                    else if (this.IsHoveringNode && this.IsHoveringTitle(this.hoveredNode))
                    {
                        // If mousedown on node header, select or deselect
                        if (!Selection.Contains(this.hoveredNode))
                        {
                            this.SelectNode(this.hoveredNode, e.control || e.shift);
                            if (!e.control && !e.shift)
                            {
                                this.selectedReroutes.Clear();
                            }
                        }
                        else if (e.control || e.shift)
                        {
                            this.DeselectNode(this.hoveredNode);
                        }

                        // Cache double click state, but only act on it in MouseUp - Except ClickCount only works in mouseDown.
                        this.isDoubleClick = (e.clickCount == 2);

                        e.Use();
                        currentActivity = NodeActivity.HoldNode;
                    }
                    else if (this.IsHoveringReroute)
                    {
                        // If reroute isn't selected
                        if (!this.selectedReroutes.Contains(this.hoveredReroute))
                        {
                            // Add it
                            if (e.control || e.shift)
                            {
                                this.selectedReroutes.Add(this.hoveredReroute);
                            }
                            // Select it
                            else
                            {
                                this.selectedReroutes = new List <RerouteReference>()
                                {
                                    this.hoveredReroute
                                };
                                Selection.activeObject = null;
                            }
                        }
                        // Deselect
                        else if (e.control || e.shift)
                        {
                            this.selectedReroutes.Remove(this.hoveredReroute);
                        }

                        e.Use();
                        currentActivity = NodeActivity.HoldNode;
                    }
                    // If mousedown on grid background, deselect all
                    else if (!this.IsHoveringNode)
                    {
                        currentActivity = NodeActivity.HoldGrid;
                        if (!e.control && !e.shift)
                        {
                            this.selectedReroutes.Clear();
                            Selection.activeObject = null;
                        }
                    }
                }

                break;

            case EventType.MouseUp:
                if (e.button == 0)
                {
                    //Port drag release
                    if (this.IsDraggingPort)
                    {
                        // If connection is valid, save it
                        if (this.draggedOutputTarget != null && this.draggedOutput.CanConnectTo(this.draggedOutputTarget))
                        {
                            var node = this.draggedOutputTarget.node;
                            if (this.graph.nodes.Count != 0)
                            {
                                this.draggedOutput.Connect(this.draggedOutputTarget);
                            }

                            // ConnectionIndex can be -1 if the connection is removed instantly after creation
                            var connectionIndex = this.draggedOutput.GetConnectionIndex(this.draggedOutputTarget);
                            if (connectionIndex != -1)
                            {
                                this.draggedOutput.GetReroutePoints(connectionIndex).AddRange(this.draggedOutputReroutes);
                                if (NodeEditor.onUpdateNode != null)
                                {
                                    NodeEditor.onUpdateNode(node);
                                }
                                EditorUtility.SetDirty(this.graph);
                            }
                        }
                        // Open context menu for auto-connection if there is no target node
                        else if (this.draggedOutputTarget == null && NodeEditorPreferences.GetSettings().dragToCreate&& this.autoConnectOutput != null)
                        {
                            var menu = new GenericMenu();
                            this.graphEditor.AddContextMenuItems(menu);
                            menu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
                        }

                        //Release dragged connection
                        this.draggedOutput       = null;
                        this.draggedOutputTarget = null;
                        EditorUtility.SetDirty(this.graph);
                        if (NodeEditorPreferences.GetSettings().autoSave)
                        {
                            AssetDatabase.SaveAssets();
                        }
                    }
                    else if (currentActivity == NodeActivity.DragNode)
                    {
                        var nodes = Selection.objects.Where(x => x is xNode.Node).Select(x => x as xNode.Node);
                        foreach (var node in nodes)
                        {
                            EditorUtility.SetDirty(node);
                        }
                        if (NodeEditorPreferences.GetSettings().autoSave)
                        {
                            AssetDatabase.SaveAssets();
                        }
                    }
                    else if (!this.IsHoveringNode)
                    {
                        // If click outside node, release field focus
                        if (!isPanning)
                        {
                            EditorGUI.FocusTextInControl(null);
                            EditorGUIUtility.editingTextField = false;
                        }

                        if (NodeEditorPreferences.GetSettings().autoSave)
                        {
                            AssetDatabase.SaveAssets();
                        }
                    }

                    // If click node header, select it.
                    if (currentActivity == NodeActivity.HoldNode && !(e.control || e.shift))
                    {
                        this.selectedReroutes.Clear();
                        this.SelectNode(this.hoveredNode, false);

                        // Double click to center node
                        if (this.isDoubleClick)
                        {
                            var nodeDimension = this.nodeSizes.ContainsKey(this.hoveredNode)
                                    ? this.nodeSizes[this.hoveredNode] / 2
                                    : Vector2.zero;
                            this.panOffset = -this.hoveredNode.position - nodeDimension;
                        }
                    }

                    // If click reroute, select it.
                    if (this.IsHoveringReroute && !(e.control || e.shift))
                    {
                        this.selectedReroutes = new List <RerouteReference>()
                        {
                            this.hoveredReroute
                        };
                        Selection.activeObject = null;
                    }

                    this.Repaint();
                    currentActivity = NodeActivity.Idle;
                }
                else if (e.button == 1 || e.button == 2)
                {
                    if (!isPanning)
                    {
                        if (this.IsDraggingPort)
                        {
                            this.draggedOutputReroutes.Add(this.WindowToGridPosition(e.mousePosition));
                        }
                        else if (currentActivity == NodeActivity.DragNode && Selection.activeObject == null && this.selectedReroutes.Count == 1)
                        {
                            this.selectedReroutes[0].InsertPoint(this.selectedReroutes[0].GetPoint());
                            this.selectedReroutes[0] = new RerouteReference(this.selectedReroutes[0].port, this.selectedReroutes[0].connectionIndex, this.selectedReroutes[0].pointIndex + 1);
                        }
                        else if (this.IsHoveringReroute)
                        {
                            this.ShowRerouteContextMenu(this.hoveredReroute);
                        }
                        else if (this.IsHoveringPort)
                        {
                            this.ShowPortContextMenu(this.hoveredPort);
                        }
                        else if (this.IsHoveringNode && this.IsHoveringTitle(this.hoveredNode))
                        {
                            if (!Selection.Contains(this.hoveredNode))
                            {
                                this.SelectNode(this.hoveredNode, false);
                            }
                            this.autoConnectOutput = null;
                            var menu = new GenericMenu();
                            NodeEditor.GetEditor(this.hoveredNode, this).AddContextMenuItems(menu);
                            menu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
                            e.Use();     // Fixes copy/paste context menu appearing in Unity 5.6.6f2 - doesn't occur in 2018.3.2f1 Probably needs to be used in other places.
                        }
                        else if (!this.IsHoveringNode)
                        {
                            this.autoConnectOutput = null;
                            var menu = new GenericMenu();
                            this.graphEditor.AddContextMenuItems(menu);
                            menu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
                        }
                    }

                    isPanning = false;
                }

                // Reset DoubleClick
                this.isDoubleClick = false;
                break;

            case EventType.KeyDown:
                if (EditorGUIUtility.editingTextField)
                {
                    break;
                }
                else if (e.keyCode == KeyCode.F)
                {
                    this.Home();
                }
                if (NodeEditorUtilities.IsMac())
                {
                    if (e.keyCode == KeyCode.Return)
                    {
                        this.RenameSelectedNode();
                    }
                }
                else
                {
                    if (e.keyCode == KeyCode.F2)
                    {
                        this.RenameSelectedNode();
                    }
                }

                if (e.keyCode == KeyCode.A)
                {
                    if (Selection.objects.Any(x => this.graph.nodes.Contains(x as xNode.Node)))
                    {
                        foreach (var node in this.graph.nodes)
                        {
                            this.DeselectNode(node);
                        }
                    }
                    else
                    {
                        foreach (var node in this.graph.nodes)
                        {
                            this.SelectNode(node, true);
                        }
                    }

                    this.Repaint();
                }

                break;

            case EventType.ValidateCommand:
            case EventType.ExecuteCommand:
                if (e.commandName == "SoftDelete")
                {
                    if (e.type == EventType.ExecuteCommand)
                    {
                        this.RemoveSelectedNodes();
                    }
                    e.Use();
                }
                else if (NodeEditorUtilities.IsMac() && e.commandName == "Delete")
                {
                    if (e.type == EventType.ExecuteCommand)
                    {
                        this.RemoveSelectedNodes();
                    }
                    e.Use();
                }
                else if (e.commandName == "Duplicate")
                {
                    if (e.type == EventType.ExecuteCommand)
                    {
                        this.DuplicateSelectedNodes();
                    }
                    e.Use();
                }
                else if (e.commandName == "Copy")
                {
                    if (e.type == EventType.ExecuteCommand)
                    {
                        this.CopySelectedNodes();
                    }
                    e.Use();
                }
                else if (e.commandName == "Paste")
                {
                    if (e.type == EventType.ExecuteCommand)
                    {
                        this.PasteNodes(this.WindowToGridPosition(this.lastMousePosition));
                    }
                    e.Use();
                }

                this.Repaint();
                break;

            case EventType.Ignore:
                // If release mouse outside window
                if (e.rawType == EventType.MouseUp && currentActivity == NodeActivity.DragGrid)
                {
                    this.Repaint();
                    currentActivity = NodeActivity.Idle;
                }

                break;
            }
        }
コード例 #21
0
ファイル: NodeGraphEditor.cs プロジェクト: Your-Die/xNode
 /// <summary> Returned float is used for noodle thickness </summary>
 /// <param name="output"> The output this noodle comes from. Never null. </param>
 /// <param name="input"> The output this noodle comes from. Can be null if we are dragging the noodle. </param>
 public virtual float GetNoodleThickness(xNode.NodePort output, xNode.NodePort input)
 {
     return(NodeEditorPreferences.GetSettings().noodleThickness);
 }
コード例 #22
0
ファイル: NodeEditorWindow.cs プロジェクト: Your-Die/xNode
 public NodePortReference(xNode.NodePort nodePort)
 {
     _node = nodePort.node;
     _name = nodePort.fieldName;
 }
コード例 #23
0
ファイル: NodeEditorGUILayout.cs プロジェクト: Your-Die/xNode
        /// <summary> Make a field for a serialized property. Manual node port override. </summary>
        public static void PropertyField(SerializedProperty property, GUIContent label, xNode.NodePort port, bool includeChildren = true, params GUILayoutOption[] options)
        {
            if (property == null)
            {
                throw new NullReferenceException();
            }

            // If property is not a port, display a regular property field
            if (port == null)
            {
                EditorGUILayout.PropertyField(property, label, includeChildren, GUILayout.MinWidth(30));
            }
            else
            {
                Rect rect = new Rect();

                List <PropertyAttribute> propertyAttributes = NodeEditorUtilities.GetCachedPropertyAttribs(port.node.GetType(), property.name);

                // If property is an input, display a regular property field and put a port handle on the left side
                if (port.Direction == xNode.NodePort.IO.Input)
                {
                    // Get data from [Input] attribute
                    xNode.Node.ShowBackingValue showBacking = xNode.Node.ShowBackingValue.Unconnected;
                    xNode.Node.InputAttribute   inputAttribute;
                    bool dynamicPortList = false;
                    if (NodeEditorUtilities.GetCachedAttrib(port.node.GetType(), property.name, out inputAttribute))
                    {
                        dynamicPortList = inputAttribute.dynamicPortList;
                        showBacking     = inputAttribute.backingValue;
                    }

                    bool usePropertyAttributes = dynamicPortList ||
                                                 showBacking == xNode.Node.ShowBackingValue.Never ||
                                                 (showBacking == xNode.Node.ShowBackingValue.Unconnected && port.IsConnected);

                    float  spacePadding = 0;
                    string tooltip      = null;
                    foreach (var attr in propertyAttributes)
                    {
                        if (attr is SpaceAttribute)
                        {
                            if (usePropertyAttributes)
                            {
                                GUILayout.Space((attr as SpaceAttribute).height);
                            }
                            else
                            {
                                spacePadding += (attr as SpaceAttribute).height;
                            }
                        }
                        else if (attr is HeaderAttribute)
                        {
                            if (usePropertyAttributes)
                            {
                                //GUI Values are from https://github.com/Unity-Technologies/UnityCsReference/blob/master/Editor/Mono/ScriptAttributeGUI/Implementations/DecoratorDrawers.cs
                                Rect position = GUILayoutUtility.GetRect(0, (EditorGUIUtility.singleLineHeight * 1.5f) - EditorGUIUtility.standardVerticalSpacing); //Layout adds standardVerticalSpacing after rect so we subtract it.
                                position.yMin += EditorGUIUtility.singleLineHeight * 0.5f;
                                position       = EditorGUI.IndentedRect(position);
                                GUI.Label(position, (attr as HeaderAttribute).header, EditorStyles.boldLabel);
                            }
                            else
                            {
                                spacePadding += EditorGUIUtility.singleLineHeight * 1.5f;
                            }
                        }
                        else if (attr is TooltipAttribute)
                        {
                            tooltip = (attr as TooltipAttribute).tooltip;
                        }
                    }

                    if (dynamicPortList)
                    {
                        Type type = GetType(property);
                        xNode.Node.ConnectionType connectionType = inputAttribute != null ? inputAttribute.connectionType : xNode.Node.ConnectionType.Multiple;
                        DynamicPortList(property.name, type, property.serializedObject, port.Direction, connectionType);
                        return;
                    }
                    switch (showBacking)
                    {
                    case xNode.Node.ShowBackingValue.Unconnected:
                        // Display a label if port is connected
                        if (port.IsConnected)
                        {
                            EditorGUILayout.LabelField(label != null ? label : new GUIContent(property.displayName, tooltip));
                        }
                        // Display an editable property field if port is not connected
                        else
                        {
                            EditorGUILayout.PropertyField(property, label, includeChildren, GUILayout.MinWidth(30));
                        }
                        break;

                    case xNode.Node.ShowBackingValue.Never:
                        // Display a label
                        EditorGUILayout.LabelField(label != null ? label : new GUIContent(property.displayName, tooltip));
                        break;

                    case xNode.Node.ShowBackingValue.Always:
                        // Display an editable property field
                        EditorGUILayout.PropertyField(property, label, includeChildren, GUILayout.MinWidth(30));
                        break;
                    }

                    rect = GUILayoutUtility.GetLastRect();
                    float paddingLeft = NodeEditorResources.styles.inputPort.padding.left;
                    rect.position = rect.position - new Vector2(16 + paddingLeft, -spacePadding);
                    // If property is an output, display a text label and put a port handle on the right side
                }
                else if (port.Direction == xNode.NodePort.IO.Output)
                {
                    // Get data from [Output] attribute
                    xNode.Node.ShowBackingValue showBacking = xNode.Node.ShowBackingValue.Unconnected;
                    xNode.Node.OutputAttribute  outputAttribute;
                    bool dynamicPortList = false;
                    if (NodeEditorUtilities.GetCachedAttrib(port.node.GetType(), property.name, out outputAttribute))
                    {
                        dynamicPortList = outputAttribute.dynamicPortList;
                        showBacking     = outputAttribute.backingValue;
                    }

                    bool usePropertyAttributes = dynamicPortList ||
                                                 showBacking == xNode.Node.ShowBackingValue.Never ||
                                                 (showBacking == xNode.Node.ShowBackingValue.Unconnected && port.IsConnected);

                    float  spacePadding = 0;
                    string tooltip      = null;
                    foreach (var attr in propertyAttributes)
                    {
                        if (attr is SpaceAttribute)
                        {
                            if (usePropertyAttributes)
                            {
                                GUILayout.Space((attr as SpaceAttribute).height);
                            }
                            else
                            {
                                spacePadding += (attr as SpaceAttribute).height;
                            }
                        }
                        else if (attr is HeaderAttribute)
                        {
                            if (usePropertyAttributes)
                            {
                                //GUI Values are from https://github.com/Unity-Technologies/UnityCsReference/blob/master/Editor/Mono/ScriptAttributeGUI/Implementations/DecoratorDrawers.cs
                                Rect position = GUILayoutUtility.GetRect(0, (EditorGUIUtility.singleLineHeight * 1.5f) - EditorGUIUtility.standardVerticalSpacing); //Layout adds standardVerticalSpacing after rect so we subtract it.
                                position.yMin += EditorGUIUtility.singleLineHeight * 0.5f;
                                position       = EditorGUI.IndentedRect(position);
                                GUI.Label(position, (attr as HeaderAttribute).header, EditorStyles.boldLabel);
                            }
                            else
                            {
                                spacePadding += EditorGUIUtility.singleLineHeight * 1.5f;
                            }
                        }
                        else if (attr is TooltipAttribute)
                        {
                            tooltip = (attr as TooltipAttribute).tooltip;
                        }
                    }

                    if (dynamicPortList)
                    {
                        Type type = GetType(property);
                        xNode.Node.ConnectionType connectionType = outputAttribute != null ? outputAttribute.connectionType : xNode.Node.ConnectionType.Multiple;
                        DynamicPortList(property.name, type, property.serializedObject, port.Direction, connectionType);
                        return;
                    }
                    switch (showBacking)
                    {
                    case xNode.Node.ShowBackingValue.Unconnected:
                        // Display a label if port is connected
                        if (port.IsConnected)
                        {
                            EditorGUILayout.LabelField(label != null ? label : new GUIContent(property.displayName, tooltip), NodeEditorResources.OutputPort, GUILayout.MinWidth(30));
                        }
                        // Display an editable property field if port is not connected
                        else
                        {
                            EditorGUILayout.PropertyField(property, label, includeChildren, GUILayout.MinWidth(30));
                        }
                        break;

                    case xNode.Node.ShowBackingValue.Never:
                        // Display a label
                        EditorGUILayout.LabelField(label != null ? label : new GUIContent(property.displayName, tooltip), NodeEditorResources.OutputPort, GUILayout.MinWidth(30));
                        break;

                    case xNode.Node.ShowBackingValue.Always:
                        // Display an editable property field
                        EditorGUILayout.PropertyField(property, label, includeChildren, GUILayout.MinWidth(30));
                        break;
                    }

                    rect          = GUILayoutUtility.GetLastRect();
                    rect.width   += NodeEditorResources.styles.outputPort.padding.right;
                    rect.position = rect.position + new Vector2(rect.width, spacePadding);
                }

                rect.size = new Vector2(16, 16);

                Color backgroundColor = NodeEditorWindow.current.graphEditor.GetPortBackgroundColor(port);
                Color col             = NodeEditorWindow.current.graphEditor.GetPortColor(port);
                DrawPortHandle(rect, backgroundColor, col);

                // Register the handle position
                Vector2 portPos = rect.center;
                NodeEditor.portPositions[port] = portPos;
            }
        }
コード例 #24
0
ファイル: RerouteReference.cs プロジェクト: Your-Die/xNode
 public RerouteReference(xNode.NodePort port, int connectionIndex, int pointIndex)
 {
     this.port            = port;
     this.connectionIndex = connectionIndex;
     this.pointIndex      = pointIndex;
 }
コード例 #25
0
ファイル: NodeGraphEditor.cs プロジェクト: Your-Die/xNode
 public virtual NoodleStroke GetNoodleStroke(xNode.NodePort output, xNode.NodePort input)
 {
     return(NodeEditorPreferences.GetSettings().noodleStroke);
 }