public override void OnDisconnection(IPortModel selfConnectedPortModel, IPortModel otherConnectedPortModel) { if (selfConnectedPortModel.Direction != Direction.Input || selfConnectedPortModel.PortType != PortType.Instance) { return; } ((PortModel)selfConnectedPortModel).DataType = TypeHandle.Unknown; }
public CreateEdgeAction(IPortModel inputPortModel, IPortModel outputPortModel, List <IEdgeModel> edgeModelsToDelete = null) { Assert.IsTrue(inputPortModel.Direction == Direction.Input); Assert.IsTrue(outputPortModel.Direction == Direction.Output); InputPortModel = inputPortModel; OutputPortModel = outputPortModel; EdgeModelsToDelete = edgeModelsToDelete; }
void Reset() { m_Active = false; m_Edge = null; m_ConnectedEdgeDragHelper = null; m_AdditionalEdgeDragHelpers = null; m_DetachedPort = null; m_DetachedFromInputPort = false; }
public CreateStackedNodeFromOutputPortAction(IPortModel portModel, IStackModel stackModel, int index, StackNodeModelSearcherItem selectedItem, IEnumerable <IGTFEdgeModel> edgesToDelete = null) { PortModel = portModel; StackModel = stackModel; Index = index; SelectedItem = selectedItem; EdgesToDelete = edgesToDelete ?? Enumerable.Empty <IGTFEdgeModel>(); }
protected override void OnDefineNode() { Input0 = AddDataInput <int>("input0"); Input1 = AddDataInput <int>("input1"); Input2 = AddDataInput <int>("input2"); Output0 = AddDataOutputPort <int>("output0"); Output1 = AddDataOutputPort <int>("output1"); Output2 = AddDataOutputPort <int>("output2"); }
protected override void OnDefineNode() { EntityPort = AddDataInput <Entity>("entity"); if (ComponentType != TypeHandle.Unknown) { m_ComponentDescription = AddPortsForComponent(ComponentType); } }
public override void OnConnection(IPortModel selfConnectedPortModel, IPortModel otherConnectedPortModel) { if (ReferenceEquals(InstancePort, selfConnectedPortModel)) { TypeHandle t = otherConnectedPortModel?.DataTypeHandle ?? TypeHandle.Unknown; InstancePort.DataTypeHandle = t; ValuePort.DataTypeHandle = t; } }
static void CreateNodes(Store store, IPortModel portModel, Vector2 position, IEnumerable <IEdgeModel> edgesToDelete, IStackModel stackModel, int index, IGroupNodeModel groupModel) { switch (portModel.PortType) { case PortType.Data: case PortType.Instance: switch (portModel.Direction) { case Direction.Output when stackModel != null: if (portModel.DataType != TypeHandle.Unknown) { SearcherService.ShowOutputToStackNodes( store.GetState(), stackModel, portModel, position, item => { store.Dispatch(new CreateStackedNodeFromOutputPortAction( portModel, stackModel, index, item, edgesToDelete, groupModel)); }); } break; case Direction.Output: SearcherService.ShowOutputToGraphNodes(store.GetState(), portModel, position, item => { store.Dispatch(new CreateNodeFromOutputPortAction( portModel, position, item, edgesToDelete, groupModel)); }); break; case Direction.Input: SearcherService.ShowInputToGraphNodes(store.GetState(), portModel, position, item => { store.Dispatch(new CreateNodeFromInputPortAction( portModel, position, item, edgesToDelete, groupModel)); }); break; default: throw new ArgumentOutOfRangeException(); } break; case PortType.Execution: if (portModel.NodeModel is LoopStackModel loopStack && portModel.Direction == Direction.Input) { if (stackModel != null) { store.Dispatch(new CreateInsertLoopNodeAction( portModel, stackModel, index, loopStack, edgesToDelete, groupModel)); } } else { store.Dispatch(new CreateNodeFromExecutionPortAction( portModel, position, edgesToDelete, groupModel)); } break;
public CreateVariableNodesAction(IVariableDeclarationModel graphElementModel, Vector2 mousePosition, IEnumerable <IEdgeModel> edgeModelsToDelete = null, IPortModel connectAfterCreation = null, IGroupNodeModel groupModel = null, bool autoAlign = false) { VariablesToCreate = new List <Tuple <IVariableDeclarationModel, Vector2> >(); VariablesToCreate.Add(Tuple.Create(graphElementModel, mousePosition)); EdgeModelsToDelete = edgeModelsToDelete; ConnectAfterCreation = connectAfterCreation; GroupModel = groupModel; AutoAlign = autoAlign; }
public CreateInsertLoopNodeAction(IPortModel portModel, IStackModel stackModel, int index, LoopStackModel loopStackModel, IEnumerable <IEdgeModel> edgesToDelete = null) { PortModel = portModel; StackModel = stackModel; Index = index; LoopStackModel = loopStackModel; EdgesToDelete = edgesToDelete ?? Enumerable.Empty <IEdgeModel>(); }
public static SyntaxNode GetProperty(RoslynTranslator translator, IPortModel instancePortModel, params string[] members) { ExpressionSyntax instance = instancePortModel.Connected ? translator.BuildPort(instancePortModel).FirstOrDefault() as ExpressionSyntax : SyntaxFactory.ThisExpression(); return(GetProperty(instance, members)); }
public CreateEdgeAction(IPortModel inputPortModel, IPortModel outputPortModel, IEnumerable <IEdgeModel> edgeModelsToDelete = null, PortAlignmentType portAlignment = PortAlignmentType.None) { Assert.IsTrue(inputPortModel.Direction == Direction.Input); Assert.IsTrue(outputPortModel.Direction == Direction.Output); InputPortModel = inputPortModel; OutputPortModel = outputPortModel; EdgeModelsToDelete = edgeModelsToDelete; PortAlignment = portAlignment; }
public CreateNodeFromInputPortAction(IPortModel portModel, Vector2 position, GraphNodeModelSearcherItem selectedItem, IEnumerable <IEdgeModel> edgesToDelete = null, IGroupNodeModel groupModel = null) { PortModel = portModel; Position = position; SelectedItem = selectedItem; EdgesToDelete = edgesToDelete ?? Enumerable.Empty <IEdgeModel>(); GroupModel = groupModel; }
private static Port GetPortFromPortModel(IPortModel port, Unity.GraphElements.Node nodeUi) { Unity.GraphElements.Node n = nodeUi; var portContainer = port.Direction == Direction.Output ? n.outputContainer : n.inputContainer; Port p = portContainer.childCount > 0 ? portContainer.Query <Port>().Where(x => x.Model == port).First() : null; return(p); }
public static SyntaxNode SetProperty(RoslynTranslator translator, AssignmentKind kind, IPortModel instancePortModel, IPortModel valuePortModel, params string[] members) { ExpressionSyntax instance = instancePortModel.Connected ? translator.BuildPort(instancePortModel).FirstOrDefault() as ExpressionSyntax : SyntaxFactory.ThisExpression(); ExpressionSyntax value = translator.BuildPort(valuePortModel).FirstOrDefault() as ExpressionSyntax; return(SetProperty(kind, instance, value, members)); }
public bool GetComponentFromEntityOrComponentPort( INodeModel model, IPortModel entityOrComponentPort, out ComponentQueryDeclarationModel query, out ExpressionSyntax setValue, AccessMode mode = AccessMode.Read) { setValue = null; var componentVariableType1 = entityOrComponentPort.DataType; var varNode = !entityOrComponentPort.Connected ? context.IterationContext.Query.ItemVariableDeclarationModel : (entityOrComponentPort.ConnectionPortModels?.FirstOrDefault()?.NodeModel as VariableNodeModel)?.DeclarationModel; if (varNode != null && varNode.DataType == typeof(Entity).GenerateTypeHandle(Stencil) && varNode.Owner is IIteratorStackModel iteratorStackModel) { query = iteratorStackModel.ComponentQueryDeclarationModel; if (query.Components.Any(x => x.Component.TypeHandle == componentVariableType1)) { context.RecordComponentAccess(context.IterationContext, componentVariableType1, mode); var componentVarName = context.GetComponentVariableName(iteratorStackModel, componentVariableType1); setValue = IdentifierName(componentVarName); } else { var componentName = componentVariableType1.Resolve(Stencil).FriendlyName(); var queryCopy = query; AddError(model, $"A component of type {componentName} is required, which the query {query.Name} doesn't specify", new CompilerQuickFix($"Add {componentName} to the query", s => s.Dispatch(new AddComponentToQueryAction( queryCopy, componentVariableType1, ComponentDefinitionFlags.None))) ); return(false); } } if (setValue == null) { context.RecordComponentAccess(context.IterationContext, componentVariableType1, mode); setValue = BuildPort(entityOrComponentPort).FirstOrDefault() as ExpressionSyntax; } query = null; return(true); }
static State ChangeStackedNode(State previousState, ChangeStackedNodeAction action) { var graphModel = ((VSGraphModel)previousState.CurrentGraphModel); // Remove old node int index = -1; if (action.OldNodeModel != null) { index = action.StackModel.NodeModels.IndexOf(action.OldNodeModel); } Undo.RegisterCompleteObjectUndo((Object)graphModel.AssetModel, "Change Stacked Node"); // Add new node action.SelectedItem.CreateElements.Invoke(new StackNodeCreationData(action.StackModel, index)); // Reconnect edges var newNodeModel = action.StackModel.NodeModels.ElementAt(index); if (action.OldNodeModel != null) { var oldInputs = action.OldNodeModel.InputsByDisplayOrder.ToList(); var newInputs = newNodeModel.InputsByDisplayOrder.ToList(); for (var i = 0; i < oldInputs.Count; ++i) { IPortModel oldInputPort = oldInputs[i]; if (i < newInputs.Count) { foreach (var edge in graphModel.GetEdgesConnections(oldInputPort).Cast <EdgeModel>()) { edge.SetFromPortModels(newInputs[i], edge.OutputPortModel); } } else { var edges = graphModel.GetEdgesConnections(oldInputPort); graphModel.DeleteEdges(edges); break; } } // delete after edge patching or undo/redo will fail var parentStack = (StackBaseModel)action.StackModel; graphModel.DeleteNode(action.OldNodeModel, GraphModel.DeleteConnections.False); if (parentStack.Capabilities.HasFlag(CapabilityFlags.DeletableWhenEmpty) && parentStack != (StackBaseModel)action.StackModel && !parentStack.NodeModels.Any()) { graphModel.DeleteNode(parentStack, GraphModel.DeleteConnections.True); } } return(previousState); }
public IEnumerator EdgeConnectDragMultipleEdgesFromExecutionPortInputToOutputWorks() { IONodeModel exeStartNode = CreateNode("First Out Exe node", new Vector2(100, 100), 0, 0, 0, 1); IONodeModel exeStartNode2 = CreateNode("Second Out Exe node", new Vector2(100, 400), 0, 0, 0, 1); IONodeModel exeEndNode = CreateNode("First In Exe node", new Vector2(400, 100), 0, 0, 1, 0); IONodeModel exeEndNode2 = CreateNode("Second In Exe node", new Vector2(400, 400), 0, 0, 1, 0); IPortModel startPort = exeStartNode.GetPorts(PortDirection.Output, PortType.Execution).First(); IPortModel startPort2 = exeStartNode2.GetPorts(PortDirection.Output, PortType.Execution).First(); IPortModel endPort = exeEndNode.GetPorts(PortDirection.Input, PortType.Execution).First(); IPortModel endPort2 = exeEndNode2.GetPorts(PortDirection.Input, PortType.Execution).First(); // We start without any connection Assert.AreEqual(0, startPort.GetConnectedEdges().Count()); Assert.AreEqual(0, endPort.GetConnectedEdges().Count()); Assert.AreEqual(0, endPort2.GetConnectedEdges().Count()); MarkGraphViewStateDirty(); yield return(null); Port startPortUI = startPort.GetUI <Port>(graphView); Port startPort2UI = startPort2.GetUI <Port>(graphView); Port endPortUI = endPort.GetUI <Port>(graphView); Port endPort2UI = endPort2.GetUI <Port>(graphView); // Drag an edge between the two ports helpers.DragTo(startPortUI.GetGlobalCenter(), endPortUI.GetGlobalCenter()); helpers.DragTo(startPort2UI.GetGlobalCenter(), endPortUI.GetGlobalCenter()); // Allow one frame for the edge to be placed onto a layer yield return(null); // Allow one frame for the edge to be rendered and process its layout a first time yield return(null); // Check that the edge exists and that it connects the two ports. Assert.AreEqual(1, startPort.GetConnectedEdges().Count()); Assert.AreEqual(1, startPort2.GetConnectedEdges().Count()); Assert.AreEqual(2, endPort.GetConnectedEdges().Count()); graphView.CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, endPort.GetConnectedEdges().First(), endPort.GetConnectedEdges().Skip(1).First())); helpers.DragTo(endPortUI.GetGlobalCenter() - new Vector3(k_EdgeSelectionOffset, 0, 0), endPort2UI.GetGlobalCenter()); // Allow one frame for the edge to be placed onto a layer yield return(null); // Allow one frame for the edge to be rendered and process its layout a first time yield return(null); Assert.AreEqual(1, startPort.GetConnectedEdges().Count()); Assert.AreEqual(1, startPort2.GetConnectedEdges().Count()); Assert.AreEqual(2, endPort2.GetConnectedEdges().Count()); }
protected override IEdgeModel InstantiateEdge(IPortModel toPort, IPortModel fromPort, SerializableGUID guid = default) { var edgeModel = base.InstantiateEdge(toPort, fromPort, guid); if (edgeModel is EdgeModel testEdgeModel) { testEdgeModel.SetGraphModel(this); } return(edgeModel); }
public IEnumerable <SyntaxNode> BuildPort(IPortModel portModel, PortSemantic portSemantic = PortSemantic.Read) { var buildPortInner = BuildPortInner(portModel, out var builtNode).ToList(); if (portSemantic == PortSemantic.Read && (Options & UnityEngine.Modifier.VisualScripting.CompilationOptions.Tracing) != 0 && builtNode != null && buildPortInner.Count == 1 && buildPortInner.First() is ExpressionSyntax exp) { return(Enumerable.Repeat(InstrumentForInEditorDebugging.RecordValue(GetRecorderName(), exp, null, (NodeModel)builtNode), 1)); } return(buildPortInner); }
public static IEnumerable <SyntaxNode> Build( this RoslynEcsTranslator translator, RemoveComponentNodeModel model, IPortModel portModel) { var componentType = model.ComponentType.Resolve(model.GraphModel.Stencil); var entityTranslator = translator.context.GetEntityManipulationTranslator(); var entitySyntax = translator.BuildPort(model.EntityPort).SingleOrDefault() as ExpressionSyntax; return(entityTranslator.RemoveComponent(translator.context, entitySyntax, componentType)); }
protected override void OnDefineNode() { ExeInput0 = this.AddExecutionInputPort("exe0"); ExeOutput0 = this.AddExecutionOutputPort("exe0"); Input0 = this.AddDataInputPort <int>("input0"); Input1 = this.AddDataInputPort <int>("input1"); Input2 = this.AddDataInputPort <int>("input2"); Output0 = this.AddDataOutputPort <int>("output0"); Output1 = this.AddDataOutputPort <int>("output1"); Output2 = this.AddDataOutputPort <int>("output2"); }
public virtual SearcherFilter GetInputToGraphSearcherFilter(IPortModel portModel) { var dataType = portModel.DataTypeHandle.Resolve(m_Stencil); return(new SearcherFilter(SearcherContext.Graph) .WithVisualScriptingNodesExcept(new[] { typeof(GetPropertyGroupNodeModel) }) .WithVariables(m_Stencil, portModel) .WithConstants(m_Stencil, portModel) .WithUnaryOperators(dataType) .WithBinaryOperators(dataType)); }
public override void OnConnection(IPortModel selfConnectedPortModel, IPortModel otherConnectedPortModel) { if (selfConnectedPortModel.Direction == Direction.Input && otherConnectedPortModel?.NodeModel is ForAllEntitiesNodeModel forAllNode) { ComponentQueryDeclarationModel = forAllNode.ComponentQueryDeclarationModel; CreateLoopVariables(otherConnectedPortModel); } base.OnConnection(selfConnectedPortModel, otherConnectedPortModel); }
protected override void OnDefineNode() { var portType = Kind == UnaryOperatorKind.LogicalNot ? TypeHandle.Bool : TypeHandle.Float; InputPort = AddDataInputPort("A", portType); if (Kind == UnaryOperatorKind.LogicalNot || Kind == UnaryOperatorKind.Minus) { OutputPort = AddDataOutputPort("Out", portType); } }
public static void ShowOutputToGraphNodes(State state, IPortModel portModel, Vector2 position, Action <GraphNodeModelSearcherItem> callback) { var stencil = state.CurrentGraphModel.Stencil; var filter = stencil.GetSearcherFilterProvider()?.GetOutputToGraphSearcherFilter(portModel); var adapter = stencil.GetSearcherAdapter(state.CurrentGraphModel, $"Choose an action for {portModel.DataTypeHandle.GetMetadata(stencil).FriendlyName}"); var dbProvider = stencil.GetSearcherDatabaseProvider(); var dbs = dbProvider.GetGraphElementsSearcherDatabases().ToList(); PromptSearcher(dbs, filter, adapter, position, callback); }
public override SearcherFilter GetOutputToStackSearcherFilter(IPortModel portModel, IStackModel stackModel) { var queryType = typeof(EntityQuery).GenerateTypeHandle(m_Stencil); if (portModel.DataType.Equals(queryType)) { return(new EcsSearcherFilter(SearcherContext.Stack) .WithControlFlow(typeof(IIteratorStackModel), stackModel)); } return(base.GetOutputToStackSearcherFilter(portModel, stackModel)); }
public override SearcherFilter GetOutputToGraphSearcherFilter(IPortModel portModel) { var queryType = typeof(EntityQuery).GenerateTypeHandle(m_Stencil); if (portModel.DataType.Equals(queryType)) { return(new EcsSearcherFilter(SearcherContext.Graph) .WithVisualScriptingNodes(typeof(IIteratorStackModel))); } return(base.GetOutputToGraphSearcherFilter(portModel)); }
public virtual SearcherFilter GetEdgeSearcherFilter(IEdgeModel edgeModel) { Type it = edgeModel.InputPortModel.DataTypeHandle.Resolve(m_Stencil); IPortModel opm = edgeModel.OutputPortModel; TypeHandle oth = opm.DataTypeHandle == TypeHandle.ThisType ? m_Stencil.GetThisType() : opm.DataTypeHandle; Type ot = oth.Resolve(m_Stencil); return(new SearcherFilter(SearcherContext.Graph) .WithVisualScriptingNodesExcept(new[] { typeof(ThisNodeModel) }) // TODO : We should be able to determine if a VSNode type has input port instead of doing this .WithUnaryOperators(ot, opm.NodeModel is IConstantNodeModel) .WithBinaryOperators(ot)); }
public override void SetUp() { base.SetUp(); firstNode = CreateNode("First Node", new Vector2(0, 0), outCount: 2); startPort = firstNode.OutputsByDisplayOrder[0]; startPortTwo = firstNode.OutputsByDisplayOrder[1]; secondNode = CreateNode("Second Node", new Vector2(400, 0), inCount: 2); endPort = secondNode.InputsByDisplayOrder[0]; endPortTwo = secondNode.InputsByDisplayOrder[1]; }