public string Generate(UnityTypeDetails details, string package)
{
qualifiedNamespace = package;
this.details = details;
return(TransformText());
}
private void GenerateUpdateMethod(TypeBlock typeBlock, UnityTypeDetails details)
{
typeBlock.Method($"public override void Update({details.FullyQualifiedName} data)", mb =>
{
mb.TextList(details.FieldDetails.Select(fd => fieldTypeHandler.ToUiFieldUpdate(fd, "data")));
});
}
public string Generate(UnityTypeDetails details)
{
this.details = details;
nestedTypes = details.ChildTypes;
nestedEnums = details.ChildEnums;
return(TransformText());
}
private void GenerateConstructor(TypeBlock typeBlock, UnityTypeDetails details)
{
typeBlock.Method($"public {details.Name}Renderer(string label) : base(label)", mb =>
{
foreach (var field in details.FieldDetails)
{
mb.TextList(fieldTypeHandler.ToFieldInitialisation(field, "Container"));
}
});
}
private static TypeBlock GenerateSerializationClass(UnityTypeDetails typeDetails)
{
var fieldDetails = typeDetails.FieldDetails;
return(Scope.Type("public static class Serialization", s =>
{
s.Method($"public static void Serialize({typeDetails.CapitalisedName} instance, global::Improbable.Worker.CInterop.SchemaObject obj)",
serializeMethod =>
{
if (typeDetails.HasSerializationOverride)
{
serializeMethod.CustomScope(() => new[]
{
typeDetails.SerializationOverride.GetSerializationString("instance", "obj")
});
}
else
{
foreach (var fieldDetail in fieldDetails)
{
serializeMethod.CustomScope(() => new[]
{
fieldDetail.GetSerializationString($"instance.{fieldDetail.PascalCaseName}", "obj", 0)
});
}
}
});
s.Method($"public static {typeDetails.CapitalisedName} Deserialize(global::Improbable.Worker.CInterop.SchemaObject obj)",
deserializeMethod =>
{
if (typeDetails.HasSerializationOverride)
{
var deserializeString = typeDetails.SerializationOverride.GetDeserializeString("obj");
deserializeMethod.Return(deserializeString);
}
else
{
deserializeMethod.Line($"var instance = new {typeDetails.CapitalisedName}();");
foreach (var fieldDetail in fieldDetails)
{
deserializeMethod.CustomScope(() => new[]
{
fieldDetail.GetDeserializeString($"instance.{fieldDetail.PascalCaseName}", "obj", 0)
});
}
deserializeMethod.Return("instance");
}
});
}));
}
public static TypeBlock Generate(UnityTypeDetails details, string typeNamespace)
{
var nestedTypes = details.ChildTypes;
var nestedEnums = details.ChildEnums;
var typeDetails = details;
var fieldDetailsList = details.FieldDetails;
var hasPartial = PartialDatabase.TryGetPartial(typeDetails.GetPartialResourceTypeName(), out var partial);
Logger.Trace($"Generating {typeNamespace}.{typeDetails.CapitalisedName} struct.");
return(Scope.AnnotatedType("global::System.Serializable",
$"public struct {typeDetails.CapitalisedName}", s =>
{
if (fieldDetailsList.Count > 0)
{
s.Line(fieldDetailsList
.Select(fd => $"public {fd.Type} {fd.PascalCaseName};")
.ToList());
var constructorArgs = GetConstructorArgs(fieldDetailsList);
s.Method($"public {typeDetails.CapitalisedName}({constructorArgs})", m =>
{
m.Line(sb =>
{
foreach (var fd in fieldDetailsList)
{
sb.AppendLine($"{fd.PascalCaseName} = {fd.CamelCaseName};");
}
});
});
}
if (hasPartial)
{
s.Line(partial);
}
s.Type(GenerateSerializationClass(typeDetails));
foreach (var nestedType in nestedTypes)
{
s.Type(Generate(nestedType, $"{typeNamespace}.{typeDetails.CapitalisedName}"));
}
foreach (var nestedEnum in nestedEnums)
{
s.Enum(UnityEnumContent.Generate(nestedEnum, $"{typeNamespace}.{typeDetails.CapitalisedName}"));
}
}));
}
private TypeBlock GenerateType(UnityTypeDetails details)
{
return(Scope.Type($"public class {details.Name}Renderer : SchemaTypeVisualElement<{details.FullyQualifiedName}>",
type =>
{
type.TextList(details.FieldDetails.Select(fieldTypeHandler.ToFieldDeclaration));
GenerateConstructor(type, details);
GenerateUpdateMethod(type, details);
foreach (var nestedType in details.ChildTypes)
{
type.Type(GenerateType(nestedType));
}
}));
}
public CodeWriter Generate(UnityTypeDetails details)
{
return(CodeWriter.Populate(cgw =>
{
cgw.UsingDirectives(
"UnityEngine.UIElements",
"UnityEditor.UIElements",
"Improbable.Gdk.Debug.WorkerInspector.Codegen"
);
cgw.Namespace(details.Namespace, ns =>
{
ns.Type(GenerateType(details));
});
}));
}
public static CodeWriter Generate(UnityTypeDetails details)
{
return(CodeWriter.Populate(cgw =>
{
cgw.UsingDirectives(
"System.Linq",
"Improbable.Gdk.Core",
"UnityEngine"
);
cgw.Namespace(details.Namespace, ns =>
{
ns.Type(UnityTypeContent.Generate(details, details.Namespace));
});
}));
}
public static string Generate(UnityTypeDetails details, string package)
{
var qualifiedNamespace = package;
return(CodeWriter.Populate(cgw =>
{
cgw.UsingDirectives(
"System.Linq",
"Improbable.Gdk.Core",
"UnityEngine"
);
cgw.Namespace(qualifiedNamespace, ns =>
{
ns.Type(UnityTypeContent.Generate(details, qualifiedNamespace));
});
}).Format());
}
public DetailsStore(SchemaBundle bundle, List <string> serializationOverrides)
{
this.bundle = bundle;
var overrideMap = serializationOverrides.Select(@override =>
{
var parts = @override.Split(";");
if (parts.Length != 2)
{
throw new ArgumentException($"Serialization override malformed: {@override}");
}
return(parts[0], parts[1]);
}).ToDictionary(pair => pair.Item1, pair => pair.Item2);
PopulateBlittableMaps();
BlittableSet = ImmutableHashSet.CreateRange(blittableMap.Where(kv => kv.Value).Select(kv => kv.Key));
var enums = new Dictionary <string, UnityEnumDetails>();
var types = new Dictionary <string, UnityTypeDetails>();
var components = new Dictionary <string, UnityComponentDetails>();
foreach (var file in bundle.SchemaFiles)
{
foreach (var enumm in file.Enums)
{
enums.Add(enumm.QualifiedName, new UnityEnumDetails(file.Package.Name, enumm));
}
foreach (var type in file.Types)
{
var typeDetails = new UnityTypeDetails(file.Package.Name, type);
if (overrideMap.TryGetValue(typeDetails.FullyQualifiedTypeName, out var staticClassFqn))
{
typeDetails.SerializationOverride = new SerializationOverride(staticClassFqn);
}
types.Add(type.QualifiedName, typeDetails);
}
foreach (var component in file.Components)
{
components.Add(component.QualifiedName, new UnityComponentDetails(file.Package.Name, component, this));
}
}
Enums = new ReadOnlyDictionary <string, UnityEnumDetails>(enums);
Types = new ReadOnlyDictionary <string, UnityTypeDetails>(types);
Components = new ReadOnlyDictionary <string, UnityComponentDetails>(components);
SchemaFiles = bundle.SchemaFiles
.Select(file => file.CanonicalPath)
.ToList().AsReadOnly();
foreach (var kv in Types)
{
kv.Value.PopulateFields(this);
kv.Value.PopulateChildren(this);
}
foreach (var kv in Components)
{
kv.Value.PopulateFields(this);
}
RemoveRecursiveOptions();
}
