コード例 #1
0
        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");
        }
コード例 #2
0
        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();
        }
コード例 #3
0
        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));
            }
        }