void CreateDataEdge(List <Node> nodes, ActorLink link)
        {
            var outputNode = nodes.FirstOrDefault(x => ((ActorSetup)x.userData).Outputs.Any(x => x.Id == link.OutputId));
            var inputNode  = nodes.FirstOrDefault(x => ((ActorSetup)x.userData).Inputs.Any(x => x.Id == link.InputId));

            if (outputNode == null || inputNode == null)
            {
                return;
            }

            var outputPort = outputNode.Q <Port>(link.OutputId);
            var inputPort  = inputNode.Q <Port>(link.InputId);

            if (outputPort == null || inputPort == null)
            {
                return;
            }

            var edge = outputPort.ConnectTo <CustomEdge>(inputPort);

            edge.userData = link;

            if (link.IsRemoved)
            {
                edge.EdgeState = EdgeState.Deleted;
            }

            AddElement(edge);
        }
Ejemplo n.º 2
0
        public static void Connect <TComponent, TMessage>(this ActorSystemSetup actorSystemSetup,
                                                          ActorSetup outputActorSetup, ActorSetup inputActorSetup)
        {
            var componentConfig = actorSystemSetup.GetComponentConfig <TComponent>();
            var messageTypeName = typeof(TMessage).ToString();

            var outputActorConfig = actorSystemSetup.GetActorConfig(outputActorSetup);
            var inputActorConfig  = actorSystemSetup.GetActorConfig(inputActorSetup);

            var outputPortConfig = outputActorConfig.OutputConfigs.First(x =>
                                                                         x.ComponentConfigId == componentConfig.Id && x.MessageTypeNormalizedFullName == messageTypeName);
            var inputPortConfig = inputActorConfig.InputConfigs.First(x =>
                                                                      x.ComponentConfigId == componentConfig.Id && x.MessageTypeNormalizedFullName == messageTypeName);

            var outputPort = outputActorSetup.Outputs.First(x => x.ConfigId == outputPortConfig.Id);
            var inputPort  = inputActorSetup.Inputs.First(x => x.ConfigId == inputPortConfig.Id);

            var link = new ActorLink(outputPort.Id, inputPort.Id, false);

            outputPort.Links.Add(link);
            inputPort.Links.Add(link);
        }
        GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
        {
            if (graphViewChange.elementsToRemove != null)
            {
                foreach (var element in graphViewChange.elementsToRemove)
                {
                    if (element is Node)
                    {
                        var setup = (ActorSetup)element.userData;
                        m_Asset.ActorSetups.Remove(setup);
                    }
                    else if (element is CustomEdge edge)
                    {
                        if (edge.userData is ActorLink link)
                        {
                            var inputSetup  = (ActorSetup)edge.input.node.userData;
                            var outputSetup = (ActorSetup)edge.output.node.userData;

                            var input = inputSetup.Inputs.FirstOrDefault(x => x.Id == link.InputId);
                            input?.Links.Remove(link);
                            var output = outputSetup.Outputs.FirstOrDefault(x => x.Id == link.OutputId);
                            output?.Links.Remove(link);

                            if (input != null)
                            {
                                var inputActorConfig     = m_Asset.ActorConfigs.First(x => x.Id == inputSetup.ConfigId);
                                var inputConfig          = inputActorConfig.InputConfigs.First(x => x.Id == input.ConfigId);
                                var inputComponentConfig = m_Asset.ComponentConfigs.First(x => x.Id == inputConfig.ComponentConfigId);
                                var inputMultiplicity    = inputComponentConfig.InputMultiplicity;
                                input.IsValid = MultiplicityValidator.IsValid(inputMultiplicity, input.Links.Count);
                                SetPortColor(edge.input, input);
                            }

                            if (output != null)
                            {
                                var outputActorConfig     = m_Asset.ActorConfigs.First(x => x.Id == outputSetup.ConfigId);
                                var outputConfig          = outputActorConfig.OutputConfigs.First(x => x.Id == output.ConfigId);
                                var outputComponentConfig = m_Asset.ComponentConfigs.First(x => x.Id == outputConfig.ComponentConfigId);
                                var outputMultiplicity    = outputComponentConfig.OutputMultiplicity;
                                output.IsValid = MultiplicityValidator.IsValid(outputMultiplicity, output.Links.Count);
                                SetPortColor(edge.output, output);
                            }
                        }
                    }
                    RemoveElement(element);
                }
            }

            if (graphViewChange.edgesToCreate != null)
            {
                foreach (var e in graphViewChange.edgesToCreate)
                {
                    var edge   = (CustomEdge)e;
                    var input  = (ActorPort)edge.input.userData;
                    var output = (ActorPort)edge.output.userData;

                    var link = new ActorLink(output.Id, input.Id, output.IsRemoved || input.IsRemoved);
                    input.Links.Add(link);
                    output.Links.Add(link);

                    edge.userData = link;
                    if (link.IsRemoved)
                    {
                        edge.EdgeState = EdgeState.Deleted;
                    }

                    if (!link.IsRemoved)
                    {
                        if (!input.IsRemoved)
                        {
                            var inputSetup           = (ActorSetup)edge.input.node.userData;
                            var inputActorConfig     = m_Asset.ActorConfigs.First(x => x.Id == inputSetup.ConfigId);
                            var inputConfig          = inputActorConfig.InputConfigs.First(x => x.Id == input.ConfigId);
                            var inputComponentConfig = m_Asset.ComponentConfigs.First(x => x.Id == inputConfig.ComponentConfigId);
                            var inputMultiplicity    = inputComponentConfig.InputMultiplicity;
                            input.IsValid = MultiplicityValidator.IsValid(inputMultiplicity, input.Links.Count);
                            SetPortColor(edge.input, input);
                        }

                        if (!output.IsRemoved)
                        {
                            var outputSetup           = (ActorSetup)edge.output.node.userData;
                            var outputActorConfig     = m_Asset.ActorConfigs.First(x => x.Id == outputSetup.ConfigId);
                            var outputConfig          = outputActorConfig.OutputConfigs.First(x => x.Id == output.ConfigId);
                            var outputComponentConfig = m_Asset.ComponentConfigs.First(x => x.Id == outputConfig.ComponentConfigId);
                            var outputMultiplicity    = outputComponentConfig.OutputMultiplicity;
                            output.IsValid = MultiplicityValidator.IsValid(outputMultiplicity, output.Links.Count);
                            SetPortColor(edge.output, output);
                        }
                    }

                    AddElement(edge, true);
                }
            }

            if (graphViewChange.movedElements != null)
            {
                foreach (var element in graphViewChange.movedElements)
                {
                    if (element is Node)
                    {
                        ((ActorSetup)element.userData).Position = element.GetPosition().position;
                    }
                }
            }

            return(graphViewChange);
        }