Beispiel #1
0
        public override void OnCreateConnection(NodePort from, NodePort to)
        {
            base.OnCreateConnection(from, to);

            if (from.node != this)
            {
                if (from != null && (from.node.GetType() == typeof(AI_Cond_PlayerTime) ||
                                     from.node.GetType() == typeof(AI_Cond_PlayerAniTime)))
                {
                    triggleType = CnsStateTriggerType.AnimTime;
                }
                else if ((from != null) && (from.node.GetType() == typeof(AI_Cond_PlayerAniElem)) ||
                         (from.node.GetType() == typeof(AI_Cond_PlayerAnimElemTime)))
                {
                    triggleType = CnsStateTriggerType.AnimElem;
                }

                if (from.node is AI_CreateStateDef)
                {
                    DoCreateConnect(from, to, ref parent, "parent");
                }
                else if (from.node is AI_BaseCondition)
                {
                    DoCreateConnect(from, to, ref condition, "condition");
                }
                else
                {
                    var p1 = GetPort("parent");
                    var p2 = GetPort("condition");
                    from.Disconnect(p1);
                    from.Disconnect(p2);
                }
            }
        }
 public override void OnCreateConnection(NodePort from, NodePort to)
 {
     this.DisconnectIfNotType <TrainingExamplesNode, IFeatureIML>(from, to);
     // DIRTY CODE
     // InputFeatures size check
     if (to.fieldName == "InputFeatures")
     {
         // DIRTY CODE
         // Since there is a bug in DTW rapidlib, we don't allow features of different size connected
         // If we are a training examples node for DTW...
         if (this is SeriesTrainingExamplesNode)
         {
             // If we have any features...
             if (!Lists.IsNullOrEmpty(ref InputFeatures))
             {
                 // We check that the new feature connected is not of a different size
                 int newFeatureSize = (from.node as IFeatureIML).FeatureValues.Values.Length;
                 // Get the first feature connected as the template size
                 int knownFeatureSize = (InputFeatures[0] as IFeatureIML).FeatureValues.Values.Length;
                 // Disconnect if sizes don't match
                 if (newFeatureSize != knownFeatureSize)
                 {
                     from.Disconnect(to);
                 }
             }
         }
     }
     //if connected to target values
     if (to.fieldName == "TargetValues")
     {
         // Go through MLS systems connected if any MLS are classification or DTW set MLSclassification to true
         foreach (IMLConfiguration MLS in IMLConfigurationNodesConnected)
         {
             if (MLS.LearningType == IMLSpecifications.LearningType.DTW || MLS.LearningType == IMLSpecifications.LearningType.Classification)
             {
                 MLSClassification = true;
             }
         }
         // if there is a mls classification connected and there is one or more target values break connection otherwise update list of connected wtarget values
         if (MLSClassification && TargetValues.Count >= 1)
         {
             from.Disconnect(to);
         }
         else
         {
             UpdateTargetValueInput();
         }
         MLSClassification = false;
     }
     // if you have started training and this is not the system trying to stop you changing the connection and it is an output port
     if ((TrainingExamplesVector.Count > 0 || TrainingSeriesCollection.Count > 0) && from.IsInput && !badRemove)
     {
         from.Disconnect(to);
     }
     UpdateTargetValuesConfig();
     inputPortList  = this.GetInputPort("InputFeatures").GetConnections();
     targetPortList = this.GetInputPort("TargetValues").GetConnections();
 }
Beispiel #3
0
        protected bool DoCreateConnect <T>(NodePort from, NodePort to, ref T item, string itemName, NodePort.IO dir = NodePort.IO.Input) where T : Node
        {
            // 不允许自己连接自己
            if (from.node == to.node)
            {
                from.Disconnect(to);
                return(false);
            }

            if (dir == NodePort.IO.Input)
            {
                if (from.node == this)
                {
                    return(false);
                }
            }
            else if (dir == NodePort.IO.Output)
            {
                if (from.node != this)
                {
                    return(false);
                }
            }
            else
            {
                return(false);
            }

            if (dir == NodePort.IO.Input)
            {
                if (to.fieldName != itemName)
                {
                    return(false);
                }
                item = from.node as T;
            }
            else if (dir == NodePort.IO.Output)
            {
                if (from.fieldName != itemName)
                {
                    return(false);
                }
                item = from.node as T;
            }
            else
            {
                return(false);
            }

            if (item == null)
            {
                from.Disconnect(to);
                return(false);
            }
            return(true);
        }
Beispiel #4
0
        public override void Disconnect(Edge edge)
        {
            // Copy the disconnect onto the linked data
            if (direction == Direction.Input)
            {
                target.Disconnect((edge.output as PortView).target);
            }
            else
            {
                target.Disconnect((edge.input as PortView).target);
            }

            base.Disconnect(edge);
        }
Beispiel #5
0
        /// <summary>
        /// Disconnects two nodes if types don't match (3 type evaluation)
        /// </summary>
        public static bool DisconnectIfNotType <T, U, W>(this Node node, NodePort from, NodePort to)
        {
            // Check if types are matching
            bool isValidType1 = false;
            bool isValidType2 = false;
            bool disconnect   = false;

            if (to.node is T)
            {
                isValidType1 = from.node is U;
                if (isValidType1)
                {
                    // return here since we don't need to disconnect anything
                    return(disconnect = false);
                }

                isValidType2 = from.node is W;
                if (isValidType2)
                {
                    // return here since we don't need to disconnect anything
                    return(disconnect = false);
                }

                // If we reach here, it is not a validType
                from.Disconnect(to);
                disconnect = true;
            }

            return(disconnect);
        }
Beispiel #6
0
        /// <summary>
        /// Disconnect if at least not one of the types is found in the FROM node
        /// </summary>
        /// <param name="node"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <param name="typesAccepted"></param>
        /// <returns></returns>
        public static bool DisconnectFROMPortIsNotTypes(this Node node, NodePort from, NodePort to, Type[] typesAccepted)
        {
            bool disconnect = false;

            // If not types are passed, then do nothing
            if (typesAccepted == null || typesAccepted.Length < 1)
            {
                disconnect = false;
                return(disconnect);
            }
            bool typesEqual = false;

            // If one of the types is detected as equal, don't disconnect
            for (int i = 0; i < typesAccepted.Length; i++)
            {
                typesEqual = from.ValueType.Equals(typesAccepted);
                if (typesEqual)
                {
                    disconnect = false;
                    // End search
                    return(disconnect);
                }
            }

            if (disconnect)
            {
                from.Disconnect(to);
            }

            return(disconnect);
        }
Beispiel #7
0
    public void OnBeginDrag(PointerEventData eventData)
    {
        if (port.IsOutput)
        {
            tempConnection = Instantiate(graph.runtimeConnectionPrefab);
            tempConnection.transform.SetParent(graph.scrollRect.content);
            tempConnection.SetPosition(transform.position, eventData.position);
            startPos  = transform.position;
            startPort = port;
        }
        else
        {
            if (port.IsConnected)
            {
                NodePort output = port.Connection;

                IUGUINode otherNode     = graph.GetRuntimeNode(output.node);
                UGUIPort  otherUGUIPort = otherNode.GetPort(output.fieldName, output.node);

                output.Disconnect(port);
                tempConnection = Instantiate(graph.runtimeConnectionPrefab);
                tempConnection.transform.SetParent(graph.scrollRect.content);
                tempConnection.SetPosition(otherUGUIPort.transform.position, eventData.position);
                startPos  = otherUGUIPort.transform.position;
                startPort = otherUGUIPort.port;
                graph.GetRuntimeNode(node).UpdateGUI();
            }
        }
    }
        /// <summary>
        /// Override training Examples to only check for the single training examples type
        /// </summary>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <param name="portName"></param>
        protected override void CheckTrainingExamplesConnections(NodePort from, NodePort to, string portName)
        {
            // Evaluate the nodeport for training examples
            if (to.fieldName == portName)
            {
                // Check if the node connected was a training examples node
                bool isNotTrainingExamplesNode = this.DisconnectIfNotType <CIMLConfiguration, SingleTrainingExamplesNode>(from, to);

                // If we broke the connection...
                if (isNotTrainingExamplesNode)
                {
                    // Prepare flag to show error regarding training examples
                    m_ErrorWrongInputTrainingExamplesPort = true;
                }
                // If we accept the connection...
                else
                {
                    SingleTrainingExamplesNode examplesNode = from.node as SingleTrainingExamplesNode;
                    if (examplesNode.TargetValues.Count > 1)
                    {
                        from.Disconnect(to);
                        m_WrongNumberOfTargetValues = true;
                    }
                    // We check that the connection is from a training examples node
                    if (examplesNode != null && !m_WrongNumberOfTargetValues)
                    {
                        // Update dynamic ports for output
                        AddDynamicOutputPorts(examplesNode, ref m_DynamicOutputPorts);
                    }
                }
            }
        }
Beispiel #9
0
        public override void OnCreateConnection(NodePort from, NodePort to)
        {
            base.OnCreateConnection(from, to);

            if (from != null && from.node != this)
            {
                if (from != null && from.node.GetType() == typeof(AI_Cmd))
                {
                    if (DoCreateConnect <AI_Cmd> (from, to, ref input, "input"))
                    {
                        var pp = GetPort("prevCns");
                        if (pp != null)
                        {
                            pp.ClearConnections();
                        }
                    }
                }
                else if (from != null && from.node.GetType() == typeof(AI_StateEvent_PlayCns))
                {
                    if (DoCreateConnect <AI_StateEvent_PlayCns> (from, to, ref prevCns, "prevCns"))
                    {
                        var pp = GetPort("input");
                        if (pp != null)
                        {
                            pp.ClearConnections();
                        }
                    }
                }
                else
                {
                    from.Disconnect(to);
                }
            }
        }
Beispiel #10
0
        protected override void RemoveAt(TList collection, int index)
        {
            NodePort indexPort = GetNodePort(index);

            if (indexPort == null)
            {
                Debug.LogWarning($"No port found at index {index}");
            }

            lastRemovedConnections.Clear();
            if (indexPort != null)
            {
                lastRemovedConnections.AddRange(indexPort.GetConnections());

                // Clear the removed ports connections
                indexPort.ClearConnections();
            }

            // Cache the last port because I'm about to remove it
            NodePort lastPort = GetNodePort(ChildCount - 1);

            // Move following connections one step up to replace the missing connection
            for (int k = index + 1; k < ChildCount; k++)
            {
                NodePort kPort = GetNodePort(k);
                if (kPort == null)
                {
                    continue;
                }

                NodePort k1Port = GetNodePort(k - 1);
                // Port k - 1 missing means I need to actually rename a port instead
                // Create k -1, add all the correct connections ... leave K alone because he existed
                if (k1Port == null)
                {
                    k1Port = ReplaceNodeForRemove(k - 1);
                }

                for (int j = 0; j < kPort.ConnectionCount; j++)
                {
                    NodePort other = kPort.GetConnection(j);
                    kPort.Disconnect(other);

                    k1Port.Connect(other);
                }
            }

            // Remove the last dynamic port, to avoid messing up the indexing
            if (lastPort != null)
            {
                lastPort.node.RemoveDynamicPort(lastPort);
            }

            base.RemoveAt(collection, index);

            this.ForceUpdateChildCount();
        }
Beispiel #11
0
        protected override void InsertAt(TList collection, int index, object value)
        {
            int newChildCount = this.ChildCount + 1;
            int nextId        = this.ChildCount;

            // Remove happens before insert and we lose all the connections
            // Add a new port at the end
            if (nodePortInfo.Port.IsInput)
            {
                nodePortInfo.Node.AddDynamicInput(typeof(TElement), nodePortInfo.ConnectionType, nodePortInfo.TypeConstraint, string.Format("{0} {1}", nodePortInfo.BaseFieldName, nextId));
            }
            else
            {
                nodePortInfo.Node.AddDynamicOutput(typeof(TElement), nodePortInfo.ConnectionType, nodePortInfo.TypeConstraint, string.Format("{0} {1}", nodePortInfo.BaseFieldName, nextId));
            }

            // Move everything down to make space - if something is missing just pretend we moved it?
            for (int k = newChildCount - 1; k > index; --k)
            {
                NodePort k1Port = GetNodePort(k - 1);
                if (k1Port == null)                   // It is missing, I have nothing to move
                {
                    continue;
                }

                for (int j = 0; j < k1Port.ConnectionCount; j++)
                {
                    NodePort other = k1Port.GetConnection(j);
                    k1Port.Disconnect(other);

                    NodePort kPort = GetNodePort(k);
                    if (kPort == null)
                    {
                        continue;
                    }

                    kPort.Connect(other);
                }
            }

            // Let's just re-add connections to this node that were probably his
            foreach (var c in lastRemovedConnections)
            {
                NodePort indexPort = GetNodePort(index);
                if (indexPort != null)
                {
                    indexPort.Connect(c);
                }
            }

            lastRemovedConnections.Clear();

            //if ( noDataResolver == null )
            base.InsertAt(collection, index, value);

            this.ForceUpdateChildCount();
        }
        /// <summary>Draw node's body GUI.</summary>
        public override void OnBodyGUI()
        {
            base.OnBodyGUI();

            _composite = target as BTCompositeNode;

            // Only work the GUI for the current exits and entries.
            int childCount = _composite.ChildCount;

            // Render children ports.
            EditorGUILayout.Space();

            for (int i = 0; i < childCount; i++)
            {
                BTConnection connection = _composite.GetChildConnection(i);
                NodePort     port       = target.GetOutputPort(connection.PortName);
                NodePort     connected  = port.Connection;

                if (connected == null)
                {
                    _composite.RemoveChildConnection(i);
                    i--;
                    childCount--;
                }
                else
                {
                    GUILayout.BeginHorizontal();
                    EditorGUILayout.Space();
                    NodeEditorGUILayout.PortField(new GUIContent((i + 1).ToString()), port, GUILayout.Width(50));
                    GUILayout.EndHorizontal();
                }
            }

            // Check if we need to create new exit.
            _newChild = target.GetOutputPort("newChild");
            if (_newChild == null)
            {
                _newChild = target.AddInstanceOutput(typeof(BTConnection), Node.ConnectionType.Override, Node.TypeConstraint.Inherited, "newChild");
            }

            // If exit connection is not empty create new exit.
            if (_newChild.Connection != null)
            {
                _composite.AddChildConnection(_newChild.Connection);
                _newChild.Disconnect(_newChild.Connection);
            }

            GUILayout.BeginHorizontal();
            EditorGUILayout.Space();
            NodeEditorGUILayout.PortField(_newChild, GUILayout.Width(80));
            GUILayout.EndHorizontal();
        }
Beispiel #13
0
        /// <summary>
        /// Disconnects two nodes if types don't match
        /// </summary>
        /// <typeparam name="T">Type from</typeparam>
        /// <typeparam name="U">Type to</typeparam>
        /// <param name="node"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <returns>True if disconnected. False otherwise</returns>
        public static bool DisconnectIfNotType <T, U>(this Node node, NodePort from, NodePort to)
        {
            // Check if types are matching
            bool isValidType = false;

            if (to.node is T)
            {
                isValidType = from.node is U;
                if (!isValidType)
                {
                    from.Disconnect(to);
                }
            }

            //True if disconnected.False otherwise
            return(!isValidType);
        }
Beispiel #14
0
 public override void OnCreateConnection(NodePort from, NodePort to)
 {
     if (to.fieldName == nameof(Enumerable) && to.node == this)
     {
         ClearDynamicPorts();
         ReflectionData reflectionData = GetInputValue <ReflectionData>(nameof(Enumerable));
         if (typeof(IEnumerable).IsAssignableFrom(reflectionData.Type))
         {
             Type type = reflectionData.Type.GetGenericArguments()[0];
             _argumentTypeName = type.AssemblyQualifiedName;
             AddDynamicOutput(type, ConnectionType.Multiple, TypeConstraint.Inherited, type.Name);
         }
         else
         {
             from.Disconnect(to);
         }
     }
 }
Beispiel #15
0
        /// <summary>
        /// Disconnect a Feature Extractor from a Data Type Node if the feature extracted doesn't match our expected type
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="node"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <param name="expectedType"></param>
        /// <returns></returns>
        public static bool DisconnectFeatureNotSameIMLDataType <T>(this BaseDataTypeNode <T> node, NodePort from, NodePort to, IMLSpecifications.DataTypes expectedType)
        {
            // Make sure that the feature connected is matching our type
            bool disconnect = false;

            // If it is a feature...
            if (from.node is IFeatureIML featureConnected)
            {
                // If it is a feature...
                if (featureConnected != null)
                {
                    // Check that dataType is the same as the expected one
                    if (featureConnected.FeatureValues.DataType != expectedType)
                    {
                        from.Disconnect(to);
                        disconnect = true;
                    }
                }
            }
            return(disconnect);
        }
Beispiel #16
0
        /// <summary>
        /// Disconnects if ANY of the FROM port or node don't meet type requirements
        /// </summary>
        /// <param name="node"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <param name="typesPort"></param>
        /// <param name="typesNode"></param>
        /// <returns></returns>
        public static bool DisconnectPortAndNodeIfANYTypes(this Node node, NodePort from, NodePort to, Type[] typesPort, Type[] typesNode)
        {
            // Init equals
            bool equalPorts    = true;
            bool equalNodeType = true;

            // If null or empty, allow connections
            // Port Types
            if (typesPort == null && typesPort.Length < 1)
            {
                equalPorts = false;
            }
            else
            {
                equalPorts = CheckPortEqualTypes(node, from, to, typesPort);
            }

            // Node Types
            if (typesNode == null && typesNode.Length < 1)
            {
                equalNodeType = false;
            }
            else
            {
                equalNodeType = CheckNodeEqualTypes(node, from, to, typesNode);
            }

            // If any of them is true, DO disconnect
            if (equalPorts || equalNodeType)
            {
                from.Disconnect(to);
                return(true);
            }
            // If all of them are false, DON'T disconnect
            else
            {
                return(false);
            }
        }
Beispiel #17
0
        /// <summary>
        /// Disconnect two IML Data Types if they are not equal
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="node"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <param name="expectedType"></param>
        /// <returns></returns>
        public static bool DisconnectIfNotSameIMLDataType <T>(this BaseDataTypeNode <T> node, NodePort from, NodePort to, IMLSpecifications.DataTypes expectedType)
        {
            // Make sure that the IMLDataType connected is matching our type
            bool disconnect = false;

            // If it is a IMLDataType, check that it is the exact same one
            if (from.node.GetType().Equals(typeof(IMLBaseDataType)))
            {
                var featureConnected = from.node as IFeatureIML;
                // If it is a feature...
                if (featureConnected != null)
                {
                    // Check that dataType is the same as the expected one
                    if (featureConnected.FeatureValues.DataType != expectedType)
                    {
                        from.Disconnect(to);
                        disconnect = true;
                    }
                }
            }
            return(disconnect);
        }
Beispiel #18
0
    public void UpdateConnectionTransforms()
    {
        if (port.IsInput)
        {
            return;
        }

        while (connections.Count < port.ConnectionCount)
        {
            AddConnection();
        }
        while (connections.Count > port.ConnectionCount)
        {
            Destroy(connections[0].gameObject);
            connections.RemoveAt(0);
        }

        // Loop through connections
        for (int i = port.ConnectionCount - 1; i >= 0; i--)
        {
            NodePort  other     = port.GetConnection(i);
            IUGUINode otherNode = graph.GetRuntimeNode(other.node);
            if (otherNode == null)
            {
                Debug.LogWarning(other.node.name + " node not found ||| " + other.node, this);
                port.Disconnect(i);
                continue;
            }

            Transform port2 = otherNode.GetPort(other.fieldName, other.node).transform;
            if (!port2)
            {
                Debug.LogWarning(other.fieldName + " not found", this);
            }
            connections[i].SetPosition(transform.position, port2.position);
        }
    }
Beispiel #19
0
        /// <summary>
        /// Disconnects two nodes if two Data Type Nodes are not exactly the same
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="node"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public static bool DisconnectIfNotSameDataTypeNode <T> (this BaseDataTypeNode <T> node, NodePort from, NodePort to)
        {
            bool disconnect = false;
            // Check if types are matching
            Type nodeConnectedType = from.node.GetType();
            // Check if the from node is a dataType
            var isDataType = ReusableMethods.Types.IsSubclassOfRawGeneric(typeof(BaseDataTypeNode <>), nodeConnectedType);

            // If it is a dataType...
            if (isDataType)
            {
                // Check if both from and to are the same dataType
                var isSameType = nodeConnectedType.Equals(node.GetType());
                // If not (i.e. a float vs a Vector3)
                if (!isSameType)
                {
                    // We disconnect the nodes
                    from.Disconnect(to);
                    disconnect = true;
                }
            }

            return(disconnect);
        }
Beispiel #20
0
        public void Controls()
        {
            wantsMouseMove = true;
            Event e = Event.current;

            switch (e.type)
            {
            case EventType.MouseMove:
                break;

            case EventType.ScrollWheel:
                if (e.delta.y > 0)
                {
                    zoom += 0.1f * zoom;
                }
                else
                {
                    zoom -= 0.1f * zoom;
                }
                break;

            case EventType.MouseDrag:
                if (e.button == 0)
                {
                    if (IsDraggingPort)
                    {
                        if (IsHoveringPort && hoveredPort.IsInput)
                        {
                            if (!draggedOutput.IsConnectedTo(hoveredPort))
                            {
                                draggedOutputTarget = hoveredPort;
                            }
                        }
                        else
                        {
                            draggedOutputTarget = null;
                        }
                        Repaint();
                    }
                    else if (IsDraggingNode)
                    {
                        draggedNode.position = WindowToGridPosition(e.mousePosition) + dragOffset;
                        Repaint();
                    }
                }
                else if (e.button == 1)
                {
                    panOffset += e.delta * zoom;
                    isPanning  = true;
                }
                break;

            case EventType.KeyDown:
                if (GUIUtility.keyboardControl == 0)
                {
                    break;
                }
                else if (e.keyCode == KeyCode.F)
                {
                    Home();
                }
                break;

            case EventType.MouseDown:
                Repaint();
                if (e.button == 0)
                {
                    SelectNode(hoveredNode);
                    if (IsHoveringPort)
                    {
                        if (hoveredPort.IsOutput)
                        {
                            draggedOutput = hoveredPort;
                        }
                        else
                        {
                            hoveredPort.VerifyConnections();
                            if (hoveredPort.IsConnected)
                            {
                                Node     node   = hoveredPort.node;
                                NodePort output = hoveredPort.Connection;
                                hoveredPort.Disconnect(output);
                                draggedOutput       = output;
                                draggedOutputTarget = hoveredPort;
                                if (NodeEditor.onUpdateNode != null)
                                {
                                    NodeEditor.onUpdateNode(node);
                                }
                            }
                        }
                    }
                    else if (IsHoveringNode && IsHoveringTitle(hoveredNode))
                    {
                        draggedNode = hoveredNode;
                        dragOffset  = hoveredNode.position - WindowToGridPosition(e.mousePosition);
                    }
                }
                break;

            case EventType.MouseUp:
                if (e.button == 0)
                {
                    //Port drag release
                    if (IsDraggingPort)
                    {
                        //If connection is valid, save it
                        if (draggedOutputTarget != null)
                        {
                            Node node = draggedOutputTarget.node;
                            if (graph.nodes.Count != 0)
                            {
                                draggedOutput.Connect(draggedOutputTarget);
                            }
                            if (NodeEditor.onUpdateNode != null)
                            {
                                NodeEditor.onUpdateNode(node);
                            }
                            EditorUtility.SetDirty(graph);
                        }
                        //Release dragged connection
                        draggedOutput       = null;
                        draggedOutputTarget = null;
                        EditorUtility.SetDirty(graph);
                        Repaint();
                        AssetDatabase.SaveAssets();
                    }
                    else if (IsDraggingNode)
                    {
                        draggedNode = null;
                        AssetDatabase.SaveAssets();
                    }
                    else if (GUIUtility.hotControl != 0)
                    {
                        AssetDatabase.SaveAssets();
                    }
                }
                else if (e.button == 1)
                {
                    if (!isPanning)
                    {
                        ShowContextMenu();
                    }
                    isPanning = false;
                }
                break;
            }
        }
Beispiel #21
0
    public void Controls()
    {
        wantsMouseMove = true;

        Event e = Event.current;

        switch (e.type)
        {
        case EventType.MouseMove:
            UpdateHovered();
            break;

        case EventType.ScrollWheel:
            if (e.delta.y > 0)
            {
                zoom += 0.1f * zoom;
            }
            else
            {
                zoom -= 0.1f * zoom;
            }
            break;

        case EventType.MouseDrag:
            UpdateHovered();
            if (e.button == 0)
            {
                if (IsDraggingPort)
                {
                    if (IsHoveringPort && hoveredPort.IsInput)
                    {
                        if (!draggedOutput.IsConnectedTo(hoveredPort))
                        {
                            draggedOutputTarget = hoveredPort;
                        }
                    }
                    else
                    {
                        draggedOutputTarget = null;
                    }
                    Repaint();
                }
                else if (IsDraggingNode)
                {
                    draggedNode.rect.position = WindowToGridPosition(e.mousePosition) + dragOffset;
                    Repaint();
                }
            }
            else if (e.button == 1)
            {
                panOffset += e.delta * zoom;
                isPanning  = true;
            }
            break;

        case EventType.KeyDown:
            if (e.keyCode == KeyCode.F)
            {
                Home();
            }
            break;

        case EventType.MouseDown:
            UpdateHovered();
            Repaint();
            SelectNode(hoveredNode);
            if (IsHoveringPort)
            {
                if (hoveredPort.IsOutput)
                {
                    draggedOutput = hoveredPort;
                }
                else
                {
                    if (hoveredPort.IsConnected)
                    {
                        NodePort output = hoveredPort.Connection;
                        hoveredPort.Disconnect(output);
                        draggedOutput       = output;
                        draggedOutputTarget = hoveredPort;
                    }
                }
            }
            else if (IsHoveringNode && IsHoveringTitle(hoveredNode))
            {
                draggedNode = hoveredNode;
                dragOffset  = hoveredNode.rect.position - WindowToGridPosition(e.mousePosition);
            }
            break;

        case EventType.MouseUp:
            if (e.button == 0)
            {
                //Port drag release
                if (IsDraggingPort)
                {
                    //If connection is valid, save it
                    if (draggedOutputTarget != null)
                    {
                        if (graph.nodes.Count != 0)
                        {
                            draggedOutput.Connect(draggedOutputTarget);
                        }
                    }
                    //Release dragged connection
                    draggedOutput       = null;
                    draggedOutputTarget = null;
                    Repaint();
                }
                else if (IsDraggingNode)
                {
                    draggedNode = null;
                }
            }
            else if (e.button == 1)
            {
                if (!isPanning)
                {
                    ShowContextMenu();
                }
                isPanning = false;
            }
            UpdateHovered();
            break;
        }
    }
Beispiel #22
0
        protected bool DoCreateConnectToList <T>(NodePort from, NodePort to, ref List <T> condList, string condListName, NodePort.IO dir = NodePort.IO.Input) where T : Node
        {
            // 不允许自己连接自己
            if (from.node == to.node)
            {
                from.Disconnect(to);
                return(false);
            }

            if (dir == NodePort.IO.Input)
            {
                if (from.node == this)
                {
                    return(false);
                }
            }
            else if (dir == NodePort.IO.Output)
            {
                if (from.node != this)
                {
                    return(false);
                }
            }
            else
            {
                return(false);
            }

            T item = default(T);

            if (dir == NodePort.IO.Input)
            {
                if (to.fieldName != condListName)
                {
                    return(false);
                }
                item = from.node as T;
            }
            else if (dir == NodePort.IO.Output)
            {
                if (from.fieldName != condListName)
                {
                    return(false);
                }
                item = from.node as T;
            }
            else
            {
                return(false);
            }

            if (item != null)
            {
                if (condList == null)
                {
                    condList = new List <T> ();
                }
                T cc = from.node as T;
                if (!condList.Contains(cc))
                {
                    condList.Add(cc);
                }
                return(true);
            }
            else
            {
                from.Disconnect(to);
            }

            return(false);
        }
        /// <summary>Draw transition ports.</summary>
        protected virtual void OnTransitionsGUI()
        {
            _state = target as FSMStateNode;

            // Only work the GUI for the current exits and entries.
            int exitCount  = _state.ExitsCount;
            int entryCount = _state.EntriesCount;

            // Check if we need to create new entry.
            _entry = target.GetInputPort("entry");
            if (_entry == null)
            {
                _entry = target.AddInstanceInput(typeof(FSMConnection), Node.ConnectionType.Override, Node.TypeConstraint.Inherited, "entry");
            }

            // If entry connection is not empty create new entry.
            if (_entry.Connection != null)
            {
                _state.AddEntryConnection(_entry.Connection);
                _entry.Disconnect(_entry.Connection);
            }

            // Check if we need to create new exit.
            _exit = target.GetOutputPort("exit");
            if (_exit == null)
            {
                _exit = target.AddInstanceOutput(typeof(FSMConnection), Node.ConnectionType.Override, Node.TypeConstraint.Inherited, "exit");
            }

            // If exit connection is not empty create new exit.
            if (_exit.Connection != null)
            {
                _state.AddExitConnection(_exit.Connection);
                _exit.Disconnect(_exit.Connection);
            }

            GUILayout.BeginHorizontal();
            NodeEditorGUILayout.PortField(_entry, GUILayout.Width(50));
            EditorGUILayout.Space();
            NodeEditorGUILayout.PortField(_exit, GUILayout.Width(50));
            GUILayout.EndHorizontal();

            EditorGUILayout.Space();
            for (int i = 0; i < entryCount; i++)
            {
                FSMConnection connection = _state.GetEntryConnection(i);
                NodePort      port       = target.GetInputPort(connection.PortName);
                NodePort      connected  = port.Connection;

                if (connected == null)
                {
                    _state.RemoveEntryConnection(i);
                    i--;
                    entryCount--;
                }
                else
                {
                    GUILayout.BeginHorizontal();
                    NodeEditorGUILayout.PortField(new GUIContent(), port, GUILayout.Width(-4));
                    EditorGUILayout.LabelField(string.Format("> {0}", connected.node.name));
                    GUILayout.EndHorizontal();
                }
            }

            EditorGUILayout.Space();

            for (int i = 0; i < exitCount; i++)
            {
                FSMConnection connection = _state.GetExitConnection(i);
                NodePort      port       = target.GetOutputPort(connection.PortName);
                NodePort      connected  = port.Connection;

                if (connected == null)
                {
                    _state.RemoveExitConnection(i);
                    i--;
                    exitCount--;
                }
                else
                {
                    GUILayout.BeginHorizontal();
                    EditorGUILayout.Space();
                    NodeEditorGUILayout.PortField(new GUIContent(), port, GUILayout.Width(50));
                    GUILayout.EndHorizontal();
                }
            }
        }
Beispiel #24
0
        private void DrawStateNode(int maxChildCount)
        {
            int childCount = _FTNode.ChildCount;

            for (int i = 0; i < childCount; i++)
            {
                FTConnection connection = _FTNode.GetChildConnection(i);
                NodePort     port       = target.GetOutputPort(connection.portName);
                NodePort     connected  = port.Connection;

                if (connected == null)
                {
                    _FTNode.RemoveChildConnection(i);
                    i--;
                    childCount--;
                }
                else
                {
                    //GUILayout.BeginArea(new Rect(50f, 50f + i * 100f, 100f, 100f));
                    EditorGUILayout.BeginVertical("Box");
                    {
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.Space();
                        NodeEditorGUILayout.PortField(new GUIContent("To" + (i + 1)), port, GUILayout.Width(50));
                        EditorGUILayout.EndHorizontal();

                        // GUILayout.Button("XXX");
                        var           fsms  = FTUtils.GetFSMTransitionMethod("ActorFSM");
                        List <string> names = new List <string>();
                        foreach (var tp  in fsms)
                        {
                            names.Add(tp.ToString());
                        }

                        EditorGUILayout.Popup(0, names.ToArray());
                    }
                    EditorGUILayout.EndVertical();
                    //GUILayout.EndArea();
                }
            }

            // if (NodeEditorWindow.mode == NodeEditorMode.Edit && childCount < maxChildCount)
            if (childCount < maxChildCount)
            {
                _outputNewChild = target.GetOutputPort(OUTPUT_PORT_NEWCHILD);
                if (_outputNewChild == null)
                {
                    _outputNewChild = target.AddDynamicOutput(typeof(FTConnection), Node.ConnectionType.Override, Node.TypeConstraint.Inherited, OUTPUT_PORT_NEWCHILD);
                }

                if (_outputNewChild.Connection != null)
                {
                    _FTNode.AddChildConnection(_outputNewChild.Connection);
                    _outputNewChild.Disconnect(_outputNewChild.Connection);
                    EditorUtility.SetDirty(target);
                }

                GUILayout.BeginHorizontal();
                EditorGUILayout.Space();
                NodeEditorGUILayout.PortField(_outputNewChild, GUILayout.Width(80));
                GUILayout.EndHorizontal();
            }
        }