863 lines
35 KiB
C#
863 lines
35 KiB
C#
using Bright.Time;
|
|
using CommandLine;
|
|
using Luban.Common.Protos;
|
|
using Luban.Common.Utils;
|
|
using Luban.Job.Cfg.Cache;
|
|
using Luban.Job.Cfg.DataCreators;
|
|
using Luban.Job.Cfg.Defs;
|
|
using Luban.Job.Cfg.Generate;
|
|
using Luban.Job.Cfg.RawDefs;
|
|
using Luban.Job.Cfg.Utils;
|
|
using Luban.Job.Common;
|
|
using Luban.Job.Common.Defs;
|
|
using Luban.Job.Common.Utils;
|
|
using Luban.Server.Common;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using FileInfo = Luban.Common.Protos.FileInfo;
|
|
|
|
namespace Luban.Job.Cfg
|
|
{
|
|
[Controller("cfg")]
|
|
public class JobController : IJobController
|
|
{
|
|
private static readonly NLog.Logger s_logger = NLog.LogManager.GetCurrentClassLogger();
|
|
|
|
class GenArgs : GenArgsBase
|
|
{
|
|
|
|
[Option("input_data_dir", Required = true, HelpText = "input data dir")]
|
|
public string InputDataDir { get; set; }
|
|
|
|
[Option('v', "validate_root_dir", Required = false, HelpText = "validate root directory")]
|
|
public string ValidateRootDir { get; set; }
|
|
|
|
[Option("output_data_dir", Required = true, HelpText = "output data directory")]
|
|
public string OutputDataDir { get; set; }
|
|
|
|
[Option("output_data_resource_list_file", Required = false, HelpText = "output resource list file")]
|
|
public string OutputDataResourceListFile { get; set; }
|
|
|
|
[Option("output_data_json_monolithic_file", Required = false, HelpText = "output monolithic json file")]
|
|
public string OutputDataJsonMonolithicFile { get; set; }
|
|
|
|
[Option("gen_types", Required = true, HelpText = "code_cs_bin,code_cs_json,code_cs_unity_json,code_lua_bin,code_java_bin,code_go_bin,code_go_json,code_cpp_bin,code_python27_json,code_python3_json,code_typescript_bin,code_typescript_json,data_bin,data_lua,data_json,data_json_monolithic . can be multi")]
|
|
public string GenType { get; set; }
|
|
|
|
[Option('s', "service", Required = true, HelpText = "service")]
|
|
public string Service { get; set; }
|
|
|
|
[Option("export_test_data", Required = false, HelpText = "export test data")]
|
|
public bool ExportTestData { get; set; } = false;
|
|
|
|
[Option('t', "l10n_timezone", Required = false, HelpText = "timezone")]
|
|
public string TimeZone { get; set; }
|
|
|
|
[Option("input_l10n_text_files", Required = false, HelpText = "input l10n text table files. can be multi, sep by ','")]
|
|
public string InputTextTableFiles { get; set; }
|
|
|
|
[Option("l10n_text_field_name", Required = false, HelpText = "text value field name of text table files. default is text")]
|
|
public string TextValueFieldName { get; set; }
|
|
|
|
[Option("output_l10n_not_converted_text_file", Required = false, HelpText = "the file save not converted l10n texts.")]
|
|
public string OutputNotConvertTextFile { get; set; }
|
|
|
|
[Option("branch", Required = false, HelpText = "branch name")]
|
|
public string BranchName { get; set; }
|
|
|
|
[Option("branch_input_data_dir", Required = false, HelpText = "branch input data root dir")]
|
|
public string BranchInputDataDir { get; set; }
|
|
}
|
|
|
|
private ICfgCodeRender CreateCodeRender(string genType)
|
|
{
|
|
switch (genType)
|
|
{
|
|
case "code_cs_bin": return new CsCodeBinRender();
|
|
case "code_cs_json": return new CsCodeJsonRender();
|
|
case "code_cs_unity_json": return new CsCodeUnityJsonRender();
|
|
case "code_java_bin": return new JavaCodeBinRender();
|
|
case "code_go_bin": return new GoCodeBinRender();
|
|
case "code_go_json": return new GoCodeJsonRender();
|
|
case "code_cpp_bin": return new CppCodeBinRender();
|
|
case "code_lua_bin": return new LuaCodeBinRender();
|
|
case "code_lua_lua": return new LuaCodeLuaRender();
|
|
case "code_python27_json": return new Python27CodeJsonRender();
|
|
case "code_python3_json": return new Python3CodeJsonRender();
|
|
case "code_typescript_bin": return new TypescriptCodeBinRender();
|
|
case "code_typescript_json": return new TypescriptCodeJsonRender();
|
|
case "code_cpp_ue_editor": return new UE4EditorCppRender();
|
|
case "code_cpp_ue_bp": return new UE4BpCppRender();
|
|
case "code_cs_unity_editor": return new EditorCsRender();
|
|
default: throw new ArgumentException($"not support gen type:{genType}");
|
|
}
|
|
}
|
|
|
|
private ELanguage GetLanguage(string genType)
|
|
{
|
|
switch (genType)
|
|
{
|
|
case "code_cs_bin":
|
|
case "code_cs_json":
|
|
case "code_cs_unity_json":
|
|
return ELanguage.CS;
|
|
case "code_java_bin": return ELanguage.JAVA;
|
|
case "code_go_bin":
|
|
case "code_go_json": return ELanguage.GO;
|
|
case "code_cpp_bin": return ELanguage.CPP;
|
|
case "code_lua_bin":
|
|
case "code_lua_lua": return ELanguage.LUA;
|
|
case "code_python27_json":
|
|
case "code_python3_json": return ELanguage.PYTHON;
|
|
case "code_typescript_bin":
|
|
case "code_typescript_json": return ELanguage.TYPESCRIPT;
|
|
case "code_cpp_ue_editor":
|
|
case "code_cpp_ue_bp": return ELanguage.CPP;
|
|
case "code_cs_unity_editor": return ELanguage.CS;
|
|
default: throw new ArgumentException($"not support output data type:{genType}");
|
|
}
|
|
}
|
|
|
|
private string GetOutputFileSuffix(string genType)
|
|
{
|
|
switch (genType)
|
|
{
|
|
case "data_bin": return "bin";
|
|
case "data_json": return "json";
|
|
case "data_lua": return "lua";
|
|
default: throw new Exception($"not support output data type:{genType}");
|
|
}
|
|
}
|
|
|
|
private string GetOutputFileName(string genType, string fileName)
|
|
{
|
|
return $"{(genType.EndsWith("lua") ? fileName.Replace('.', '_') : fileName)}.{GetOutputFileSuffix(genType)}";
|
|
}
|
|
|
|
private static bool TryParseArg(List<string> args, out GenArgs options, out string errMsg)
|
|
{
|
|
var helpWriter = new StringWriter();
|
|
var parser = new Parser(ps =>
|
|
{
|
|
ps.HelpWriter = helpWriter;
|
|
}); ;
|
|
var parseResult = parser.ParseArguments<GenArgs>(args);
|
|
if (parseResult.Tag == ParserResultType.NotParsed)
|
|
{
|
|
errMsg = helpWriter.ToString();
|
|
options = null;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
options = (parseResult as Parsed<GenArgs>).Value;
|
|
errMsg = null;
|
|
|
|
string inputDataDir = options.InputDataDir;
|
|
string outputCodeDir = options.OutputCodeDir;
|
|
string outputDataDir = options.OutputDataDir;
|
|
|
|
var genTypes = options.GenType.Split(',').Select(s => s.Trim()).ToList();
|
|
|
|
if (genTypes.Any(t => t.StartsWith("code_", StringComparison.Ordinal)) && string.IsNullOrWhiteSpace(outputCodeDir))
|
|
{
|
|
errMsg = "--outputcodedir missing";
|
|
return false;
|
|
}
|
|
if (genTypes.Any(t => t.StartsWith("data_", StringComparison.Ordinal)))
|
|
{
|
|
if (string.IsNullOrWhiteSpace(inputDataDir))
|
|
{
|
|
errMsg = "--inputdatadir missing";
|
|
return false;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(outputDataDir))
|
|
{
|
|
errMsg = "--outputdatadir missing";
|
|
return false;
|
|
}
|
|
if (genTypes.Contains("data_resources") && string.IsNullOrWhiteSpace(options.OutputDataResourceListFile))
|
|
{
|
|
errMsg = "--output_data_resource_list_file missing";
|
|
return false;
|
|
}
|
|
if (genTypes.Contains("output_data_json_monolithic_file") && string.IsNullOrWhiteSpace(options.OutputDataJsonMonolithicFile))
|
|
{
|
|
errMsg = "--output_data_json_monolithic_file missing";
|
|
return false;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(options.InputTextTableFiles) ^ string.IsNullOrWhiteSpace(options.OutputNotConvertTextFile))
|
|
{
|
|
errMsg = "--input_l10n_text_files must be provided with --output_l10n_not_converted_text_file";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(options.BranchName) ^ string.IsNullOrWhiteSpace(options.BranchInputDataDir))
|
|
{
|
|
errMsg = "--branch must be provided with --branch_input_data_dir";
|
|
return false;
|
|
}
|
|
|
|
if (!options.ValidateTypescriptRequire(options.GenType, ref errMsg))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
class GenContext
|
|
{
|
|
public GenArgs GenArgs { get; init; }
|
|
public DefAssembly Assembly { get; init; }
|
|
public string GenType { get; set; }
|
|
public ICfgCodeRender Render { get; set; }
|
|
public ELanguage Lan { get; set; }
|
|
|
|
public string TopModule => Assembly.TopModule;
|
|
public Service TargetService => Assembly.CfgTargetService;
|
|
|
|
|
|
public List<DefTypeBase> ExportTypes { get; init; }
|
|
public List<DefTable> ExportTables { get; init; }
|
|
public ConcurrentBag<FileInfo> GenCodeFilesInOutputCodeDir { get; init; }
|
|
public ConcurrentBag<FileInfo> GenDataFilesInOutputDataDir { get; init; }
|
|
public ConcurrentBag<FileInfo> GenScatteredFiles { get; init; }
|
|
public List<Task> Tasks { get; init; }
|
|
}
|
|
|
|
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
|
|
{
|
|
var res = new GenJobRes()
|
|
{
|
|
ErrCode = Luban.Common.EErrorCode.OK,
|
|
ErrMsg = "succ",
|
|
FileGroups = new List<FileGroup>(),
|
|
};
|
|
|
|
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
|
|
{
|
|
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
|
|
res.ErrMsg = errMsg;
|
|
agent.Session.ReplyRpc<GenJob, GenJobArg, GenJobRes>(rpc, res);
|
|
return;
|
|
}
|
|
|
|
var timer = new ProfileTimer();
|
|
timer.StartPhase("= gen_all =");
|
|
try
|
|
{
|
|
string inputDataDir = args.InputDataDir;
|
|
string outputCodeDir = args.OutputCodeDir;
|
|
string outputDataDir = args.OutputDataDir;
|
|
|
|
var genTypes = args.GenType.Split(',').Select(s => s.Trim()).ToList();
|
|
|
|
timer.StartPhase("build defines");
|
|
var loader = new CfgDefLoader(agent);
|
|
await loader.LoadAsync(args.DefineFile);
|
|
await loader.LoadDefinesFromFileAsync(inputDataDir);
|
|
timer.EndPhaseAndLog();
|
|
|
|
var rawDefines = loader.BuildDefines();
|
|
|
|
TimeZoneInfo timeZoneInfo = string.IsNullOrEmpty(args.TimeZone) ? null : TimeZoneInfo.FindSystemTimeZoneById(args.TimeZone);
|
|
|
|
var ass = new DefAssembly(args.BranchName, timeZoneInfo, args.ExportTestData, agent)
|
|
{
|
|
UseUnityVectors = args.UseUnityVectors
|
|
};
|
|
|
|
ass.Load(args.Service, rawDefines);
|
|
|
|
DefAssemblyBase.LocalAssebmly = ass;
|
|
|
|
var targetService = ass.CfgTargetService;
|
|
|
|
|
|
List<DefTable> exportTables = ass.GetExportTables();
|
|
List<DefTypeBase> exportTypes = ass.GetExportTypes();
|
|
|
|
bool hasLoadCfgData = false;
|
|
|
|
bool needL10NTextConvert = !string.IsNullOrWhiteSpace(args.InputTextTableFiles);
|
|
|
|
async Task CheckLoadCfgDataAsync()
|
|
{
|
|
if (!hasLoadCfgData)
|
|
{
|
|
hasLoadCfgData = true;
|
|
var timer = new ProfileTimer();
|
|
timer.StartPhase("load config data");
|
|
await DataLoaderUtil.LoadCfgDataAsync(agent, ass, args.InputDataDir, args.BranchName, args.BranchInputDataDir, args.ExportTestData);
|
|
timer.EndPhaseAndLog();
|
|
|
|
if (needL10NTextConvert)
|
|
{
|
|
ass.InitL10n(args.TextValueFieldName);
|
|
await DataLoaderUtil.LoadTextTablesAsync(agent, ass, ".", args.InputTextTableFiles);
|
|
}
|
|
|
|
timer.StartPhase("validate");
|
|
var validateCtx = new ValidatorContext(ass, args.ValidateRootDir);
|
|
await validateCtx.ValidateTables(exportTables);
|
|
timer.EndPhaseAndLog();
|
|
}
|
|
}
|
|
|
|
var tasks = new List<Task>();
|
|
|
|
var genCodeFilesInOutputCodeDir = new ConcurrentBag<FileInfo>();
|
|
var genDataFilesInOutputDataDir = new ConcurrentBag<FileInfo>();
|
|
var genScatteredFiles = new ConcurrentBag<FileInfo>();
|
|
|
|
foreach (var genType in genTypes)
|
|
{
|
|
var ctx = new GenContext()
|
|
{
|
|
GenType = genType,
|
|
Assembly = ass,
|
|
GenArgs = args,
|
|
ExportTypes = exportTypes,
|
|
ExportTables = exportTables,
|
|
GenCodeFilesInOutputCodeDir = genCodeFilesInOutputCodeDir,
|
|
GenDataFilesInOutputDataDir = genDataFilesInOutputDataDir,
|
|
GenScatteredFiles = genScatteredFiles,
|
|
Tasks = tasks,
|
|
};
|
|
switch (genType)
|
|
{
|
|
case "code_cs_bin":
|
|
case "code_cs_json":
|
|
case "code_cs_unity_json":
|
|
case "code_java_bin":
|
|
case "code_go_bin":
|
|
case "code_go_json":
|
|
{
|
|
GenerateCodeScatter(ctx);
|
|
break;
|
|
}
|
|
case "code_lua_bin":
|
|
case "code_lua_lua":
|
|
{
|
|
GenLuaCode(ctx);
|
|
break;
|
|
}
|
|
case "code_typescript_bin":
|
|
case "code_typescript_json":
|
|
{
|
|
GenTypescriptCode(ctx);
|
|
break;
|
|
}
|
|
case "code_python27_json":
|
|
{
|
|
GenPythonCodes(ctx);
|
|
break;
|
|
}
|
|
case "code_cpp_bin":
|
|
{
|
|
GenCppCode(ctx);
|
|
break;
|
|
}
|
|
case "code_cpp_ue_editor":
|
|
{
|
|
GenCppUeEditor(ctx);
|
|
break;
|
|
}
|
|
case "code_cs_unity_editor":
|
|
{
|
|
GenCsUnityEditor(ctx);
|
|
break;
|
|
}
|
|
case "code_cpp_ue_bp":
|
|
{
|
|
GenCppUeBp(ctx);
|
|
break;
|
|
}
|
|
case "data_bin":
|
|
case "data_json":
|
|
case "data_lua":
|
|
{
|
|
await CheckLoadCfgDataAsync();
|
|
GenDataScatter(ctx);
|
|
break;
|
|
}
|
|
case "data_json_monolithic":
|
|
{
|
|
await CheckLoadCfgDataAsync();
|
|
tasks.Add(GenJsonDataMonolithic(ctx));
|
|
break;
|
|
}
|
|
case "data_resources":
|
|
{
|
|
await CheckLoadCfgDataAsync();
|
|
GenResourceList(ctx);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
s_logger.Error("unknown gentype:{gentype}", genType);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
await Task.WhenAll(tasks.ToArray());
|
|
|
|
if (needL10NTextConvert)
|
|
{
|
|
var notConvertTextList = DataExporterUtil.GenNotConvertTextList(ass.NotConvertTextSet);
|
|
var md5 = FileUtil.CalcMD5(notConvertTextList);
|
|
string outputNotConvertTextFile = args.OutputNotConvertTextFile;
|
|
CacheManager.Ins.AddCache(outputNotConvertTextFile, md5, notConvertTextList);
|
|
|
|
genScatteredFiles.Add(new FileInfo() { FilePath = outputNotConvertTextFile, MD5 = md5 });
|
|
}
|
|
|
|
if (!genCodeFilesInOutputCodeDir.IsEmpty)
|
|
{
|
|
res.FileGroups.Add(new FileGroup() { Dir = outputCodeDir, Files = genCodeFilesInOutputCodeDir.ToList() });
|
|
}
|
|
if (!genDataFilesInOutputDataDir.IsEmpty)
|
|
{
|
|
res.FileGroups.Add(new FileGroup() { Dir = outputDataDir, Files = genDataFilesInOutputDataDir.ToList() });
|
|
}
|
|
if (!genScatteredFiles.IsEmpty)
|
|
{
|
|
res.ScatteredFiles.AddRange(genScatteredFiles);
|
|
}
|
|
}
|
|
catch (DataCreateException e)
|
|
{
|
|
res.ErrCode = Luban.Common.EErrorCode.DATA_PARSE_ERROR;
|
|
res.ErrMsg = $@"
|
|
=======================================================================
|
|
解析失败!
|
|
|
|
文件: {e.OriginDataLocation}
|
|
错误位置: {e.DataLocationInFile}
|
|
Err: {e.OriginErrorMsg}
|
|
字段: {e.VariableFullPathStr}
|
|
|
|
=======================================================================
|
|
";
|
|
res.StackTrace = e.OriginStackTrace;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
|
|
res.ErrMsg = $@"
|
|
=======================================================================
|
|
|
|
{ExceptionUtil.ExtractMessage(e)}
|
|
|
|
=======================================================================
|
|
";
|
|
res.StackTrace = e.StackTrace;
|
|
}
|
|
DefAssemblyBase.LocalAssebmly = null;
|
|
timer.EndPhaseAndLog();
|
|
|
|
agent.Session.ReplyRpc<GenJob, GenJobArg, GenJobRes>(rpc, res);
|
|
}
|
|
|
|
private void GenerateCodeScatter(GenContext ctx)
|
|
{
|
|
string genType = ctx.GenType;
|
|
ctx.Render = CreateCodeRender(genType);
|
|
ctx.Lan = GetLanguage(genType);
|
|
foreach (var c in ctx.ExportTypes)
|
|
{
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(ctx.Render.RenderAny(c), ctx.Lan);
|
|
var file = RenderFileUtil.GetDefTypePath(c.FullName, ctx.Lan);
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var module = ctx.TopModule;
|
|
var name = ctx.TargetService.Manager;
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(ctx.Render.RenderService(name, module, ctx.ExportTables), ctx.Lan);
|
|
var file = RenderFileUtil.GetDefTypePath(name, ctx.Lan);
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
|
|
private void GenerateCodeMonolithic(GenContext ctx, string outputFile, List<string> fileContent, Action<List<string>> preContent, Action<List<string>> postContent)
|
|
{
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
fileContent.Add(FileHeaderUtil.GetAutoGenerationHeader(ctx.Lan));
|
|
|
|
preContent?.Invoke(fileContent);
|
|
|
|
foreach (var type in ctx.ExportTypes)
|
|
{
|
|
fileContent.Add(ctx.Render.RenderAny(type));
|
|
}
|
|
|
|
fileContent.Add(ctx.Render.RenderService("Tables", ctx.TopModule, ctx.ExportTables));
|
|
postContent?.Invoke(fileContent);
|
|
|
|
var file = outputFile;
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, string.Join('\n', fileContent));
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
|
|
private void GenLuaCode(GenContext ctx)
|
|
{
|
|
string genType = ctx.GenType;
|
|
LuaCodeRenderBase render = CreateCodeRender(genType) as LuaCodeRenderBase;
|
|
var file = "Types.lua";
|
|
var content = render.RenderAll(ctx.ExportTypes);
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, string.Join('\n', content));
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}
|
|
|
|
private void GenTypescriptCode(GenContext ctx)
|
|
{
|
|
string genType = ctx.GenType;
|
|
var args = ctx.GenArgs;
|
|
ctx.Render = CreateCodeRender(genType);
|
|
ctx.Lan = GetLanguage(genType);
|
|
|
|
var lines = new List<string>(10000);
|
|
Action<List<string>> preContent = (fileContent) =>
|
|
{
|
|
var brightRequirePath = args.TypescriptBrightRequirePath;
|
|
var brightPackageName = args.TypescriptBrightPackageName;
|
|
bool isGenBinary = genType.EndsWith("bin");
|
|
if (isGenBinary)
|
|
{
|
|
if (args.UsePuertsByteBuf)
|
|
{
|
|
fileContent.Add(TypescriptStringTemplate.PuertsByteBufImports);
|
|
}
|
|
else
|
|
{
|
|
fileContent.Add(TypescriptStringTemplate.GetByteBufImports(brightRequirePath, brightPackageName));
|
|
}
|
|
}
|
|
|
|
if (args.EmbedBrightTypes)
|
|
{
|
|
fileContent.Add(isGenBinary ? TypescriptStringTemplate.VectorTypesByteBuf : TypescriptStringTemplate.VectorTypesJson);
|
|
if (isGenBinary)
|
|
{
|
|
fileContent.Add(TypescriptStringTemplate.SerializeTypes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (isGenBinary)
|
|
{
|
|
fileContent.Add(TypescriptStringTemplate.GetSerializeImports(brightRequirePath, brightPackageName));
|
|
}
|
|
fileContent.Add(TypescriptStringTemplate.GetVectorImports(brightRequirePath, brightPackageName));
|
|
}
|
|
|
|
fileContent.Add(@$"export namespace {ctx.TopModule} {{");
|
|
};
|
|
|
|
Action<List<string>> postContent = (fileContent) =>
|
|
{
|
|
fileContent.Add("}"); // end of topmodule
|
|
};
|
|
|
|
GenerateCodeMonolithic(ctx, "Types.ts", lines, preContent, postContent);
|
|
}
|
|
|
|
private void GenPythonCodes(GenContext ctx)
|
|
{
|
|
string genType = ctx.GenType;
|
|
ctx.Render = CreateCodeRender(genType);
|
|
ctx.Lan = GetLanguage(genType);
|
|
|
|
var isPython3 = genType.Contains("python3");
|
|
|
|
var lines = new List<string>(10000);
|
|
Action<List<string>> preContent = (fileContent) =>
|
|
{
|
|
if (isPython3)
|
|
{
|
|
fileContent.Add(PythonStringTemplates.ImportTython3Enum);
|
|
}
|
|
fileContent.Add(PythonStringTemplates.PythonVectorTypes);
|
|
};
|
|
|
|
GenerateCodeMonolithic(ctx, "Types.py", lines, preContent, null);
|
|
|
|
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var moduleInitContent = "";
|
|
var initFile = "__init__.py";
|
|
|
|
var initMd5 = CacheFileUtil.GenMd5AndAddCache(initFile, moduleInitContent);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = initFile, MD5 = initMd5 });
|
|
}));
|
|
}
|
|
|
|
private void GenCppCode(GenContext ctx)
|
|
{
|
|
var render = new CppCodeBinRender();
|
|
// 将所有 头文件定义 生成到一个文件
|
|
// 按照 const,enum,bean,table, service 的顺序生成
|
|
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var headerFileContent = new List<string>
|
|
{
|
|
@$"
|
|
#pragma once
|
|
#include <functional>
|
|
|
|
#include ""bright/serialization/ByteBuf.h""
|
|
#include ""bright/CfgBean.hpp""
|
|
|
|
using ByteBuf = ::bright::serialization::ByteBuf;
|
|
|
|
namespace {ctx.TopModule}
|
|
{{
|
|
"
|
|
};
|
|
|
|
foreach (var type in ctx.ExportTypes)
|
|
{
|
|
if (type is DefEnum e)
|
|
{
|
|
headerFileContent.Add(render.Render(e));
|
|
}
|
|
}
|
|
|
|
foreach (var type in ctx.ExportTypes)
|
|
{
|
|
if (type is DefConst c)
|
|
{
|
|
headerFileContent.Add(render.Render(c));
|
|
}
|
|
}
|
|
|
|
foreach (var type in ctx.ExportTypes)
|
|
{
|
|
if (type is DefBean e)
|
|
{
|
|
headerFileContent.Add(render.RenderForwardDefine(e));
|
|
}
|
|
}
|
|
|
|
foreach (var type in ctx.ExportTypes)
|
|
{
|
|
if (type is DefBean e)
|
|
{
|
|
headerFileContent.Add(render.Render(e));
|
|
}
|
|
}
|
|
|
|
foreach (var type in ctx.ExportTables)
|
|
{
|
|
headerFileContent.Add(render.Render(type));
|
|
}
|
|
|
|
headerFileContent.Add(render.RenderService("Tables", ctx.TopModule, ctx.ExportTables));
|
|
|
|
headerFileContent.Add("}"); // end of topmodule
|
|
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', headerFileContent), ELanguage.CPP);
|
|
var file = "gen_types.h";
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content, true);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
|
|
var beanTypes = ctx.ExportTypes.Where(c => c is DefBean).ToList();
|
|
|
|
int TYPE_PER_STUB_FILE = 100;
|
|
|
|
for (int i = 0, n = (beanTypes.Count + TYPE_PER_STUB_FILE - 1) / TYPE_PER_STUB_FILE; i < n; i++)
|
|
{
|
|
int index = i;
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
int startIndex = index * TYPE_PER_STUB_FILE;
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(
|
|
render.RenderStub(ctx.TopModule, beanTypes.GetRange(startIndex, Math.Min(TYPE_PER_STUB_FILE, beanTypes.Count - startIndex))),
|
|
ELanguage.CPP);
|
|
var file = $"gen_stub_{index}.cpp";
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content, true);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
}
|
|
|
|
private void GenCppUeEditor(GenContext ctx)
|
|
{
|
|
var render = new UE4EditorCppRender();
|
|
|
|
var renderTypes = ctx.Assembly.Types.Values.Where(c => c is DefEnum || c is DefBean).ToList();
|
|
|
|
foreach (var c in renderTypes)
|
|
{
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.CPP);
|
|
var file = "editor_" + RenderFileUtil.GetUeCppDefTypeHeaderFilePath(c.FullName);
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content, true);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
|
|
int TYPE_PER_STUB_FILE = 200;
|
|
|
|
for (int i = 0, n = (renderTypes.Count + TYPE_PER_STUB_FILE - 1) / TYPE_PER_STUB_FILE; i < n; i++)
|
|
{
|
|
int index = i;
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
int startIndex = index * TYPE_PER_STUB_FILE;
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(
|
|
render.RenderStub(renderTypes.GetRange(startIndex, Math.Min(TYPE_PER_STUB_FILE, renderTypes.Count - startIndex))),
|
|
ELanguage.CPP);
|
|
var file = $"stub_{index}.cpp";
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content, true);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
}
|
|
|
|
private void GenCsUnityEditor(GenContext ctx)
|
|
{
|
|
var render = new EditorCsRender();
|
|
foreach (var c in ctx.Assembly.Types.Values)
|
|
{
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.CS);
|
|
var file = RenderFileUtil.GetDefTypePath(c.FullName, ELanguage.CS);
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
}
|
|
|
|
private void GenCppUeBp(GenContext ctx)
|
|
{
|
|
var render = new UE4BpCppRender();
|
|
foreach (var c in ctx.ExportTypes)
|
|
{
|
|
if (!(c is DefEnum || c is DefBean))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.CPP);
|
|
var file = "bp_" + RenderFileUtil.GetUeCppDefTypeHeaderFilePath(c.FullName);
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content, true);
|
|
ctx.GenCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
}
|
|
|
|
private void GenDataScatter(GenContext ctx)
|
|
{
|
|
string genType = ctx.GenType;
|
|
foreach (var table in ctx.ExportTables)
|
|
{
|
|
ctx.Tasks.Add(Task.Run(() =>
|
|
{
|
|
var file = GetOutputFileName(genType, table.OutputDataFile);
|
|
var records = ctx.Assembly.GetTableExportDataList(table);
|
|
if (!FileRecordCacheManager.Ins.TryGetRecordOutputData(table, records, genType, out string md5))
|
|
{
|
|
var content = DataExporterUtil.ToOutputData(table, records, genType);
|
|
md5 = CacheFileUtil.GenStringOrBytesMd5AndAddCache(file, content);
|
|
FileRecordCacheManager.Ins.AddCachedRecordOutputData(table, records, genType, md5);
|
|
}
|
|
ctx.GenDataFilesInOutputDataDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
}
|
|
|
|
private async Task GenJsonDataMonolithic(GenContext ctx)
|
|
{
|
|
var exportTables = ctx.ExportTables;
|
|
var allJsonTask = new List<Task<string>>();
|
|
foreach (var c in exportTables)
|
|
{
|
|
allJsonTask.Add(Task.Run(() =>
|
|
{
|
|
return (string)DataExporterUtil.ToOutputData(c, ctx.Assembly.GetTableExportDataList(c), "data_json");
|
|
}));
|
|
}
|
|
|
|
var lines = new List<string>();
|
|
|
|
lines.Add("{");
|
|
for (int i = 0; i < exportTables.Count; i++)
|
|
{
|
|
if (i != 0)
|
|
{
|
|
lines.Add(",");
|
|
}
|
|
lines.Add($"\"{exportTables[i].NeedExport}\":");
|
|
lines.Add(await allJsonTask[i]);
|
|
}
|
|
lines.Add("}");
|
|
|
|
var content = string.Join('\n', lines);
|
|
var outputFile = ctx.GenArgs.OutputDataJsonMonolithicFile;
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(outputFile, content);
|
|
ctx.GenScatteredFiles.Add(new FileInfo() { FilePath = outputFile, MD5 = md5 });
|
|
}
|
|
|
|
private void GenResourceList(GenContext ctx)
|
|
{
|
|
var genDataTasks = new List<Task<List<ResourceInfo>>>();
|
|
foreach (var c in ctx.ExportTables)
|
|
{
|
|
genDataTasks.Add(Task.Run(() =>
|
|
{
|
|
return DataExporterUtil.ExportResourceList(ctx.Assembly.GetTableExportDataList(c));
|
|
}));
|
|
}
|
|
|
|
ctx.Tasks.Add(Task.Run(async () =>
|
|
{
|
|
var ress = new HashSet<(string, string)>(10000);
|
|
var resourceLines = new List<string>(10000);
|
|
foreach (var task in genDataTasks)
|
|
{
|
|
foreach (var ri in await task)
|
|
{
|
|
if (ress.Add((ri.Resource, ri.Tag)))
|
|
{
|
|
resourceLines.Add($"{ri.Resource},{ri.Tag}");
|
|
}
|
|
}
|
|
}
|
|
var file = ctx.GenArgs.OutputDataResourceListFile;
|
|
var content = string.Join("\n", resourceLines);
|
|
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
|
|
|
|
ctx.GenScatteredFiles.Add(new FileInfo() { FilePath = file, MD5 = md5 });
|
|
}));
|
|
}
|
|
}
|
|
}
|