protected override IEnumerable <SyntaxNode> BuildNode(INodeModel statement, IPortModel portModel)
{
if (statement == null)
{
return(Enumerable.Empty <SyntaxNode>());
}
Assert.IsTrue(portModel == null || portModel.NodeModel == statement, "If a Port is provided, it must be owned by the provided node");
// TODO : Find a better way to map [Node -> Current Archetype]
if (!(context is RootContext) && statement.IsStacked)
{
var stencil = (EcsStencil)statement.GraphModel.Stencil;
if (!stencil.ComponentDefinitions.ContainsKey(statement))
{
stencil.ComponentDefinitions.Add(statement, context.GetComponentDefinitions());
}
}
Func <MethodInfo, bool> filterMethods = mi => mi.ReturnType == typeof(IEnumerable <SyntaxNode>) &&
mi.GetParameters().Length == 3 &&
mi.GetParameters()[2].ParameterType == typeof(IPortModel);
Func <MethodInfo, Type> keySelector = mi => mi.GetParameters()[1].ParameterType;
var ext = ModelUtility.ExtensionMethodCache <RoslynEcsTranslator> .GetExtensionMethod(
statement.GetType(),
filterMethods,
keySelector)
?? ModelUtility.ExtensionMethodCache <RoslynTranslator> .GetExtensionMethod(
statement.GetType(),
filterMethods,
keySelector);
if (ext != null)
{
var syntaxNode = (IEnumerable <SyntaxNode>)ext.Invoke(null, new object[] { this, statement, portModel }) ?? Enumerable.Empty <SyntaxNode>();
var annotatedNodes = new List <SyntaxNode>();
foreach (var node in syntaxNode)
{
var annotatedNode = node?.WithAdditionalAnnotations(new SyntaxAnnotation(Annotations.AnnotationKind, statement.NodeAssetReference.GetInstanceID().ToString()));
annotatedNodes.Add(annotatedNode);
}
return(annotatedNodes);
}
Debug.LogError("Roslyn ECS Translator doesn't know how to create a node of type: " + statement.GetType());
return(Enumerable.Empty <SyntaxNode>());
}
// static StatementSyntax StatementFromExitStrategy(StackExitStrategy stackExitStrategy, ExpressionSyntax returnValue)
// {
// StatementSyntax lastStatementSyntax;
// switch (stackExitStrategy)
// {
// case StackExitStrategy.Return:
// lastStatementSyntax = ReturnStatement(returnValue);
// break;
// case StackExitStrategy.Break:
// lastStatementSyntax = BreakStatement();
// break;
// case StackExitStrategy.None:
// lastStatementSyntax = null;
// break;
// default:
// lastStatementSyntax = ContinueStatement();
// break;
// }
//
// return lastStatementSyntax;
// }
protected virtual IEnumerable <SyntaxNode> BuildNode(INodeModel statement, IPortModel portModel)
{
if (statement == null)
{
return(Enumerable.Empty <SyntaxNode>());
}
Assert.IsTrue(portModel == null || portModel.NodeModel == statement, "If a Port is provided, it must be owned by the provided node");
var ext = ModelUtility.ExtensionMethodCache <RoslynTranslator> .GetExtensionMethod(
statement.GetType(),
FilterMethods,
KeySelector);
if (ext != null)
{
var syntaxNode = (IEnumerable <SyntaxNode>)ext.Invoke(null, new object[] { this, statement, portModel }) ?? Enumerable.Empty <SyntaxNode>();
var annotatedNodes = new List <SyntaxNode>();
foreach (var node in syntaxNode)
{
var annotatedNode = node?.WithAdditionalAnnotations(new SyntaxAnnotation(Annotations.AnnotationKind, statement.Guid.ToString()));
annotatedNodes.Add(annotatedNode);
}
return(annotatedNodes);
}
else
{
Debug.LogError("Roslyn Translator doesn't know how to create a node of type: " + statement.GetType());
}
return(Enumerable.Empty <SyntaxNode>());
}
void CheckNodeList(IReadOnlyList <INodeModel> nodeModels, Dictionary <GUID, int> existingGuids = null)
{
if (existingGuids == null)
{
existingGuids = new Dictionary <GUID, int>(nodeModels.Count * 4); // wild guess of total number of nodes, including stacked nodes
}
for (var i = 0; i < nodeModels.Count; i++)
{
INodeModel node = nodeModels[i];
Assert.IsTrue(node.NodeAssetReference != null, $"Node asset {i} is null");
Assert.IsNotNull(node, $"Node {i} is null");
Assert.IsTrue(AssetModel.IsSameAsset(node.AssetModel), $"Node {i} asset is not matching its actual asset");
Assert.IsFalse(node.Guid.Empty(), $"Node {i} ({node.GetType()}) has an empty Guid");
Assert.IsFalse(existingGuids.TryGetValue(node.Guid, out var oldIndex), $"duplicate GUIDs: Node {i} ({node.GetType()}) and Node {oldIndex}");
existingGuids.Add(node.Guid, i);
if (node.Destroyed)
{
continue;
}
CheckNodePorts(node.InputsById);
CheckNodePorts(node.OutputsById);
if (node is IStackModel stackModel)
{
CheckNodeList(stackModel.NodeModels, existingGuids);
}
}
}
// static StatementSyntax StatementFromExitStrategy(StackExitStrategy stackExitStrategy, ExpressionSyntax returnValue)
// {
// StatementSyntax lastStatementSyntax;
// switch (stackExitStrategy)
// {
// case StackExitStrategy.Return:
// lastStatementSyntax = ReturnStatement(returnValue);
// break;
// case StackExitStrategy.Break:
// lastStatementSyntax = BreakStatement();
// break;
// case StackExitStrategy.None:
// lastStatementSyntax = null;
// break;
// default:
// lastStatementSyntax = ContinueStatement();
// break;
// }
//
// return lastStatementSyntax;
// }
protected virtual IEnumerable <SyntaxNode> BuildNode(INodeModel statement, IPortModel portModel)
{
if (statement == null)
{
return(Enumerable.Empty <SyntaxNode>());
}
Assert.IsTrue(portModel == null || portModel.NodeModel == statement, "If a Port is provided, it must be owned by the provided node");
var ext = ModelUtility.ExtensionMethodCache <RoslynTranslator> .GetExtensionMethod(
statement.GetType(),
mi => mi.ReturnType == typeof(IEnumerable <SyntaxNode>) &&
mi.GetParameters().Length == 3 &&
mi.GetParameters()[2].ParameterType == typeof(IPortModel),
mi => mi.GetParameters()[1].ParameterType);
if (ext != null)
{
var syntaxNode = (IEnumerable <SyntaxNode>)ext.Invoke(null, new object[] { this, statement, portModel }) ?? Enumerable.Empty <SyntaxNode>();
var annotatedNodes = new List <SyntaxNode>();
foreach (var node in syntaxNode)
{
var annotatedNode = node?.WithAdditionalAnnotations(new SyntaxAnnotation(Annotations.AnnotationKind, (statement.NodeAssetReference).GetInstanceID().ToString()));
annotatedNodes.Add(annotatedNode);
}
return(annotatedNodes);
}
else
{
Debug.LogError("Roslyn Translator doesn't know how to create a node of type: " + statement.GetType());
}
return(Enumerable.Empty <SyntaxNode>());
}
public void AddStackedNodeNoUndo(INodeModel nodeModelInterface, int index)
{
if (!AcceptNode(nodeModelInterface.GetType()))
{
return;
}
var nodeModel = (NodeModel)nodeModelInterface;
Utility.SaveAssetIntoObject(nodeModel.NodeAssetReference, (Object)AssetModel);
nodeModel.GraphModel = GraphModel;
nodeModel.ParentStackModel = this;
if (index == -1)
{
m_NodeModels.Add(nodeModel.NodeAssetReference);
}
else
{
m_NodeModels.Insert(index, nodeModel.NodeAssetReference);
}
VSGraphModel vsGraphModel = (VSGraphModel)GraphModel;
vsGraphModel.LastChanges.ChangedElements.Add(nodeModel);
}
static bool TranslateNode(GraphBuilder builder, INodeModel nodeModel, out INode node,
out Dictionary <string, uint> portToOffsetMapping, out uint?preAllocatedDataIndex)
{
Assert.IsNotNull(nodeModel);
preAllocatedDataIndex = null;
switch (nodeModel)
{
case SetVariableNodeModel setVariableNodeModel:
{
node = setVariableNodeModel.Node;
portToOffsetMapping = setVariableNodeModel.PortToOffsetMapping;
if (setVariableNodeModel.DeclarationModel == null)
{
return(false);
}
preAllocatedDataIndex = builder.GetVariableDataIndex(setVariableNodeModel.DeclarationModel).DataIndex;
return(true);
}
case IEventNodeModel eventNodeModel:
node = eventNodeModel.Node;
((IEventNode)node).EventId = TypeHash.CalculateStableTypeHash(
eventNodeModel.TypeHandle.Resolve(nodeModel.GraphModel.Stencil));
portToOffsetMapping = eventNodeModel.PortToOffsetMapping;
return(true);
case SubgraphReferenceNodeModel subgraphReferenceNodeModel:
node = subgraphReferenceNodeModel.Node;
portToOffsetMapping = subgraphReferenceNodeModel.PortToOffsetMapping;
return(true);
case IDotsNodeModel dotsNodeModel:
node = dotsNodeModel.Node;
portToOffsetMapping = dotsNodeModel.PortToOffsetMapping;
if (nodeModel is IReferenceComponentTypes referenceComponentTypes)
{
foreach (var typeReference in referenceComponentTypes.ReferencedTypes)
{
if (typeReference.TypeIndex != -1)
{
builder.AddReferencedComponent(typeReference);
}
}
}
return(true);
case IConstantNodeModel constantNodeModel:
HandleConstants(builder, out node, out portToOffsetMapping, constantNodeModel);
return(true);
case IVariableModel variableModel:
return(HandleVariable(builder, out node, out portToOffsetMapping,
out preAllocatedDataIndex, variableModel));
default:
throw new NotImplementedException(
$"Don't know how to translate a node of type {nodeModel.GetType()}: {nodeModel}");
}
}
IEnumerable <StatementSyntax> ConvertNodesToSyntaxList(INodeModel node, IEnumerable <SyntaxNode> blocks,
CompilationOptions options)
{
foreach (var block in blocks)
{
switch (block)
{
case StatementSyntax statementNode:
foreach (var statementSyntax in Instrument(statementNode, node, options))
{
yield return(statementSyntax);
}
break;
case ExpressionSyntax expressionNode:
foreach (var statementSyntax in Instrument(ExpressionStatement(expressionNode)
.WithAdditionalAnnotations(
new SyntaxAnnotation(Annotations.VSNodeMetadata, node.Guid.ToString())), node, options))
{
yield return(statementSyntax);
}
break;
default:
throw new InvalidOperationException("Expected a statement or expression " +
$"node, found a {node.GetType()} when building {block}");
}
}
}
public void AddStackedNode(INodeModel nodeModelInterface, int index)
{
if (!AcceptNode(nodeModelInterface.GetType()))
{
return;
}
var nodeModel = (NodeModel)nodeModelInterface;
Utility.SaveAssetIntoObject(nodeModel.NodeAssetReference, (Object)AssetModel);
nodeModel.GraphModel = GraphModel;
nodeModel.ParentStackModel = this;
if (index == -1)
{
m_NodeModels.Add(nodeModel.NodeAssetReference);
}
else
{
m_NodeModels.Insert(index, nodeModel.NodeAssetReference);
}
bool insertedLast = index == -1 || m_NodeModels.Count == 1 || index == m_NodeModels.Count;
if (insertedLast && ModelDelegatesOutputs(nodeModelInterface))
{
TransferConnections(GraphModel, m_OutputPorts, OutputPorts);
}
VSGraphModel vsGraphModel = (VSGraphModel)GraphModel;
vsGraphModel.LastChanges.ChangedElements.Add(nodeModel);
}
void OffsetNodeDependencies(INodeModel dependentNode, Vector2 delta)
{
Log($"Moving all dependencies of {dependentNode.GetType().Name} by {delta}");
m_TempMovedModels.Clear();
m_ModelsToMove.Clear();
m_ModelsToMove.Add(dependentNode);
ProcessDependency(dependentNode, delta, OffsetDependency);
}
void CheckNodeList(IList <INodeModel> nodeModels, Dictionary <GUID, int> existingGuids = null)
{
if (existingGuids == null)
{
existingGuids = new Dictionary <GUID, int>(nodeModels.Count * 4); // wild guess of total number of nodes, including stacked nodes
}
for (var i = 0; i < nodeModels.Count; i++)
{
INodeModel node = nodeModels[i];
Assert.IsTrue(node.GraphModel != null, $"Node {i} {node} graph is null");
Assert.IsTrue(node.SerializableAsset != null, $"Node {i} {node} asset is null");
Assert.IsNotNull(node, $"Node {i} is null");
Assert.IsTrue(AssetModel.IsSameAsset(node.AssetModel), $"Node {i} asset is not matching its actual asset");
Assert.IsFalse(node.Guid.Empty(), $"Node {i} ({node.GetType()}) has an empty Guid");
Assert.IsFalse(existingGuids.TryGetValue(node.Guid, out var oldIndex), $"duplicate GUIDs: Node {i} ({node.GetType()}) and Node {oldIndex} have the same guid {node.Guid}");
existingGuids.Add(node.Guid, i);
if (node.Destroyed)
{
continue;
}
CheckNodePorts(node.InputsById);
CheckNodePorts(node.OutputsById);
if (node is IStackModel stackModel)
{
CheckNodeList(stackModel.NodeModels, existingGuids);
}
if (node is VariableNodeModel variableNode)
{
Assert.IsNotNull(variableNode.DeclarationModel, $"Variable Node {i} {variableNode.Title} has a null declaration model");
if (variableNode.DeclarationModel.VariableType == VariableType.GraphVariable)
{
var originalDeclarations = GraphVariableModels.Where(d => d.GetId() == variableNode.DeclarationModel.GetId());
Assert.IsTrue(originalDeclarations.Count() <= 1);
var originalDeclaration = originalDeclarations.SingleOrDefault();
Assert.IsNotNull(originalDeclaration, $"Variable Node {i} {variableNode.Title} has a declaration model, but it was not present in the graph's variable declaration list");
Assert.IsTrue(ReferenceEquals(originalDeclaration, variableNode.DeclarationModel), $"Variable Node {i} {variableNode.Title} has a declaration model that was not ReferenceEquals() to the matching one in the graph");
}
}
}
}
public virtual void AddStackedNode(INodeModel nodeModelInterface, int index)
{
if (!AcceptNode(nodeModelInterface.GetType()))
{
return;
}
var nodeModel = (NodeModel)nodeModelInterface;
nodeModel.AssetModel = AssetModel;
nodeModel.ParentStackModel = this;
if (index == -1)
{
m_StackedNodeModels.Add(nodeModel);
}
else
{
m_StackedNodeModels.Insert(index, nodeModel);
}
VSGraphModel vsGraphModel = (VSGraphModel)GraphModel;
// We need to register before calling TransferConnections(), as edge models rely on the guid to node mapping to resolve ports
vsGraphModel.UnregisterNodeGuid(nodeModel.Guid);
vsGraphModel.RegisterNodeGuid(nodeModel);
bool insertedLast = index == -1 || m_StackedNodeModels.Count == 1 || index == m_StackedNodeModels.Count;
if (insertedLast && ModelDelegatesOutputs(nodeModelInterface))
{
TransferConnections(GraphModel, m_OutputPorts, OutputPorts);
}
vsGraphModel.LastChanges.ChangedElements.Add(nodeModel);
// Needed to add/remove/update the return value port of the node according to the function type
nodeModel.DefineNode();
}
static void CheckNodeList(this IGraphModel self)
{
var existingGuids = new Dictionary <SerializableGUID, int>(self.NodeModels.Count * 4); // wild guess of total number of nodes, including stacked nodes
for (var i = 0; i < self.NodeModels.Count; i++)
{
INodeModel node = self.NodeModels[i];
Assert.IsTrue(node.GraphModel != null, $"Node {i} {node} graph is null");
Assert.IsTrue(node.AssetModel != null, $"Node {i} {node} asset is null");
Assert.IsNotNull(node, $"Node {i} is null");
Assert.IsTrue(self.AssetModel.GetHashCode() == node.AssetModel?.GetHashCode(), $"Node {i} asset is not matching its actual asset");
Assert.IsFalse(!node.Guid.Valid, $"Node {i} ({node.GetType()}) has an empty Guid");
Assert.IsFalse(existingGuids.TryGetValue(node.Guid, out var oldIndex), $"duplicate GUIDs: Node {i} ({node.GetType()}) and Node {oldIndex} have the same guid {node.Guid}");
existingGuids.Add(node.Guid, i);
if (node.Destroyed)
{
continue;
}
if (node is IInputOutputPortsNodeModel portHolder)
{
CheckNodePorts(portHolder.InputsById);
CheckNodePorts(portHolder.OutputsById);
}
if (node is IVariableNodeModel variableNode && variableNode.DeclarationModel != null)
{
var originalDeclarations = self.VariableDeclarations.Where(d => d.Guid == variableNode.DeclarationModel.Guid).ToList();
Assert.IsTrue(originalDeclarations.Count <= 1);
var originalDeclaration = originalDeclarations.SingleOrDefault();
Assert.IsNotNull(originalDeclaration, $"Variable Node {i} {variableNode.Title} has a declaration model, but it was not present in the graph's variable declaration list");
Assert.IsTrue(ReferenceEquals(originalDeclaration, variableNode.DeclarationModel), $"Variable Node {i} {variableNode.Title} has a declaration model that was not ReferenceEquals() to the matching one in the graph");
}
}
}
public void AddStackedNode(INodeModel nodeModelInterface, int index)
{
if (!AcceptNode(nodeModelInterface.GetType()))
{
return;
}
var nodeModel = (NodeModel)nodeModelInterface;
nodeModel.GraphModel = GraphModel;
nodeModel.ParentStackModel = this;
if (index == -1)
{
m_StackedNodeModels.Add(nodeModel);
}
else
{
m_StackedNodeModels.Insert(index, nodeModel);
}
bool insertedLast = index == -1 || m_StackedNodeModels.Count == 1 || index == m_StackedNodeModels.Count;
if (insertedLast && ModelDelegatesOutputs(nodeModelInterface))
{
TransferConnections(GraphModel, m_OutputPorts, OutputPorts);
}
VSGraphModel vsGraphModel = (VSGraphModel)GraphModel;
// theor: why is that needed ?
vsGraphModel.UnregisterNodeGuid(nodeModel.Guid);
vsGraphModel.RegisterNodeGuid(nodeModel);
vsGraphModel.LastChanges.ChangedElements.Add(nodeModel);
// Needed to add/remove/update the return value port of the node according to the function type
nodeModel.DefineNode();
}
bool AcceptNode(INodeModel nodeModel)
{
return(stackModel.NodeModels.Any(m => m == nodeModel) || stackModel.AcceptNode(nodeModel.GetType()));
}
private void ParseNodeFirstPass(XmlTextReader reader, XMLTree parentNode, String parentTypeName)
{
INodeModel nodeModel = graph.Model.NodeModel;
IEdgeModel edgeModel = graph.Model.EdgeModel;
Dictionary <String, int> tagNameToNextIndex = new Dictionary <String, int>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break; // reached end of current nesting level
}
if (reader.NodeType != XmlNodeType.Element)
{
continue;
}
bool emptyElem = reader.IsEmptyElement; // retard API designer
String tagName = reader.Name;
String id = null;
if (reader.MoveToAttribute("xmi:id"))
{
id = reader.Value;
}
String elementName = null;
if (reader.MoveToAttribute("name"))
{
elementName = reader.Value;
}
String typeName = null;
if (reader.MoveToAttribute("xsi:type"))
{
typeName = reader.Value;
}
else if (reader.MoveToAttribute("xmi:type"))
{
typeName = reader.Value;
}
else
{
typeName = FindRefTypeName(parentTypeName, tagName);
if (typeName == null)
{
// Treat it as an attribute
AssignAttribute(parentNode.elementNode, tagName, reader.ReadInnerXml());
XMLTree attributeChild = new XMLTree();
attributeChild.elementNode = null;
attributeChild.elementName = elementName;
attributeChild.element = tagName;
attributeChild.children = null;
parentNode.children.Add(attributeChild);
continue;
}
}
INode gnode = graph.AddNode(nodeModel.GetType(GrGenTypeNameFromXmi(typeName)));
XMLTree child = new XMLTree();
child.elementNode = gnode;
child.elementName = elementName;
child.element = tagName;
child.children = new List <XMLTree>();
parentNode.children.Add(child);
if (id != null)
{
nodeMap[id] = gnode;
}
String edgeTypeName = FindContainingTypeName(parentTypeName, tagName);
String grgenEdgeTypeName = GrGenTypeNameFromXmi(edgeTypeName) + "_" + tagName;
IEdge parentEdge = graph.AddEdge(edgeModel.GetType(grgenEdgeTypeName), parentNode.elementNode, gnode);
if (IsRefOrdered(parentTypeName, tagName))
{
int nextIndex = 0;
tagNameToNextIndex.TryGetValue(tagName, out nextIndex);
parentEdge.SetAttribute("ordering", nextIndex);
tagNameToNextIndex[tagName] = nextIndex + 1;
}
if (!emptyElem)
{
ParseNodeFirstPass(reader, child, typeName);
}
}
}
