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];
}
