public static IEnumerable <SyntaxNode> BuildUnaryOperator(this RoslynTranslator translator, UnaryOperatorNodeModel model, IPortModel portModel)
{
var semantic = model.Kind == UnaryOperatorKind.PostDecrement ||
model.Kind == UnaryOperatorKind.PostIncrement
? RoslynTranslator.PortSemantic.Write
: RoslynTranslator.PortSemantic.Read;
yield return(RoslynBuilder.UnaryOperator(model.Kind, translator.BuildPort(model.InputPort, semantic).SingleOrDefault()));
}
public static IEnumerable <SyntaxNode> BuildGetPropertyNode(this RoslynTranslator translator, GetPropertyGroupNodeModel model, IPortModel portModel)
{
var instancePort = model.InstancePort;
var input = !instancePort.IsConnected ? SyntaxFactory.ThisExpression() : translator.BuildPort(instancePort).SingleOrDefault();
if (input == null)
{
yield break;
}
var member = model.Members.FirstOrDefault(m => m.GetId() == portModel.UniqueId);
if (member.Path == null || member.Path.Count == 0)
{
yield break;
}
var access = RoslynBuilder.MemberReference(input, member.Path.ToArray());
yield return(access);
}
IEnumerable <SyntaxNode> BuildPortInner(IPortModel portModel, out INodeModel builtNode)
{
var connectedPort = portModel.ConnectionPortModels.FirstOrDefault();
if (connectedPort != null && connectedPort.NodeModel.State == ModelState.Enabled)
{
return(BuildNode(builtNode = connectedPort.NodeModel, connectedPort));
}
// if it' s an embedded value, no point in recording its value, keep a null builtNode
builtNode = null;
if (portModel.EmbeddedValue != null)
{
return(BuildNode(portModel.EmbeddedValue));
}
// return default datatype value (null) if not connected. not recorded either
var defaultValue = RoslynBuilder.GetDefault(portModel.DataTypeHandle.Resolve(Stencil));
return(Enumerable.Repeat(defaultValue == null
? LiteralExpression(SyntaxKind.NullLiteralExpression)
: Constant(defaultValue, Stencil), 1));
}
protected virtual Microsoft.CodeAnalysis.SyntaxTree ToSyntaxTree(VSGraphModel graphModel, CompilationOptions options)
{
//TODO fix graph name, do not use the asset name
var className = graphModel.TypeName;
var baseClass = graphModel.Stencil.GetBaseClass().Name;
var classDeclaration = ClassDeclaration(className)
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)));
if (!String.IsNullOrEmpty(baseClass))
{
classDeclaration = classDeclaration.WithBaseList(
BaseList(
SingletonSeparatedList <BaseTypeSyntax>(
SimpleBaseType(
IdentifierName(baseClass)))));
}
if (graphModel.Stencil.addCreateAssetMenuAttribute)
{
classDeclaration = classDeclaration.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("CreateAssetMenu"))
.WithArgumentList(
AttributeArgumentList(
SeparatedList <AttributeArgumentSyntax>(
new SyntaxNodeOrToken[]
{
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(graphModel.Stencil.fileName)))
.WithNameEquals(
NameEquals(
IdentifierName("fileName"))),
Token(SyntaxKind.CommaToken),
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(graphModel.Stencil.menuName)))
.WithNameEquals(
NameEquals(
IdentifierName("menuName")))
})))))));
}
var allMembers = new List <MemberDeclarationSyntax>();
m_AllFields = new List <MemberDeclarationSyntax>();
var allRemainingMembers = new List <MemberDeclarationSyntax>();
foreach (var fieldDecl in graphModel.GraphVariableModels)
{
var fieldSyntaxNode = fieldDecl.DeclareField(this);
m_AllFields.Add(fieldSyntaxNode);
}
var entryPoints = graphModel.GetEntryPoints();
Dictionary <string, MethodDeclarationSyntax> declaredMethods = new Dictionary <string, MethodDeclarationSyntax>();
foreach (var stack in entryPoints)
{
var entrySyntaxNode = BuildNode(stack);
foreach (var memberDeclaration in entrySyntaxNode.Cast <MemberDeclarationSyntax>())
{
if (memberDeclaration is MethodDeclarationSyntax methodDeclarationSyntax)
{
string key = methodDeclarationSyntax.Identifier.ToString();
declaredMethods.Add(key, methodDeclarationSyntax);
}
else
{
allRemainingMembers.Add(memberDeclaration);
}
}
}
allMembers.AddRange(m_AllFields);
m_AllFields = null;
allMembers.AddRange(allRemainingMembers);
if (m_EventRegistrations.Any())
{
if (!declaredMethods.TryGetValue("Update", out var method))
{
method = RoslynBuilder.DeclareMethod("Update", AccessibilityFlags.Public, typeof(void))
.WithParameterList(
ParameterList(
SeparatedList(
Enumerable.Empty <ParameterSyntax>())))
.WithBody(Block());
}
BlockSyntax blockSyntax = Block(m_EventRegistrations.Concat(method.Body.Statements));
method = method.WithBody(blockSyntax);
declaredMethods["Update"] = method;
}
allMembers.AddRange(declaredMethods.Values);
classDeclaration = classDeclaration.AddMembers(allMembers.ToArray());
var referencedNamespaces = UsingDirectives.OrderBy(n => n).Select(ns => UsingDirective(ParseName(ns)));
var namespaceAliases = UsingAliases.OrderBy(n => n.Key).Select(pair =>
UsingDirective(ParseName(pair.Key))
.WithAlias(NameEquals(
IdentifierName(pair.Value))));
var usings = referencedNamespaces.Concat(namespaceAliases).ToArray();
var compilationUnit = CompilationUnit()
.WithUsings(
List(usings))
.WithMembers(
SingletonList <MemberDeclarationSyntax>(classDeclaration)).NormalizeWhitespace();
return(compilationUnit.SyntaxTree);
}
public virtual ExpressionSyntax Constant(object value, Stencil stencil, Type generatedType = null)
{
switch (value)
{
case float f:
return(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(f)));
case decimal d:
return(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(d)));
case int i:
return(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(i)));
case double d:
return(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(d)));
case bool b:
return(LiteralExpression(b ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression));
case string s:
return(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(s)));
case char c:
return(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(c)));
case Vector2 _:
case Vector3 _:
case Vector4 _:
case Quaternion _:
case Color _:
if (generatedType == null)
{
generatedType = value.GetType();
}
return(RoslynBuilder.CreateConstantInitializationExpression(value, generatedType));
case Enum _:
return(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(value.GetType().Name),
IdentifierName(value.ToString())
));
case EnumValueReference e:
return(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
TypeSystem.BuildTypeSyntax(e.EnumType.Resolve(stencil)),
IdentifierName(e.ValueAsEnum(stencil).ToString())
));
case AnimationCurve _:
return(DefaultExpression(TypeSyntaxFactory.ToTypeSyntax(typeof(AnimationCurve))));
case LayerMask m:
return(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(m.value)));
case InputName inputName:
return(inputName.name == null
? LiteralExpression(SyntaxKind.NullLiteralExpression)
: LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(inputName.name)));
case SceneAsset asset:
return(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(AssetDatabase.GetAssetPath(asset))));
default:
return(DefaultExpression(TypeSystem.BuildTypeSyntax(value.GetType())));
}
}
public static IEnumerable <SyntaxNode> BuildBinaryOperator(this RoslynTranslator translator, BinaryOperatorNodeModel model, IPortModel portModel)
{
yield return(RoslynBuilder.BinaryOperator(model.Kind,
translator.BuildPort(model.InputPortA).SingleOrDefault(),
translator.BuildPort(model.InputPortB).SingleOrDefault()));
}
