public MacroNode(MacroRefNodeModel model, Store store, GraphView graphView) : base(model, store, graphView)
{
m_MacroModel = model;
AddToClassList("macro");
m_TitleElement = this.MandatoryQ("title");
m_TitleElement.pickingMode = PickingMode.Position;
this.EnableRename();
var clickable = new Clickable(DoAction);
clickable.activators.Clear();
clickable.activators.Add(
new ManipulatorActivationFilter {
button = MouseButton.LeftMouse, clickCount = 2
});
this.AddManipulator(clickable);
IGraphElementModel elementModelToRename = m_Store.GetState().EditorDataModel.ElementModelToRename;
if (elementModelToRename as MacroRefNodeModel == model)
{
((VseGraphView)m_GraphView).UIController.ElementToRename = this;
}
}
public static IEnumerable <SyntaxNode> BuildMacroRefNode(this RoslynTranslator translator,
MacroRefNodeModel model, IPortModel portModel)
{
if (model.Macro == null)
{
translator.AddError(
model,
$"The asset of macro node {model.Title} is missing.");
return(Enumerable.Empty <SyntaxNode>());
}
var variableDeclarations = portModel.Direction == Direction.Input
? model.DefinedInputVariables
: model.DefinedOutputVariables;
var declaration = variableDeclarations.Single(v => v.VariableName == portModel.UniqueId);
translator.InMacro.Push(model);
var variableNodeModel = ((VSGraphModel)declaration.GraphModel)
.FindUsages((VariableDeclarationModel)declaration)
.Single();
var returnValue = translator.BuildPort(variableNodeModel.OutputPort);
translator.InMacro.Pop();
return(returnValue);
}
public static IEnumerable <SyntaxNode> BuildVariable(this RoslynEcsTranslator translator, IVariableModel v, IPortModel portModel)
{
if (v is IConstantNodeModel model)
{
if (model.ObjectValue != null)
{
yield return(translator.Constant(model.ObjectValue, translator.Stencil, model.Type));
}
yield break;
}
if (translator.InMacro.Count > 0 && v.DeclarationModel.VariableType == VariableType.GraphVariable && v.DeclarationModel.Modifiers == ModifierFlags.ReadOnly)
{
MacroRefNodeModel oldValue = translator.InMacro.Pop();
var syntaxNodes = translator.BuildPort(oldValue.InputsById[v.DeclarationModel.VariableName]);
translator.InMacro.Push(oldValue);
foreach (var syntaxNode in syntaxNodes)
{
yield return(syntaxNode);
}
yield break;
}
switch (v.DeclarationModel.VariableType)
{
case VariableType.GraphVariable:
yield return(translator.context.GetSingletonVariable(v.DeclarationModel));
break;
case VariableType.FunctionVariable:
case VariableType.ComponentGroupField:
yield return(RoslynBuilder.LocalVariableReference(v.DeclarationModel.VariableName));
break;
case VariableType.FunctionParameter:
var variableDeclarationModel = v.DeclarationModel;
if (variableDeclarationModel.VariableIsAGeneratedEcsComponent(out var groupDeclaration))
{
var relevantContext = translator.FindContext(groupDeclaration);
translator.context.RecordComponentAccess(relevantContext, v.DeclarationModel.DataType, translator.IsRecordingComponentAccesses);
yield return(RoslynBuilder.ArgumentReference(translator.context.GetComponentVariableName(groupDeclaration, variableDeclarationModel.DataType)));
}
else
{
yield return(RoslynBuilder.ArgumentReference(v.DeclarationModel.VariableName));
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static IEnumerable <SyntaxNode> BuildVariable(this RoslynTranslator translator, IVariableModel v, IPortModel portModel)
{
if (v is IConstantNodeModel constantNodeModel)
{
if (constantNodeModel.ObjectValue != null)
{
if (constantNodeModel is IStringWrapperConstantModel)
{
yield return(translator.Constant(constantNodeModel.ObjectValue.ToString(), translator.Stencil));
}
else
{
yield return(translator.Constant(constantNodeModel.ObjectValue, translator.Stencil));
}
}
yield break;
}
if (translator.InMacro.Count > 0 && v.DeclarationModel.VariableType == VariableType.GraphVariable && v.DeclarationModel.Modifiers == ModifierFlags.ReadOnly)
{
MacroRefNodeModel oldValue = translator.InMacro.Pop();
var syntaxNodes = translator.BuildPort(oldValue.InputsById[v.DeclarationModel.VariableName]);
translator.InMacro.Push(oldValue);
foreach (var syntaxNode in syntaxNodes)
{
yield return(syntaxNode);
}
yield break;
}
switch (v.DeclarationModel.VariableType)
{
case VariableType.FunctionVariable:
case VariableType.GraphVariable:
case VariableType.ComponentQueryField:
yield return(RoslynBuilder.LocalVariableReference(v.DeclarationModel.Name));
break;
case VariableType.FunctionParameter:
yield return(RoslynBuilder.ArgumentReference(v.DeclarationModel.Name));
break;
// case VariableType.Literal:
// case VariableType.InlineExpression:
default:
throw new ArgumentOutOfRangeException();
}
}
void TestExtractMacro(IEnumerable <IGraphElementModel> toExtract, IO inputs, IO outputs)
{
MacroRefNodeModel macroRef = GraphModel.ExtractNodesAsMacro(m_MacroGraphModel, Vector2.zero, toExtract);
Assert.That(macroRef.GraphAssetModel.GraphModel, Is.EqualTo(m_MacroGraphModel));
inputs.Check(m_MacroGraphModel, macroRef.InputVariablePorts.ToList(), ModifierFlags.ReadOnly);
outputs.Check(m_MacroGraphModel, macroRef.OutputVariablePorts.ToList(), ModifierFlags.WriteOnly);
CompilationResult compilationResult = GraphModel.Compile(AssemblyType.None, GraphModel.CreateTranslator(), CompilationOptions.Default);
Assert.That(
compilationResult.status,
Is.EqualTo(CompilationStatus.Succeeded));
Debug.Log(compilationResult.sourceCode[0]);
}
public static GraphElement CreateMacro(this INodeBuilder builder, Store store, MacroRefNodeModel model)
{
return(new MacroNode(model, store, builder.GraphView));
}
