public void PopulateFields(DetailsStore store)
{
FieldDetails = raw.Fields
.Select(field => new UnityFieldDetails(field, store))
.ToList()
.AsReadOnly();
}
public UnityFieldDetails(Field field, DetailsStore store)
{
PascalCaseName = Formatting.SnakeCaseToPascalCase(field.Identifier.Name);
CamelCaseName = Formatting.PascalCaseToCamelCase(PascalCaseName);
FieldNumber = field.FieldId;
IsBlittable = store.BlittableMap.Contains(field.Identifier);
if (field.Option != null)
{
CanBeEmpty = true;
fieldType = new OptionFieldType(field.Option.InnerType, store);
}
else if (field.List != null)
{
CanBeEmpty = true;
fieldType = new ListFieldType(field.List.InnerType, store);
}
else if (field.Map != null)
{
CanBeEmpty = true;
fieldType = new MapFieldType(field.Map.KeyType, field.Map.ValueType, store);
}
else
{
var singularType = field.Singular.Type;
fieldType = new SingularFieldType(singularType, store);
}
}
// TODO: This can probably be reworked with the inner type concept.
public ContainedType(Field.InnerType innerType, DetailsStore store)
{
if (innerType.Primitive != null)
{
category = ContainedTypeCategory.Primitive;
Type = CommonDetailsUtils.GetCapitalisedFqnTypename(innerType.Primitive);
rawType = innerType.Primitive;
}
else if (innerType.UserType != null)
{
category = ContainedTypeCategory.UserDefined;
Type = CommonDetailsUtils.GetCapitalisedFqnTypename(innerType.UserType.QualifiedName);
rawType = innerType.UserType.QualifiedName;
}
else if (innerType.EnumType != null)
{
category = ContainedTypeCategory.Enum;
Type = CommonDetailsUtils.GetCapitalisedFqnTypename(innerType.EnumType.QualifiedName);
rawType = innerType.EnumType.QualifiedName;
}
else
{
throw new ArgumentException("Malformed inner type.");
}
}
public UnityFieldDetails(FieldDefinition field, DetailsStore store)
{
PascalCaseName = Formatting.SnakeCaseToPascalCase(field.Name);
CamelCaseName = Formatting.PascalCaseToCamelCase(PascalCaseName);
FieldNumber = field.FieldId;
IsBlittable = store.CheckBlittable(field);
if (field.OptionType != null)
{
CanBeEmpty = true;
fieldType = new OptionFieldType(field.OptionType.InnerType, store);
}
else if (field.ListType != null)
{
CanBeEmpty = true;
fieldType = new ListFieldType(field.ListType.InnerType, store);
}
else if (field.MapType != null)
{
CanBeEmpty = true;
fieldType = new MapFieldType(field.MapType.KeyType, field.MapType.ValueType, store);
}
else
{
var singularType = field.SingularType.Type;
fieldType = new SingularFieldType(singularType, store);
}
}
public int Run()
{
if (options.ShouldShowHelp)
{
ShowHelpMessage();
return(0);
}
if (!ValidateOptions())
{
ShowHelpMessage();
return(1);
}
var bundlePath = GenerateBundle();
var schemaBundle = SchemaBundle.FromJson(File.ReadAllText(bundlePath));
var store = new DetailsStore(schemaBundle);
var workerGenerationJob = new WorkerGenerationJob(options.NativeOutputDirectory, options, fileSystem);
var singleJob = new SingleGenerationJob(options.NativeOutputDirectory, store, fileSystem);
var runner = new JobRunner(fileSystem);
runner.Run(singleJob, workerGenerationJob);
return(0);
}
public WorkerGenerationJob(string baseOutputDir, IFileSystem fileSystem, DetailsStore detailsStore) : base(baseOutputDir, fileSystem, detailsStore)
{
workerTypesToGenerate = ExtractWorkerTypes(CodeGeneratorOptions.Instance.WorkerJsonDirectory);
OutputFiles.Add(Path.Combine(relativeEditorPath, workerFileName));
OutputFiles.Add(Path.Combine(relativeEditorPath, workerListFileName));
OutputFiles.Add(Path.Combine(relativeOutputPath, buildSystemFileName));
}
public void PopulateFields(DetailsStore store)
{
if (raw.Data != null)
{
FieldDetails = store.Types[CommonDetailsUtils.CreateIdentifier(raw.Data.QualifiedName)].FieldDetails;
}
else
{
FieldDetails = raw.Fields
.Select(field => new UnityFieldDetails(field, store))
.ToList()
.AsReadOnly();
}
}
public void PopulateFields(DetailsStore store)
{
if (!string.IsNullOrEmpty(raw.DataDefinition))
{
FieldDetails = store.Types[raw.DataDefinition].FieldDetails;
}
else
{
FieldDetails = raw.Fields
.Select(field => new UnityFieldDetails(field, store))
.ToList()
.AsReadOnly();
}
}
public void PopulateChildren(DetailsStore store)
{
var children = store.GetNestedTypes(Identifier);
ChildTypes = store.Types
.Where(kv => children.Contains(kv.Key))
.Select(kv => kv.Value)
.ToList()
.AsReadOnly();
ChildEnums = store.Enums
.Where(kv => children.Contains(kv.Key))
.Select(kv => kv.Value)
.ToList()
.AsReadOnly();
}
public int Run()
{
if (options.ShouldShowHelp)
{
ShowHelpMessage();
return(0);
}
if (!ValidateOptions())
{
ShowHelpMessage();
return(1);
}
var bundlePath = GenerateBundle();
var schemaBundle = SchemaBundle.LoadBundle(File.ReadAllText(bundlePath));
var fileTree = new FileTree(options.SchemaInputDirs);
var store = new DetailsStore(schemaBundle, options.SerializationOverrides, fileTree);
var jobs = AppDomain.CurrentDomain
.GetAssemblies()
.SelectMany(assembly =>
{
try
{
return(assembly.GetTypes());
}
catch (ReflectionTypeLoadException e)
{
Console.Error.WriteLine($"Failed to load assembly {assembly.FullName} with error {e}");
return(Enumerable.Empty <Type>());
}
})
.Where(type => typeof(CodegenJob).IsAssignableFrom(type))
.Where(type => !type.IsAbstract)
.Where(type => !type.GetCustomAttributes(typeof(IgnoreCodegenJobAttribute)).Any())
.Select(type =>
(CodegenJob)Activator.CreateInstance(type, options.NativeOutputDirectory, fileSystem, store))
.ToArray();
new JobRunner(fileSystem).Run(jobs);
return(0);
}
public UnityComponentDetails(ComponentDefinitionRaw componentDefinitionRaw, DetailsStore store)
{
ComponentName = componentDefinitionRaw.Identifier.Name;
ComponentId = componentDefinitionRaw.ComponentId;
IsBlittable = store.BlittableMap.Contains(componentDefinitionRaw.Identifier);
CommandDetails = componentDefinitionRaw.Commands
.Select(command => new UnityCommandDetails(command))
.ToList()
.AsReadOnly();
EventDetails = componentDefinitionRaw.Events
.Select(ev => new UnityEventDetails(ev))
.ToList()
.AsReadOnly();
Identifier = componentDefinitionRaw.Identifier;
raw = componentDefinitionRaw;
}
public WorkerGenerationJob(string baseOutputDir, IFileSystem fileSystem, DetailsStore detailsStore)
: base(baseOutputDir, fileSystem, detailsStore)
{
const string jobName = nameof(WorkerGenerationJob);
logger.Info($"Initialising {jobName}.");
workerTypesToGenerate = ExtractWorkerTypes(CodeGeneratorOptions.Instance.WorkerJsonDirectory);
var outputFilePaths = new List <string>
{
Path.Combine(relativeEditorPath, WorkerFileName),
Path.Combine(relativeEditorPath, WorkerListFileName),
Path.Combine(relativeOutputPath, BuildSystemFileName)
};
AddOutputFiles(outputFilePaths);
logger.Info($"Added {outputFilePaths.Count} job output files.");
logger.Info($"Finished initialising {jobName}.");
}
public WorkerGenerationJob(string baseOutputDir, IFileSystem fileSystem, DetailsStore detailsStore, bool force)
: base(baseOutputDir, fileSystem, detailsStore, force)
{
const string jobName = nameof(WorkerGenerationJob);
Logger.Trace($"Initialising {jobName}.");
var workerTypesToGenerate = ExtractWorkerTypes(CodeGeneratorOptions.Instance.WorkerJsonDirectory);
Logger.Trace($"Adding job target {WorkerFileName}.");
AddJobTarget(Path.Combine(relativeEditorPath, WorkerFileName),
() => UnityWorkerMenuGenerator.Generate(workerTypesToGenerate));
Logger.Trace($"Adding job target for {BuildSystemFileName}.");
AddJobTarget(Path.Combine(relativeEditorPath, BuildSystemFileName),
() => BuildSystemAssemblyGenerator.Generate());
Logger.Trace($"Adding job target for {WorkerListFileName}.");
AddJobTarget(Path.Combine(relativeOutputPath, WorkerListFileName),
() => string.Join(Environment.NewLine, workerTypesToGenerate));
Logger.Trace($"Finished initialising {jobName}.");
}
public FieldTypeHandler(DetailsStore detailsStore)
{
this.detailsStore = detailsStore;
}
public SingularFieldType(TypeReference innerType, DetailsStore store)
{
containedType = new ContainedType(innerType);
}
public MapFieldType(TypeReference keyType, TypeReference valueType, DetailsStore store)
{
this.keyType = new ContainedType(keyType);
this.valueType = new ContainedType(valueType);
}
public OptionFieldType(TypeReference innerType, DetailsStore store)
{
containedType = new ContainedType(innerType);
}
public OptionFieldType(Field.InnerType innerType, DetailsStore store)
{
containedType = new ContainedType(innerType, store);
}
public TestCodegenJob(string baseOutputDir, IFileSystem fileSystem, DetailsStore detailsStore, bool force)
: base(baseOutputDir, fileSystem, detailsStore, force)
{
AddOutputFile(relativeOutputPath);
AddOutputFile(relativeTemplateOutputPath);
}
public int Run()
{
if (options.ShouldShowHelp)
{
ShowHelpMessage();
return(0);
}
var optionErrors = options.GetValidationErrors().ToList();
foreach (var optionError in optionErrors)
{
Console.WriteLine(optionError);
}
if (optionErrors.Any())
{
ShowHelpMessage();
return(1);
}
logger.Info("Starting code generation.");
logger.Info("Gathering schema information.");
var bundlePath = GenerateBundle();
logger.Info("Loading schema bundle from json.");
var schemaBundle = SchemaBundle.LoadBundle(File.ReadAllText(bundlePath));
logger.Info("Setting up schema file tree.");
var fileTree = new FileTree(options.SchemaInputDirs);
logger.Info("Initialising DetailsStore.");
var store = new DetailsStore(schemaBundle, options.SerializationOverrides, fileTree);
logger.Info("Setting up code generation jobs.");
var jobs = AppDomain.CurrentDomain
.GetAssemblies()
.SelectMany(assembly =>
{
try
{
return(assembly.GetTypes());
}
catch (ReflectionTypeLoadException e)
{
logger.Error(e, $"Failed to load assembly {assembly.FullName}.");
return(Enumerable.Empty <Type>());
}
})
.Where(type => typeof(CodegenJob).IsAssignableFrom(type))
.Where(type => !type.IsAbstract)
.Where(type => !type.GetCustomAttributes(typeof(IgnoreCodegenJobAttribute)).Any())
.Select(type =>
{
logger.Info($"Creating instance of {type}.");
return((CodegenJob)Activator.CreateInstance(type, options.NativeOutputDirectory, fileSystem, store, options.Force));
})
.ToArray();
logger.Info("Calling JobRunner.");
new JobRunner(fileSystem).Run(jobs);
logger.Info("Finished code generation.");
return(0);
}
public SingularFieldType(Field.InnerType innerType, DetailsStore store)
{
containedType = new ContainedType(innerType, store);
}
public MapFieldType(Field.InnerType keyType, Field.InnerType valueType, DetailsStore store)
{
this.keyType = new ContainedType(keyType, store);
this.valueType = new ContainedType(valueType, store);
}
public TestCodegenJob(string baseOutputDir, IFileSystem fileSystem, DetailsStore detailsStore) : base(
baseOutputDir, fileSystem, detailsStore)
{
OutputFiles.Add(relativeOutputPath);
OutputFiles.Add(relativeTemplateOutputPath);
}
public ComponentVisualElementGenerator(DetailsStore detailsStore)
{
typeGenerator = new FieldTypeHandler(detailsStore);
}
public SingleGenerationJob(string outputDir, DetailsStore store, IFileSystem fileSystem) : base(
outputDir, fileSystem)
{
InputFiles = store.SchemaFiles.ToList();
OutputFiles = new List <string>();
var allNestedTypes = store.Types
.SelectMany(kv => store.GetNestedTypes(kv.Key))
.ToHashSet();
typesToGenerate = store.Types
.Where(kv => !allNestedTypes.Contains(kv.Key))
.Select(kv => new GenerationTarget <UnityTypeDetails>(kv.Value, kv.Value.Package))
.ToList();
enumsToGenerate = store.Enums
.Where(kv => !allNestedTypes.Contains(kv.Key))
.Select(kv => new GenerationTarget <UnityEnumDetails>(kv.Value, kv.Value.Package))
.ToList();
componentsToGenerate = store.Components
.Select(kv => new GenerationTarget <UnityComponentDetails>(kv.Value, kv.Value.Package))
.ToList();
foreach (var typeTarget in typesToGenerate)
{
var fileName = Path.ChangeExtension(typeTarget.Content.CapitalisedName, FileExtension);
OutputFiles.Add(Path.Combine(typeTarget.OutputPath, fileName));
}
foreach (var componentTarget in componentsToGenerate)
{
var relativeOutputPath = componentTarget.OutputPath;
var componentName = componentTarget.Content.ComponentName;
OutputFiles.Add(Path.Combine(relativeOutputPath, Path.ChangeExtension(componentTarget.Content.ComponentName, FileExtension)));
if (componentTarget.Content.CommandDetails.Count > 0)
{
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}CommandPayloads", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}CommandComponents", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}CommandSenderReceiver", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}ReactiveCommandComponents", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}CommandDiffDeserializer", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}CommandDiffStorage", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}CommandMetaDataStorage", FileExtension)));
}
if (componentTarget.Content.EventDetails.Count > 0)
{
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}Events", FileExtension)));
}
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}UpdateSender", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}ReactiveHandlers", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}EcsViewManager", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}ComponentDiffStorage", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}ComponentDiffDeserializer", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}ReactiveComponents", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}Providers", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}ComponentReaderWriter", FileExtension)));
OutputFiles.Add(Path.Combine(relativeOutputPath,
Path.ChangeExtension($"{componentName}ViewStorage", FileExtension)));
}
foreach (var enumTarget in enumsToGenerate)
{
var fileName = Path.ChangeExtension(enumTarget.Content.TypeName, FileExtension);
OutputFiles.Add(Path.Combine(enumTarget.OutputPath, fileName));
}
}
public TypeVisualElementGenerator(DetailsStore detailsStore)
{
fieldTypeHandler = new FieldTypeHandler(detailsStore);
}
public ComponentVisualElementJob(CodegenJobOptions options, IFileSystem fileSystem, DetailsStore detailsStore) : base(options.AsEditor(), fileSystem, detailsStore)
{
const string jobName = nameof(ComponentVisualElementJob);
Logger.Trace($"Initialising {jobName}.");
Logger.Trace($"Adding job target for {DebugAsmdefFileName}");
AddJobTarget(Path.Combine(relativeOutputPath, DebugAsmdefFileName), () => DebugAssemblyGenerator.Generate());
var componentsToGenerate = detailsStore.Components.Values.ToList();
var componentGenerator = new ComponentVisualElementGenerator(detailsStore);
AddGenerators(relativeOutputPath, componentsToGenerate, component => ($"{component.Name}Renderer.cs", componentGenerator.Generate));
Logger.Trace($"Added job targets for {componentsToGenerate.Count} components");
// Types
Logger.Trace("Gathering nested types.");
var allNestedTypes = detailsStore.Types
.SelectMany(kv => detailsStore.GetNestedTypes(kv.Key))
.ToHashSet();
Logger.Trace("Gathering types details.");
var typesToGenerate = detailsStore.Types
.Where(kv => !allNestedTypes.Contains(kv.Key))
.Select(kv => kv.Value)
.ToList();
var typeGenerator = new TypeVisualElementGenerator(detailsStore);
AddGenerators(relativeOutputPath, typesToGenerate, type => ($"{type.Name}Renderer.cs", typeGenerator.Generate));
Logger.Trace($"Added job targets for {typesToGenerate.Count} types");
}
public UnityComponentDetails(string package, ComponentDefinition componentDefinitionRaw, DetailsStore store)
{
Package = package;
ComponentName = componentDefinitionRaw.Name;
ComponentId = componentDefinitionRaw.ComponentId;
IsBlittable = store.BlittableSet.Contains(componentDefinitionRaw.QualifiedName);
CommandDetails = componentDefinitionRaw.Commands
.Select(command => new UnityCommandDetails(command))
.ToList()
.AsReadOnly();
EventDetails = componentDefinitionRaw.Events
.Select(ev => new UnityEventDetails(ev))
.ToList()
.AsReadOnly();
raw = componentDefinitionRaw;
}
public TestCodegenJob(string baseOutputDir, IFileSystem fileSystem, DetailsStore detailsStore, bool force)
: base(baseOutputDir, fileSystem, detailsStore, force)
{
AddJobTarget(relativeOutputPath, () => TestContent);
AddJobTarget(relativeTemplateOutputPath, () => ModularCodegenTestGenerator.Generate());
}