private static int RunComposite(CompositeOptions options)
{
Directory.CreateDirectory(options.TargetDir);
ContentDefinition cd;
using (var ifs = new FileStream(options.ContentDefinition, FileMode.Open, FileAccess.Read)) {
cd = AuthoringUtil.JsonDeserialize <ContentDefinition>(ifs);
}
var rm = new DataManager();
rm.RegisterDataProvider(
new FileDataProvider(options.ContentDir ?? Path.GetDirectoryName(options.ContentDefinition)));
var opts = new LiveLoadOptions(loadTextures: true);
var lc = ContentUtil.LoadLiveContent(cd, rm, opts);
foreach (var(name, image) in lc.RenderedCoTextures)
{
using (var ofs = new FileStream(Path.Combine(options.TargetDir, name + ".png"), FileMode.Create,
FileAccess.Write))
image.SaveAsPng(ofs);
}
return(0);
}
private static int RunMakeMesh(MakeMeshOptions options)
{
LiveMesh mesh;
using (var ifs = new FileStream(options.SourceFile, FileMode.Open, FileAccess.Read)) {
Dictionary <string, BoneType> boneRegexs = null;
Dictionary <string, AttachPointType> attachPointRegexs = null;
if (options.MatchFile != null)
{
MatchRules mf;
using (var mfFs = new FileStream(options.MatchFile, FileMode.Open, FileAccess.Read))
mf = AuthoringUtil.JsonDeserialize <MatchRules>(mfFs);
boneRegexs = mf.Bones;
attachPointRegexs = mf.AttachPoints;
}
Console.WriteLine("Parsing...");
mesh = options.DebugLog
? AuthoringUtil.GenerateLiveMesh(ifs, boneRegexs, attachPointRegexs, Console.WriteLine)
: AuthoringUtil.GenerateLiveMesh(ifs, boneRegexs, attachPointRegexs);
}
mesh.UniqueName = options.UniqueName;
mesh.VariantTypeName = options.VariantTypeName;
mesh.FitUniqueName = options.FitUniqueName;
Stream ofs = new FileStream(options.TargetFile, FileMode.Create, FileAccess.Write);
try {
if (options.Compress)
{
ofs = new DeflateStream(ofs, CompressionLevel.Optimal, false);
}
Console.WriteLine("Serializing...");
Serializer.Serialize(ofs, mesh);
}
finally {
ofs.Dispose();
}
return(0);
}
private static int RunUnpack(UnpackOptions options)
{
Directory.CreateDirectory(options.TargetDir);
using (var ifs = new FileStream(options.SourceFile, FileMode.Open, FileAccess.Read)) {
var box = CzBox.Load(ifs);
var def = box.GetContentDefinition();
if (def != null)
{
using (var cnBoxFs = new FileStream(Path.Combine(options.TargetDir, "contentDefinition.json"),
FileMode.Create, FileAccess.Write))
AuthoringUtil.JsonSerialize(def, cnBoxFs);
}
foreach (var(name, srcResFs) in box.GetDataEnumerator())
{
using (var resFs = new FileStream(Path.Combine(options.TargetDir, name), FileMode.Create,
FileAccess.Write))
srcResFs.CopyTo(resFs);
}
}
return(0);
}
private static int RunMakeTl(MakeTlOptions options)
{
Dictionary <string, string> dict;
using (var ifs = new FileStream(options.SourceFile, FileMode.Open, FileAccess.Read))
dict = AuthoringUtil.JsonDeserialize <Dictionary <string, string> >(ifs);
Stream ofs = new FileStream(options.TargetFile, FileMode.Create, FileAccess.Write);
try {
if (options.Compress)
{
ofs = new DeflateStream(ofs, CompressionLevel.Optimal, false);
}
Console.WriteLine("Serializing...");
Serializer.Serialize(ofs, dict);
}
finally {
ofs.Dispose();
}
return(0);
}
private static int RunPack(PackOptions options)
{
ContentDefinition def = null;
if (options.ContentDefinition != null)
{
using (var defFs = new FileStream(options.ContentDefinition, FileMode.Open, FileAccess.Read))
def = AuthoringUtil.JsonDeserialize <ContentDefinition>(defFs);
}
var bList = new List <FileInfo>();
if (options.Resources != null)
{
foreach (var res in options.Resources)
{
bList.Add(new FileInfo(res));
}
}
var metaList = new List <MutableKeyValuePair <string, int> >();
foreach (var ent in bList)
{
metaList.Add(new MutableKeyValuePair <string, int>(ent.Name, (int)ent.Length));
}
using (var ofs = new FileStream(options.TargetFile, FileMode.Create, FileAccess.Write)) {
CzBox.WriteHead(ofs, def, metaList);
foreach (var ent in bList)
{
using (var eStream = ent.OpenRead())
eStream.CopyTo(ofs);
}
}
return(0);
}
private static int RunTemplate(TemplateOptions options)
{
switch (options.Type.ToLowerInvariant())
{
case "definition":
var def = new ContentDefinition();
def.MeshConfigs.Add("yourConfigName", new MeshConfig {
Mesh = "yourMeshName",
Materials = new List <Material> {
new Material {
Textures = new Dictionary <string, string>
{
{ "yourShaderParameterName", "yourTextureName" }
}
}
},
CustomAttachPoints = new List <AttachPoint> {
new AttachPoint {
BoneName = "yourBoneName"
}
}
});
def.MeshPaths.Add("yourMeshName", "yourPath");
def.ResourcePaths.Add("yourResourceName", "yourPath");
def.TexturePaths.Add("yourTextureName", "yourPath");
def.TranslationPaths.Add("yourTranslationName", "yourPath");
def.CoTextures.Add("yourCoTextureName", new CoTextureDefinition {
Height = 1024,
Width = 1024,
Textures = new List <SubTextureDefinition>
{
new SubTextureDefinition {
Mask = "yourTextureName", Texture = "yourTextureName"
}
}
});
using (var ofs = new FileStream(options.TargetFile, FileMode.Create, FileAccess.Write))
AuthoringUtil.JsonSerialize(def, ofs);
break;
case "matchfile":
var matchFile = new MatchRules();
foreach (var t in (BoneType[])Enum.GetValues(typeof(BoneType)))
{
matchFile.Bones.Add($"boneRegex{t.ToString()}", t);
}
foreach (var t in (AttachPointType[])Enum.GetValues(typeof(AttachPointType)))
{
matchFile.AttachPoints.Add($"boneRegex{t.ToString()}", t);
}
using (var ofs = new FileStream(options.TargetFile, FileMode.Create, FileAccess.Write))
AuthoringUtil.JsonSerialize(matchFile, ofs);
break;
default:
Console.Error.WriteLine("Template type not recognized");
return(0x10103040);
}
return(0);
}
