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