public static IEnumerable <SyntaxNode> Build(
this RoslynEcsTranslator translator,
GetSingletonNodeModel model)
{
if (model.ComponentType == TypeHandle.Unknown)
{
yield break;
}
var singletonType = model.ComponentType.Resolve(translator.Stencil);
var typeArguments = TypeArgumentList(SingletonSeparatedList(TypeSystem.BuildTypeSyntax(singletonType)));
var bindingFlags = BindingFlags.Public | BindingFlags.Instance;
var methodInfo = typeof(EntityQuery).GetMethod(nameof(EntityQuery.GetSingleton), bindingFlags)
?.GetGenericMethodDefinition()
.MakeGenericMethod(singletonType);
var method = RoslynBuilder.MethodInvocation(
nameof(EntityQuery.GetSingleton),
methodInfo,
InvocationExpression(
IdentifierName("GetEntityQuery"))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(TypeOfExpression(singletonType.ToTypeSyntax()))))),
new List <ArgumentSyntax>(),
typeArguments) as ExpressionSyntax;
yield return(method);
}
public static IEnumerable <SyntaxNode> Build(this RoslynTranslator translator, LogNodeModel model,
IPortModel portModel)
{
var obj = translator.BuildPort(model.InputPort).SingleOrDefault() as ExpressionSyntax;
string methodName;
switch (model.LogType)
{
case LogNodeModel.LogTypes.Message:
methodName = nameof(Debug.Log);
break;
case LogNodeModel.LogTypes.Warning:
methodName = nameof(Debug.LogWarning);
break;
case LogNodeModel.LogTypes.Error:
methodName = nameof(Debug.LogError);
break;
default:
throw new ArgumentOutOfRangeException();
}
var arg = obj != null?Argument(obj) : Argument(LiteralExpression(SyntaxKind.NullLiteralExpression));
yield return(RoslynBuilder.MethodInvocation(methodName, IdentifierName(nameof(Debug)), arg));
}
public static IEnumerable <SyntaxNode> Build(
this RoslynEcsTranslator translator,
CountEntitiesNodeModel model,
IPortModel portModel)
{
var connected = model.InputPort.ConnectionPortModels.FirstOrDefault();
if (connected?.NodeModel is VariableNodeModel variableNode &&
variableNode.DeclarationModel is ComponentQueryDeclarationModel queryDeclaration)
{
yield return(RoslynBuilder.MethodInvocation(nameof(EntityQuery.CalculateEntityCount),
SyntaxFactory.IdentifierName(queryDeclaration.VariableName), null, null));
}
}
public ExpressionSyntax BuildCall(RoslynTranslator translator, IPortModel portModel, out ExpressionSyntax inputName, out string methodName)
{
if (InputPort.IsConnected || InputPort.EmbeddedValue != null)
{
inputName = translator.BuildPort(InputPort).FirstOrDefault() as ExpressionSyntax;
}
else
{
inputName = SyntaxFactory.LiteralExpression(
SyntaxKind.DefaultLiteralExpression,
SyntaxFactory.Token(SyntaxKind.DefaultKeyword));
}
var method = RoslynBuilder.MethodInvocation(methodName = MethodName(portModel), typeof(Input).ToTypeSyntax(), SyntaxFactory.Argument(inputName));
return(method);
}
public static ExpressionSyntax BuildCall(RoslynTranslator translator, GetInputNodeModel model, string methodName, out ExpressionSyntax inputName)
{
if (model.InputPort.Connected || model.InputPort.EmbeddedValue != null)
{
inputName = translator.BuildPort(model.InputPort).FirstOrDefault() as ExpressionSyntax;
}
else
{
inputName = RoslynBuilder.EmptyStringLiteralExpression();
}
var methodParameters = new[] { SyntaxFactory.Argument(inputName) };
var method = RoslynBuilder.MethodInvocation(methodName, typeof(Input).ToTypeSyntax(), methodParameters, Enumerable.Empty <TypeSyntax>());
return(method);
}
