public void ParseFieldWithConvertAttribute()
{
var f = FieldModel.Parse(null, RoslynBuilder.DeclareField(typeof(Entity), "a")
.AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Convert")))));
Assert.That(f, Is.Not.Null);
Assert.AreEqual(typeof(GameObject), f.Type);
}
public static IEnumerable <SyntaxNode> BuildCreateEntityTranslator(this RoslynEcsTranslator translator,
CreateEntityNodeModel model, IPortModel portModel)
{
bool hasAnyComponentInstruction = false;
ExpressionSyntax newInstance = null;
if (model.InstancePort.Connected)
{
newInstance = translator.BuildPort(model.InstancePort, RoslynTranslator.PortSemantic.Write).SingleOrDefault() as ExpressionSyntax;
hasAnyComponentInstruction = true;
}
// always instantiate
var newEntity = InstantiateEntity(translator, model);
if (hasAnyComponentInstruction) // == if connected. assignment of implicit variable is done only if it's required in the foreach loop below
{
yield return(RoslynBuilder.Assignment(newInstance, newEntity));
}
var entityTranslator = translator.context.GetEntityManipulationTranslator();
foreach (TypeHandle th in model.GetEditableComponents())
{
var componentType = th.Resolve(model.GraphModel.Stencil);
IEnumerable <SyntaxNode> instructions;
// first instruction forces the declaration of an implicit variable if not already done
if (!hasAnyComponentInstruction)
{
hasAnyComponentInstruction = true;
string entityVariableName = translator.MakeUniqueName("entity");
yield return(RoslynBuilder.DeclareLocalVariable(typeof(Entity), entityVariableName, newEntity));
newInstance = SyntaxFactory.IdentifierName(entityVariableName);
}
instructions = entityTranslator.AddComponent(translator.context, newInstance, componentType,
BuildNewComponent(th, componentType));
foreach (var instruction in instructions)
{
yield return(instruction);
}
}
if (!hasAnyComponentInstruction) // implicit variable, never used in the loop
{
yield return(SyntaxFactory.ExpressionStatement(newEntity));
}
ExpressionSyntax BuildNewComponent(TypeHandle componentTypeHandle, Type componentType)
{
var componentInput = model.GetPortsForComponent(componentTypeHandle).ToArray();
var newComponent = translator.BuildComponentFromInput(componentType, componentInput);
return(newComponent);
}
}
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 PathElement(SourceFileContext ctx, ResourceDetails.Definition def, string rawPathElement)
{
var nameWithoutId = rawPathElement.RemoveSuffix("_id");
var nameWithId = $"{nameWithoutId}_id";
UpperCamel = nameWithoutId.ToUpperCamelCase();
LowerCamel = nameWithoutId.ToLowerCamelCase();
Parameter = RoslynBuilder.Parameter(ctx.Type <string>(), nameWithId.ToLowerCamelCase());
ParameterWithDefault = RoslynBuilder.Parameter(ctx.Type <string>(), nameWithId.ToLowerCamelCase(), @default: Null);
ParameterXmlDoc = XmlDoc.Param(Parameter, "The ", XmlDoc.C(nameWithoutId.ToUpperCamelCase()), " ID. Must not be ", null, " or empty.");
var summarySuffix = def.Patterns.Count > 1 ?
new object[] { "May be ", null, ", depending on which resource name is contained by this instance." } :
new object[] { "Will not be ", null, ", unless this instance contains an unparsed resource name." };
Property = AutoProperty(Public, ctx.Type <string>(), nameWithId.ToUpperCamelCase())
.WithXmlDoc(XmlDoc.Summary(new object[] { "The ", XmlDoc.C(nameWithoutId.ToUpperCamelCase()), " ID. " }.Concat(summarySuffix).ToArray()));
}
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);
}
public static IEnumerable <SyntaxNode> BuildSetTranslation(this RoslynEcsTranslator translator, SetPositionNodeModel model, IPortModel portModel)
{
IPortModel entityOrComponentPort = model.InstancePort;
if (!translator.GetComponentFromEntityOrComponentPort(model, entityOrComponentPort, out _, out ExpressionSyntax setValue, RoslynEcsTranslator.AccessMode.Write))
{
yield break;
}
switch (model.Mode)
{
case SetPositionNodeModel.TranslationMode.Float3:
yield return(RoslynBuilder.SetProperty(
model.Add ? RoslynBuilder.AssignmentKind.Add : RoslynBuilder.AssignmentKind.Set,
setValue,
translator.BuildPort(model.GetInput(SetPositionNodeModel.InputType.Value)).FirstOrDefault() as ExpressionSyntax,
nameof(Translation.Value)));
break;
case SetPositionNodeModel.TranslationMode.Axis:
var inputTypes = new[]
{
Tuple.Create(SetPositionNodeModel.InputType.X, nameof(float3.x)),
Tuple.Create(SetPositionNodeModel.InputType.Y, nameof(float3.y)),
Tuple.Create(SetPositionNodeModel.InputType.Z, nameof(float3.z))
};
foreach (var inputType in inputTypes)
{
IPortModel axisPort = model.GetInput(inputType.Item1);
yield return(RoslynBuilder.SetProperty(
model.Add ? RoslynBuilder.AssignmentKind.Add : RoslynBuilder.AssignmentKind.Set,
setValue,
translator.BuildPort(axisPort).FirstOrDefault() as ExpressionSyntax,
nameof(Translation.Value), inputType.Item2));
}
break;
}
}
public static IEnumerable <SyntaxNode> BuildSetTranslation(this RoslynEcsTranslator translator, SetRotationNodeModel model, IPortModel portModel)
{
ExpressionSyntax BuildPortForInput(SetRotationNodeModel.InputType inputType)
{
return(translator.BuildPort(model.GetInput(inputType)).FirstOrDefault() as ExpressionSyntax);
}
ExpressionSyntax value;
switch (model.Mode)
{
case SetRotationNodeModel.RotationMode.Axis:
var axisValue = BuildPortForInput(SetRotationNodeModel.InputType.Axis);
var angleValue = BuildPortForInput(SetRotationNodeModel.InputType.Angle);
axisValue = InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(nameof(math)), IdentifierName(nameof(math.normalize)))).WithArgumentList(ArgumentList(SingletonSeparatedList(Argument(axisValue))));
value = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(nameof(quaternion)),
IdentifierName(nameof(quaternion.AxisAngle))))
.WithArgumentList(
ArgumentList(
SeparatedList(new[]
{
Argument(axisValue),
Argument(angleValue)
})));
break;
case SetRotationNodeModel.RotationMode.Quaternion:
value = BuildPortForInput(SetRotationNodeModel.InputType.Quaternion);
break;
case SetRotationNodeModel.RotationMode.Euler:
value = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(nameof(quaternion)),
IdentifierName(nameof(quaternion.EulerXYZ))))
.WithArgumentList(
ArgumentList(
SeparatedList(new[]
{
Argument(BuildPortForInput(SetRotationNodeModel.InputType.X)),
Argument(BuildPortForInput(SetRotationNodeModel.InputType.Y)),
Argument(BuildPortForInput(SetRotationNodeModel.InputType.Z))
})));
break;
default:
throw new ArgumentOutOfRangeException();
}
if (!translator.GetComponentFromEntityOrComponentPort(model, model.InstancePort, out _, out ExpressionSyntax setValue, RoslynEcsTranslator.AccessMode.Write))
{
yield break;
}
var finalValue = !model.Add
? value
: InvocationExpression( // rot.value = math.mul(rot.value, <input>)
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(nameof(math)),
IdentifierName(nameof(math.mul))))
.WithArgumentList(
ArgumentList(
SeparatedList(new[]
{
Argument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
setValue,
IdentifierName(nameof(Rotation.Value)))),
Argument(value)
})));
yield return(RoslynBuilder.SetProperty(
RoslynBuilder.AssignmentKind.Set,
setValue,
finalValue,
nameof(Rotation.Value)
));
}
