private WFR _WCC_import(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- WCC_LITE: IMPORTING MODELS pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
try
{
//get all files with specified filter
string WILDCARD = $"{MODEL_PREFIX}*.fbx";
if (!String.IsNullOrEmpty(MODELNAME))
{
WILDCARD = $"{MODEL_PREFIX}{MODELNAME}.fbx";
}
var files = Directory.GetFiles(settings.DIR_MODEL_FBX(), WILDCARD, SearchOption.AllDirectories);
for (int i = 0; i < files.Length; i++)
{
string filename = files[i]; //path
MODELNAME = Path.GetFileNameWithoutExtension(filename);
MODELNAME = MODELNAME.Split(new string[] { MODEL_PREFIX }, StringSplitOptions.None).Last();
settings.LOGGER.LogString($"importing: {MODELNAME}...");
//call wcc_lite
WCC_Command cmd = new import()
{
Depot = $"{settings.DIR_MODKIT_DEPOT()}",
File = filename,
Out = Path.Combine(settings.DIR_OUTPUT_MESHES(), $"{MODELNAME}.w2mesh"),
};
WFR result = WCC_Task.RunCommandSync(cmd);
if (result == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
}
//set dependencies
if (!settings.PATCH_MODE)
{
string sp = $"{settings.WORLD_DEF_PREFIX}*.yml";
if (Directory.GetFiles(settings.DIR_DEF_WORLD(), sp, SearchOption.AllDirectories).Any())
{
settings.WCC_NAVDATA = true;
}
settings.WCC_ANALYZE = true;
settings.WCC_COLLISIONCACHE = true;
settings.WCC_COOK = true;
settings.WCC_REPACK_DLC = true;
}
settings.LOGGER.LogString("done.");
return(WFR.WFR_Finished);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
private WFR _WCC_CookData(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- WCC_LITE: COOK pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
try
{
WFR result = WFR.WFR_Error;
// setup *all* seedfiles for cooking: hubs, dlc
string sp = $"{settings.SEEDFILE_PREFIX}*.files";
var seedfiles = Directory.GetFiles(settings.DIR_TMP(), sp, SearchOption.TopDirectoryOnly);
foreach (var file in seedfiles)
{
WCC_SEEDFILES += $"-seed={file}";
}
// Note: trimdir MUST be lowercased!
WCC_Command cmd = new cook()
{
Platform = platform.pc,
trimdir = Path.Combine("dlc", $"dlc{settings.MODNAME_LC()}"),
outdir = settings.DIR_COOKED_DLC()
};
// run as arguments because of multiple seedfiles
string args = cmd.CommandLine;
args += $" {WCC_SEEDFILES}";
result = WCC_Task.RunArgsSync(cmd.Name, args);
//cleanup
if (Directory.Exists(settings.DIR_COOKED_FILES_DB()))
{
Directory.Delete(settings.DIR_COOKED_FILES_DB());
}
//move to prevent beeing packed into mod
if (File.Exists(Path.Combine(settings.DIR_COOKED_DLC(), "cook.db")))
{
File.Move(Path.Combine(settings.DIR_COOKED_DLC(), "cook.db"), Path.Combine(settings.DIR_COOKED_FILES_DB(), "cook.db"));
}
settings.LOGGER.LogString("done.");
return(result);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
private WFR _Encode_env(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- ENCODING ENVS pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
try
{
if (!Directory.Exists(settings.DIR_OUTPUT_ENVS()))
{
Directory.CreateDirectory(settings.DIR_OUTPUT_ENVS());
}
string WILDCARD = $"{settings.ENV_DEF_PREFIX}*.yml";
if (!String.IsNullOrEmpty(ENVID))
{
WILDCARD = $"{settings.ENV_DEF_PREFIX}{ENVID}.yml";
}
var files = Directory.GetFiles(settings.DIR_DEF_ENVS(), WILDCARD, SearchOption.AllDirectories);
for (int i = 0; i < files.Length; i++)
{
string filename = files[i];
settings.LOGGER.LogString($"encoding: {filename}...");
//call encode
var encoder = new w3env()
{
OutputDirectory = settings.DIR_OUTPUT_ENVS(),
Encode = filename,
LogLevel = settings.LOG_LEVEL
};
WFR result = RAD_Task.RunCommandSync(encoder);
if (result == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
}
settings.LOGGER.LogString("done.");
return(WFR.WFR_Finished);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
private WFR _WCC_occlusion(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- WCC_LITE: COOK OCCLUSION pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
try
{
//get all folders inside the levels directory
string levelDir = Path.Combine(settings.DIR_UNCOOKED(), settings.DIR_DLC_GAMEPATH(), "levels");
var levels = Directory.GetDirectories(levelDir);
for (int i = 0; i < levels.Length; i++)
{
string level = levels[i]; //path
string worldname = Path.GetDirectoryName(level);
settings.LOGGER.LogString($"generate occlusiondata for: {worldname}...");
//check i w2w file in subfolder?
string worldfile = Path.Combine(levelDir, worldname, $"{worldname}.w2w");
if (File.Exists(worldfile))
{
//LOG WCC_LITE: GENERATE OCCLUSIONDATA FOR !WORLDNAME!
//call wcc_lite
WCC_Command cmd = new cookocclusion()
{
WorldFile = worldfile
};
WFR result = WCC_Task.RunCommandSync(cmd);
if (result == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
}
}
settings.LOGGER.LogString("done.");
return(WFR.WFR_Finished);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
private WFR _WCC_PackMODAndCreateMetadatastore(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- WCC_LITE: PACK + METADATASTORE MOD pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
try
{
WFR result_pack = WFR.WFR_Error;
WFR result_meta = WFR.WFR_Error;
WCC_Command pack = new pack()
{
Directory = settings.DIR_COOKED_MOD(),
Outdir = settings.DIR_MOD_CONTENT()
};
result_pack = WCC_Task.RunCommandSync(pack);
if (result_pack == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
WCC_Command metadata = new metadatastore()
{
Directory = settings.DIR_MOD_CONTENT()
};
result_meta = WCC_Task.RunCommandSync(metadata);
if (result_meta == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
settings.LOGGER.LogString("done.");
return(WFR.WFR_Finished);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
public void Run()
{
DocumentViewModel wvm = DocumentsSource.FirstOrDefault(x => x.IsSelected);
var workflow = wvm.Workflow;
RAD_Task RAD_Task = Kernel.Get <RAD_Task>();
WCC_Task WCC_Task = Kernel.Get <WCC_Task>();
Logger.Clear();
Logger.LogString("Starting Workflow...");
// FIXME structure?
foreach (IWorkflowItem item in workflow)
{
WFR completed = WFR.WFR_Error;
if (item.GetType().IsSubclassOf(typeof(RAD_Command)))
{
completed = RAD_Task.RunCommandSync((RAD_Command)item);
}
else if (item.GetType().IsSubclassOf(typeof(WCC_Command)))
{
completed = WCC_Task.RunCommandSync((WCC_Command)item);
}
else //workflowitems
{
completed = item.Run();
}
if (completed == WFR.WFR_Error)
{
Logger.LogString("Aborting.");
break;
}
else
{
continue;
}
}
Logger.LogString("Done.");
}
private WFR _WCC_GenerateTextureCache(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- WCC_LITE: GENERATE TEXTURE CACHE pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
if (!Directory.Exists(Path.Combine(settings.DIR_UNCOOKED_TEXTURES(), settings.DIR_DLC_GAMEPATH())))
{
settings.LOGGER.LogString($"WARNING: no textures found in {Path.Combine(settings.DIR_UNCOOKED_TEXTURES(), settings.DIR_DLC_GAMEPATH())}");
return(WFR.WFR_Error);
}
try
{
WFR result_cook = WFR.WFR_Error;
WFR result_cache = WFR.WFR_Error;
if (Directory.Exists(settings.DIR_COOKED_TEXTURES_DB()))
{
Directory.Delete(settings.DIR_COOKED_TEXTURES_DB());
}
// cook textures
WCC_Command cook = new cook()
{
Platform = platform.pc,
mod = settings.DIR_UNCOOKED_TEXTURES(),
basedir = settings.DIR_UNCOOKED_TEXTURES(),
outdir = settings.DIR_COOKED_DLC()
};
result_cook = WCC_Task.RunCommandSync(cook);
if (result_cook == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
// move so it is separated from "normal" files cook.db
if (File.Exists(Path.Combine(settings.DIR_COOKED_DLC(), "cook.db")))
{
File.Delete(Path.Combine(settings.DIR_COOKED_DLC(), "cook.db"));
}
// build texture cache
WCC_Command buildcache = new buildcache()
{
builder = cachebuilder.textures,
DataBase = settings.DIR_COOKED_TEXTURES_DB(),
basedir = settings.DIR_UNCOOKED_TEXTURES(),
Out = Path.Combine(settings.DIR_DLC_CONTENT(), "texture.cache"),
Platform = platform.pc
};
result_cache = WCC_Task.RunCommandSync(buildcache);
if (result_cache == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
settings.LOGGER.LogString("done.");
return(WFR.WFR_Finished);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
private WFR _WCC_analyze(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- WCC_LITE: ANALYZE FILES pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
try
{
if (!Directory.Exists(settings.DIR_TMP()))
{
Directory.CreateDirectory(settings.DIR_TMP());
}
// process all worlds IF any world was generated
if (settings.ENCODE_WORLD || settings.WCC_ANALYZE_WORLD)
{
//get all folders inside the levels directory
string levelDir = Path.Combine(settings.DIR_UNCOOKED(), settings.DIR_DLC_GAMEPATH(), "levels");
var levels = Directory.GetDirectories(levelDir);
for (int i = 0; i < levels.Length; i++)
{
string level = levels[i]; //path
string worldname = Path.GetDirectoryName(level);
settings.LOGGER.LogString($"analyze world for: {worldname}...");
//check i w2w file in subfolder?
string worldfile = Path.Combine(levelDir, worldname, $"{worldname}.w2w");
if (File.Exists(worldfile))
{
//LOG WCC_LITE: ANALYZE WORLD FOR !WORLDNAME!
//call wcc_lite
WCC_Command cmd = new analyze()
{
Analyzer = analyzers.world,
Object = Path.Combine(settings.DIR_DLC_GAMEPATH(), "levels", worldname, $"{worldname}.w2w"),
Out = Path.Combine(settings.DIR_TMP(), $"{settings.SEEDFILE_PREFIX}world.{worldname}.files")
};
WFR result = WCC_Task.RunCommandSync(cmd);
//if any wcc operation fails return
if (result == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
}
}
}
else //process dlc IF something changed
{
if (settings.ENCODE_QUEST || settings.WCC_IMPORT_MODELS)
{
//LOG WCC_LITE: ANALYZE DLC
//call wcc_lite
WCC_Command cmd = new analyze()
{
Analyzer = analyzers.r4dlc,
reddlc = Path.Combine(settings.DIR_DLC_GAMEPATH(), $"dlc{settings.MODNAME}.reddlc"),
Out = Path.Combine(settings.DIR_TMP(), $"{settings.SEEDFILE_PREFIX}dlc{settings.MODNAME}.files")
};
return(WCC_Task.RunCommandSync(cmd));
}
}
settings.LOGGER.LogString("done.");
return(WFR.WFR_Finished);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
private WFR _Encode_world(WF_Settings settings)
{
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
settings.LOGGER.LogString($"-- ENCODING WORLD pm: {settings.PATCH_MODE}");
settings.LOGGER.LogString($"--------------------------------------------------------------------------");
try
{
if (!Directory.Exists(settings.DIR_OUTPUT_WORLD()))
{
Directory.CreateDirectory(settings.DIR_OUTPUT_WORLD());
}
if (!Directory.Exists(settings.DIR_TMP()))
{
Directory.CreateDirectory(settings.DIR_TMP());
}
string sp = $"{settings.WORLD_DEF_PREFIX}*.yml";
var files = Directory.GetFiles(settings.DIR_DEF_WORLD(), sp, SearchOption.AllDirectories);
for (int i = 0; i < files.Length; i++)
{
string filename = files[i];
settings.LOGGER.LogString($"encoding: {filename}...");
//call encoder //FIXME
var encoder = new w3world()
{
RepoDirectory = settings.dir_repo_worlds(),
OutputDirectory = settings.DIR_OUTPUT_WORLD(),
FoliageDirectory = settings.DIR_DEF_WORLD(),
SkipFoliageGeneration = SKIP_FOLIAGE_GENERATION,
SkipWorldGeneration = SKIP_WORLD_GENERATION,
Encode = filename,
LogLevel = settings.LOG_LEVEL
};
WFR result = RAD_Task.RunCommandSync(encoder);
if (result == WFR.WFR_Error)
{
return(WFR.WFR_Error);
}
}
//set dependencies
if (!settings.PATCH_MODE)
{
settings.WCC_ANALYZE = true;
settings.WCC_ANALYZE_WORLD = true;
settings.WCC_COOK = true;
settings.WCC_NAVDATA = true;
settings.WCC_OCCLUSIONDATA = true;
settings.WCC_TEXTURECACHE = true;
settings.WCC_COLLISIONCACHE = true;
settings.WCC_REPACK_DLC = true;
}
settings.LOGGER.LogString("done.");
return(WFR.WFR_Finished);
}
catch (Exception ex)
{
settings.LOGGER.LogString(ex.ToString());
throw ex;
}
}
