private bool ImportModelResource(TagInstance tagIndex, string cachePath, string dataPath)
{
RenderModel renderModel;
ResourceCache resourceCache;
uint compressedSize = 0;
var data = File.ReadAllBytes(dataPath);
using (var cacheStream = _info.OpenCacheReadWrite())
{
var tagContext = new TagSerializationContext(cacheStream, _info.Cache, _info.StringIDs, tagIndex);
renderModel = _info.Deserializer.Deserialize <RenderModel>(tagContext);
}
using (var stream = File.Open(_info.CacheFile.DirectoryName + "\\" + cachePath, FileMode.Open, FileAccess.ReadWrite))
{
resourceCache = new ResourceCache(stream);
renderModel.Geometry.Resource.Index = resourceCache.Add(stream, data, out compressedSize);
renderModel.Geometry.Resource.CompressedSize = compressedSize;
}
using (var cacheStream = _fileInfo.Open(FileMode.Open, FileAccess.ReadWrite))
{
var context = new TagSerializationContext(cacheStream, _cache, _stringIds, tagIndex);
_info.Serializer.Serialize(context, renderModel);
}
Console.WriteLine("{1}: Imported 0x{0}.", compressedSize, tagIndex);
return(true);
}
public override bool Execute(List <string> args)
{
if (args.Count != 2)
{
return(false);
}
var tag = ArgumentParser.ParseTagIndex(Info, args[0]);
var imagePath = args[1];
Console.WriteLine("Loading textures.dat...");
var resourceManager = new ResourceDataManager();
resourceManager.LoadCacheFromDirectory(Info.CacheFile.DirectoryName, ResourceLocation.Textures);
Console.WriteLine("Importing image...");
var bitmap = new TagDefinitions.Bitmap
{
Flags = TagDefinitions.Bitmap.RuntimeFlags.UseResource,
Sequences = new List <TagDefinitions.Bitmap.Sequence>
{
new TagDefinitions.Bitmap.Sequence
{
FirstBitmapIndex = 0,
BitmapCount = 1
}
},
Images = new List <TagDefinitions.Bitmap.Image>
{
new TagDefinitions.Bitmap.Image
{
Signature = new Tag("bitm").Value,
Unknown28 = -1,
}
},
Resources = new List <TagDefinitions.Bitmap.BitmapResource>
{
new TagDefinitions.Bitmap.BitmapResource()
}
};
using (var imageStream = File.OpenRead(imagePath))
{
var injector = new BitmapDdsInjector(resourceManager);
injector.InjectDds(Info.Serializer, Info.Deserializer, bitmap, 0, imageStream);
}
Console.WriteLine("Creating a new tag...");
using (var tagsStream = Info.OpenCacheReadWrite())
{
var tagContext = new TagSerializationContext(tagsStream, Info.Cache, Info.StringIDs, tag);
Info.Serializer.Serialize(tagContext, bitmap);
}
Console.WriteLine();
Console.WriteLine("All done! The new bitmap tag is:");
TagPrinter.PrintTagShort(tag);
return(true);
}
public override bool Execute(List <string> args)
{
if (args.Count != 1)
{
return(false);
}
var destinationTag = ArgumentParser.ParseTagIndex(Info.Cache, args[0]);
Scenario destinationScenario = null;
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.ReadWrite))
{
var scenarioContext = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIds, destinationTag);
destinationScenario = Info.Deserializer.Deserialize <Scenario>(scenarioContext);
}
destinationScenario.SandboxBudget = Definition.SandboxBudget;
destinationScenario.SandboxEquipment = Definition.SandboxEquipment;
destinationScenario.SandboxGoalObjects = Definition.SandboxGoalObjects;
destinationScenario.SandboxScenery = Definition.SandboxScenery;
destinationScenario.SandboxSpawning = Definition.SandboxSpawning;
destinationScenario.SandboxTeleporters = Definition.SandboxTeleporters;
destinationScenario.SandboxVehicles = Definition.SandboxVehicles;
destinationScenario.SandboxWeapons = Definition.SandboxWeapons;
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.ReadWrite))
{
var scenarioContext = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIds, destinationTag);
Info.Serializer.Serialize(scenarioContext, destinationScenario);
}
return(true);
}
private bool ImportBitmapResource(TagInstance tagIndex, string cachePath, string dataPath)
{
Bitmap bitmap;
ResourceCache resourceCache;
uint compressedSize = 0;
using (var cacheStream = _info.OpenCacheRead())
{
var tagContext = new TagSerializationContext(cacheStream, _info.Cache, _info.StringIDs, tagIndex);
bitmap = _info.Deserializer.Deserialize <Bitmap>(tagContext);
}
using (var stream = File.Open(_info.CacheFile.DirectoryName + "\\" + cachePath, FileMode.Open, FileAccess.ReadWrite))
{
int imageIndex = 0;
foreach (string file in Directory.EnumerateFiles(dataPath, "*.bitm"))
{
byte[] inBitmapData = File.ReadAllBytes(file);
resourceCache = new ResourceCache(stream);
bitmap.Resources[imageIndex].Resource.Index = resourceCache.Add(stream, inBitmapData, out compressedSize);
bitmap.Resources[imageIndex].Resource.CompressedSize = compressedSize;
imageIndex++;
}
}
using (var cacheStream = _fileInfo.Open(FileMode.Open, FileAccess.ReadWrite))
{
var context = new TagSerializationContext(cacheStream, _cache, _stringIds, tagIndex);
_info.Serializer.Serialize(context, bitmap);
}
Console.WriteLine("{1}: Imported 0x{0}.", compressedSize, tagIndex);
return(true);
}
public static TagInstance ConvertTag(TagInstance srcTag, OpenTagCache srcInfo, Stream srcStream, ResourceDataManager srcResources, OpenTagCache destInfo, Stream destStream, ResourceDataManager destResources, TagCacheMap tagMap)
{
TagPrinter.PrintTagShort(srcTag);
// Deserialize the tag from the source cache
var structureType = TagStructureTypes.FindByGroupTag(srcTag.Group.Tag);
var srcContext = new TagSerializationContext(srcStream, srcInfo.Cache, srcInfo.StringIDs, srcTag);
var tagData = srcInfo.Deserializer.Deserialize(srcContext, structureType);
// Acquire the destination tag
var destTag = destInfo.Cache.AllocateTag(srcTag.Group);
tagMap.Add(srcInfo.CacheFile.FullName, srcTag.Index, destInfo.CacheFile.FullName, destTag.Index);
if (srcTag.IsInGroup("decs") || srcTag.IsInGroup("rmd "))
{
IsDecalShader = true;
}
// Convert the source tag
tagData = Convert(tagData, srcInfo, srcStream, srcResources, destInfo, destStream, destResources, tagMap);
if (srcTag.IsInGroup("decs") || srcTag.IsInGroup("rmd "))
{
IsDecalShader = false;
}
// Re-serialize into the destination cache
var destContext = new TagSerializationContext(destStream, destInfo.Cache, destInfo.StringIDs, destTag);
destInfo.Serializer.Serialize(destContext, tagData);
return(destTag);
}
public override bool Execute(List<string> args)
{
if (args.Count != 1)
return false;
var outDir = args[0];
Directory.CreateDirectory(outDir);
Console.WriteLine("Loading resource caches...");
var resourceManager = new ResourceDataManager();
try
{
resourceManager.LoadCachesFromDirectory(_info.CacheFile.DirectoryName);
}
catch
{
Console.WriteLine("Unable to load the resource .dat files.");
Console.WriteLine("Make sure that they all exist and are valid.");
return true;
}
var extractor = new BitmapDdsExtractor(resourceManager);
var count = 0;
using (var tagsStream = _info.OpenCacheRead())
{
foreach (var tag in _info.Cache.Tags.FindAllInGroup("bitm"))
{
Console.Write("Extracting ");
TagPrinter.PrintTagShort(tag);
try
{
var tagContext = new TagSerializationContext(tagsStream, _info.Cache, _info.StringIDs, tag);
var bitmap = _info.Deserializer.Deserialize<TagDefinitions.Bitmap>(tagContext);
var ddsOutDir = outDir;
if (bitmap.Images.Count > 1)
{
ddsOutDir = Path.Combine(outDir, tag.Index.ToString("X8"));
Directory.CreateDirectory(ddsOutDir);
}
for (var i = 0; i < bitmap.Images.Count; i++)
{
var outPath = Path.Combine(ddsOutDir,
((bitmap.Images.Count > 1) ? i.ToString() : tag.Index.ToString("X8")) + ".dds");
using (var outStream = File.Open(outPath, FileMode.Create, FileAccess.Write))
{
extractor.ExtractDds(_info.Deserializer, bitmap, i, outStream);
}
}
count++;
}
catch (Exception ex)
{
Console.WriteLine("ERROR: Failed to extract bitmap: " + ex.Message);
}
}
}
Console.WriteLine("Extracted {0} bitmaps.", count);
return true;
}
public static void FixDecalSystems(OpenTagCache destInfo, int firstNewIndex)
{
// decs tags need to be updated to use the old rmdf for decals,
// because the decal planes seem to be generated by the engine and
// therefore need to use the old vertex format.
//
// This could probably be done as a post-processing step in
// ConvertStructure to avoid the extra deserialize-reserialize
// pass, but we'd have to store the rmdf somewhere and frankly I'm
// too lazy to do that...
var firstDecalSystemTag = destInfo.Cache.Tags.FindFirstInGroup("decs");
if (firstDecalSystemTag == null)
{
return;
}
using (var stream = destInfo.OpenCacheReadWrite())
{
var firstDecalSystemContext = new TagSerializationContext(stream, destInfo.Cache, destInfo.StringIDs, firstDecalSystemTag);
var firstDecalSystem = destInfo.Deserializer.Deserialize <DecalSystem>(firstDecalSystemContext);
foreach (var decalSystemTag in destInfo.Cache.Tags.FindAllInGroup("decs").Where(t => t.Index >= firstNewIndex))
{
TagPrinter.PrintTagShort(decalSystemTag);
var context = new TagSerializationContext(stream, destInfo.Cache, destInfo.StringIDs, decalSystemTag);
var decalSystem = destInfo.Deserializer.Deserialize <DecalSystem>(context);
foreach (var system in decalSystem.DecalSystem2)
{
system.BaseRenderMethod = firstDecalSystem.DecalSystem2[0].BaseRenderMethod;
}
destInfo.Serializer.Serialize(context, decalSystem);
}
}
}
public override bool Execute(List <string> args)
{
if (args.Count != 0)
{
return(false);
}
foreach (var property in Definition.ShaderProperties)
{
RenderMethodTemplate template = null;
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.Read))
{
var context = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIDs, property.Template);
template = Info.Deserializer.Deserialize <RenderMethodTemplate>(context);
}
for (var i = 0; i < template.ShaderMaps.Count; i++)
{
var mapTemplate = template.ShaderMaps[i];
Console.WriteLine($"Bitmap {i} ({Info.StringIDs.GetString(mapTemplate.Name)}): {property.ShaderMaps[i].Bitmap.Group.Tag} 0x{property.ShaderMaps[i].Bitmap.Index:X4}");
}
}
return(true);
}
private void ExtractModelResource(string tagIndex, string cachePath, string dataPath)
{
var tag = ArgumentParser.ParseTagIndex(Info, tagIndex);
int resourceIndex;
RenderModel model;
using (var tagsStream = Info.OpenCacheRead())
{
var tagContext = new TagSerializationContext(tagsStream, Info.Cache, Info.StringIDs, tag);
model = Info.Deserializer.Deserialize <RenderModel>(tagContext);
}
resourceIndex = model.Geometry.Resource.Index;
try
{
using (var stream = File.OpenRead(Info.CacheFile.DirectoryName + "\\" + cachePath))
{
var cache = new ResourceCache(stream);
using (var outStream = File.Open(dataPath, FileMode.Create, FileAccess.Write))
{
cache.Decompress(stream, resourceIndex, 0xFFFFFFFF, outStream);
Console.WriteLine("Wrote 0x{0:X} bytes to {1}. Resource index: {2}, 0x{3}.", outStream.Position, dataPath, resourceIndex, resourceIndex.ToString("X"));
}
}
}
catch (Exception ex)
{
Console.WriteLine("Failed to extract resource: {0}", ex.Message);
}
}
public override bool Execute(List <string> args)
{
foreach (var material in Definition.Materials)
{
if (material.RenderMethod != null)
{
Console.Write("Please enter the replacement {0:X8} index: ", material.RenderMethod.Index);
}
else
{
Console.Write("Please enter the replace material #{0} index: ", Definition.Materials.IndexOf(material));
}
material.RenderMethod = ArgumentParser.ParseTagIndex(Info, Console.ReadLine());
}
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.ReadWrite))
{
var context = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIDs, Tag);
Info.Serializer.Serialize(context, Definition);
}
Console.WriteLine("Done!");
return(true);
}
public override bool Execute(List <string> args)
{
if (args.Count != 1)
{
return(false);
}
var groupTag = ArgumentParser.ParseGroupTag(Info.StringIDs, args[0]);
if (groupTag == null || !TagGroup.Instances.ContainsKey(groupTag))
{
return(false);
}
TagInstance instance;
using (var stream = Info.OpenCacheReadWrite())
{
instance = Info.Cache.AllocateTag(TagGroup.Instances[groupTag]);
var context = new TagSerializationContext(stream, Info.Cache, Info.StringIDs, instance);
var data = Activator.CreateInstance(TagStructureTypes.FindByGroupTag(groupTag));
Info.Serializer.Serialize(context, data);
}
var tagName = Info.TagNames.ContainsKey(instance.Index) ?
Info.TagNames[instance.Index] :
$"0x{instance.Index:X4}";
Console.WriteLine($"[Index: 0x{instance.Index:X4}, Offset: 0x{instance.HeaderOffset:X8}, Size: 0x{instance.TotalSize:X4}] {tagName}.{Info.StringIDs.GetString(instance.Group.Name)}");
return(true);
}
private bool ImportAnimationResource(TagInstance tagIndex, string cachePath, string dataPath)
{
ModelAnimationGraph animation;
ResourceCache resourceCache;
uint compressedSize = 0;
var data = File.ReadAllBytes(dataPath);
using (var cacheStream = _info.OpenCacheReadWrite())
{
var tagContext = new TagSerializationContext(cacheStream, _info.Cache, _info.StringIDs, tagIndex);
animation = _info.Deserializer.Deserialize <ModelAnimationGraph>(tagContext);
}
using (var stream = File.Open(_info.CacheFile.DirectoryName + "\\" + cachePath, FileMode.Open, FileAccess.ReadWrite))
{
resourceCache = new ResourceCache(stream);
animation.ResourceGroups[0].Resource.Index = resourceCache.Add(stream, data, out compressedSize);
animation.ResourceGroups[0].Resource.CompressedSize = compressedSize;
animation.ResourceGroups[0].Resource.OldLocationFlags = (OldResourceLocationFlags)2;
}
using (var cacheStream = _fileInfo.Open(FileMode.Open, FileAccess.ReadWrite))
{
var context = new TagSerializationContext(cacheStream, _cache, _stringIds, tagIndex);
_info.Serializer.Serialize(context, animation);
}
Console.WriteLine("{1}: Imported 0x{0}.", compressedSize, tagIndex);
return(true);
}
private TagInstance ConvertTag(TagInstance srcTag, OpenTagCache srcInfo, Stream srcStream, ResourceDataManager srcResources, OpenTagCache destInfo, Stream destStream, ResourceDataManager destResources, TagVersionMap tagMap)
{
TagPrinter.PrintTagShort(srcTag);
// Uncomment this to use 0x101F for all shaders
/*if (srcTag.IsClass("rm "))
* return destInfo.Cache.Tags[0x101F];*/
// Check if the tag is in the map, and just return the translated tag if so
var destIndex = tagMap.Translate(srcInfo.Version, srcTag.Index, destInfo.Version);
if (destIndex >= 0)
{
Console.WriteLine("- Using already-known index {0:X4}", destIndex);
return(destInfo.Cache.Tags[destIndex]);
}
// Deserialize the tag from the source cache
var structureType = TagStructureTypes.FindByGroupTag(srcTag.Group.Tag);
var srcContext = new TagSerializationContext(srcStream, srcInfo.Cache, srcInfo.StringIDs, srcTag);
var tagData = srcInfo.Deserializer.Deserialize(srcContext, structureType);
// Uncomment this to use 0x101F in place of shaders that need conversion
/*if (tagData is RenderMethod)
* {
* var rm = (RenderMethod)tagData;
* foreach (var prop in rm.ShaderProperties)
* {
* if (tagMap.Translate(srcInfo.Version, prop.Template.Index, destInfo.Version) < 0)
* return destInfo.Cache.Tags[0x101F];
* }
* }*/
// Allocate a new tag and create a mapping for it
var newTag = destInfo.Cache.AllocateTag(srcTag.Group);
tagMap.Add(srcInfo.Version, srcTag.Index, destInfo.Version, newTag.Index);
if (srcTag.IsInGroup("decs") || srcTag.IsInGroup("rmd "))
{
_isDecalShader = true;
}
// Convert it
tagData = Convert(tagData, srcInfo, srcStream, srcResources, destInfo, destStream, destResources, tagMap);
if (srcTag.IsInGroup("decs") || srcTag.IsInGroup("rmd "))
{
_isDecalShader = false;
}
// Re-serialize into the destination cache
var destContext = new TagSerializationContext(destStream, destInfo.Cache, destInfo.StringIDs, newTag);
destInfo.Serializer.Serialize(destContext, tagData);
return(newTag);
}
public static void Populate(CommandContext context, OpenTagCache info, TagInstance tag)
{
RenderMethod renderMethod = null;
using (var cacheStream = info.OpenCacheReadWrite())
{
var tagContext = new TagSerializationContext(cacheStream, info.Cache, info.StringIDs, tag);
switch (tag.Group.Tag.ToString())
{
case "rm ": // render_method
renderMethod = info.Deserializer.Deserialize <RenderMethod>(tagContext);
break;
case "rmsh": // shader
renderMethod = info.Deserializer.Deserialize <Shader>(tagContext);
break;
case "rmd ": // shader_decal
renderMethod = info.Deserializer.Deserialize <ShaderDecal>(tagContext);
break;
case "rmfl": // shader_foliage
renderMethod = info.Deserializer.Deserialize <ShaderFoliage>(tagContext);
break;
case "rmhg": // shader_halogram
renderMethod = info.Deserializer.Deserialize <ShaderHalogram>(tagContext);
break;
case "rmss": // shader_screen
renderMethod = info.Deserializer.Deserialize <ShaderScreen>(tagContext);
break;
case "rmtr": // shader_terrain
renderMethod = info.Deserializer.Deserialize <ShaderTerrain>(tagContext);
break;
case "rmw ": // shader_water
renderMethod = info.Deserializer.Deserialize <ShaderWater>(tagContext);
break;
case "rmzo": // shader_zonly
renderMethod = info.Deserializer.Deserialize <ShaderZonly>(tagContext);
break;
case "rmcs": // shader_custom
renderMethod = info.Deserializer.Deserialize <ShaderCustom>(tagContext);
break;
default:
throw new NotImplementedException();
}
}
context.AddCommand(new ListArgumentsCommand(info, tag, renderMethod));
context.AddCommand(new ListBitmapsCommand(info, tag, renderMethod));
context.AddCommand(new SpecifyBitmapsCommand(info, tag, renderMethod));
}
public override bool Execute(List <string> args)
{
if (args.Count != 2)
{
return(false);
}
int imageIndex;
if (!int.TryParse(args[0], NumberStyles.HexNumber, null, out imageIndex))
{
return(false);
}
if (imageIndex < 0 || imageIndex >= _bitmap.Images.Count)
{
Console.Error.WriteLine("Invalid image index.");
return(true);
}
var imagePath = args[1];
Console.WriteLine("Loading resource caches...");
var resourceManager = new ResourceDataManager();
try
{
resourceManager.LoadCachesFromDirectory(_fileInfo.DirectoryName);
}
catch
{
Console.WriteLine("Unable to load the resource .dat files.");
Console.WriteLine("Make sure that they all exist and are valid.");
return(true);
}
Console.WriteLine("Importing image data...");
try
{
using (var imageStream = File.OpenRead(imagePath))
{
var injector = new BitmapDdsInjector(resourceManager);
injector.InjectDds(_bitmap, imageIndex, imageStream);
}
using (var tagsStream = _fileInfo.Open(FileMode.Open, FileAccess.ReadWrite))
{
var tagContext = new TagSerializationContext(tagsStream, _cache, _tag);
TagSerializer.Serialize(tagContext, _bitmap);
}
}
catch (Exception ex)
{
Console.WriteLine("Importing image data failed: " + ex.Message);
return(true);
}
Console.WriteLine("Done!");
return(true);
}
public override bool Execute(List <string> args)
{
using (var stream = Info.OpenCacheReadWrite())
{
var context = new TagSerializationContext(stream, Info.Cache, Info.StringIDs, Tag);
Info.Serializer.Serialize(context, Value);
}
Console.WriteLine("Done!");
return(true);
}
private void SetRenderModelName(Stream stream, TagInstance tag, ref Dictionary <int, string> tagNames)
{
if (tagNames.ContainsKey(tag.Index))
{
return;
}
var context = new TagSerializationContext(stream, Info.Cache, Info.StringIds, tag);
var definition = Info.Deserializer.Deserialize <RenderModel>(context);
tagNames[tag.Index] = $"{Info.StringIds.GetString(definition.Name)}";
}
private object GetTagDefinition(Stream stream, CachedTagInstance tag)
{
object definition = null;
if (!LoadedDefinitions.ContainsKey(tag.Index))
{
var context = new TagSerializationContext(stream, CacheContext, tag);
definition = LoadedDefinitions[tag.Index] = CacheContext.Deserializer.Deserialize(context, TagDefinition.Find(tag.Group.Tag));
}
else
{
definition = LoadedDefinitions[tag.Index];
}
return(definition);
}
public override bool Execute(List <string> args)
{
if (args.Count != 0)
{
return(false);
}
var shaderMaps = new Dictionary <StringID, TagInstance>();
foreach (var property in Definition.ShaderProperties)
{
RenderMethodTemplate template = null;
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.Read))
{
var context = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIDs, property.Template);
template = Info.Deserializer.Deserialize <RenderMethodTemplate>(context);
}
for (var i = 0; i < template.ShaderMaps.Count; i++)
{
var mapTemplate = template.ShaderMaps[i];
Console.Write(string.Format("Please enter the {0} index: ", Info.StringIDs.GetString(mapTemplate.Name)));
shaderMaps[mapTemplate.Name] = ArgumentParser.ParseTagIndex(Info, Console.ReadLine());
property.ShaderMaps[i].Bitmap = shaderMaps[mapTemplate.Name];
}
}
foreach (var import in Definition.ImportData)
{
if (shaderMaps.ContainsKey(import.MaterialType))
{
import.Bitmap = shaderMaps[import.MaterialType];
}
}
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.ReadWrite))
{
var context = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIDs, Tag);
Info.Serializer.Serialize(context, Definition);
}
Console.WriteLine("Done!");
return(true);
}
private string SaveTagChanges(CachedTagInstance tag, object definition)
{
using (var stream = CacheContext.OpenTagCacheReadWrite())
{
var context = new TagSerializationContext(stream, CacheContext, tag);
CacheContext.Serializer.Serialize(context, definition);
}
var tagName = tag.Name ?? $"0x{tag.Index:X4}";
if (tagName.Contains('\\'))
{
var index = tagName.LastIndexOf('\\') + 1;
tagName = tagName.Substring(index, tagName.Length - index);
}
return($"{tagName}.{ CacheContext.GetString(CurrentTag.Group.Name)}");
}
public override bool Execute(List <string> args)
{
foreach (var property in Definition.ShaderProperties)
{
RenderMethodTemplate template = null;
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.Read))
{
var context = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIDs, property.Template);
template = Info.Deserializer.Deserialize <RenderMethodTemplate>(context);
}
for (var i = 0; i < template.Arguments.Count; i++)
{
Console.WriteLine("");
var argumentName = Info.StringIDs.GetString(template.Arguments[i].Name);
var argumentValue = new Vector4(
property.Arguments[i].Arg1,
property.Arguments[i].Arg2,
property.Arguments[i].Arg3,
property.Arguments[i].Arg4);
Console.WriteLine(string.Format("{0}:", argumentName));
if (argumentName.EndsWith("_map"))
{
Console.WriteLine(string.Format("\tX Scale: {0}", argumentValue.X));
Console.WriteLine(string.Format("\tY Scale: {0}", argumentValue.Y));
Console.WriteLine(string.Format("\tX Offset: {0}", argumentValue.Z));
Console.WriteLine(string.Format("\tY Offset: {0}", argumentValue.W));
}
else
{
Console.WriteLine(string.Format("\tX: {0}", argumentValue.X));
Console.WriteLine(string.Format("\tY: {0}", argumentValue.Y));
Console.WriteLine(string.Format("\tZ: {0}", argumentValue.Z));
Console.WriteLine(string.Format("\tW: {0}", argumentValue.W));
}
}
}
return(true);
}
private bool GetShader(
Mutex mutex,
Stream stream,
CachedTagInstance instance,
IEnumerable <int> shader_rmdfs_ids,
out RenderMethod rm_shader_definition,
out Type rm_shader_type,
out TagSerializationContext rm_shader_context,
out string rmdf_name
)
{
// get shader
rm_shader_definition = null;
rm_shader_type = null;
rm_shader_context = null;
rmdf_name = null;
{
stream.Position = 0;
rm_shader_context = new TagSerializationContext(stream, CacheContext, instance);
// if there is no dependency on the rmsh, early exit
if (shader_rmdfs_ids != null && !rm_shader_context.Tag.Dependencies.Intersect(shader_rmdfs_ids).Any())
{
mutex.ReleaseMutex();
return(true);
}
rm_shader_type = TagDefinition.Find(rm_shader_context.Tag.Group.Tag);
rm_shader_definition = CacheContext.Deserializer.Deserialize(rm_shader_context, rm_shader_type) as RenderMethod;
// double check to make sure this is the correct render method definition
if (shader_rmdfs_ids != null && !shader_rmdfs_ids.Contains(rm_shader_definition.BaseRenderMethod.Index))
{
mutex.ReleaseMutex();
return(true);
}
var rmdf_index = rm_shader_definition.BaseRenderMethod.Index;
rmdf_name = CacheContext.GetTag(rmdf_index)?.Name ?? rmdf_index.ToString("X");
}
return(false);
}
private static List <QueuedTag> FindScenarios(OpenTagCache info, Stream stream)
{
// Get a dictionary of scenarios by map ID
var scenarios = new Dictionary <int, QueuedTag>();
foreach (var scenarioTag in info.Cache.Tags.FindAllInGroup("scnr"))
{
var context = new TagSerializationContext(stream, info.Cache, info.StringIds, scenarioTag);
var scenario = info.Deserializer.Deserialize <Scenario>(context);
scenarios[scenario.MapId] = new QueuedTag {
Tag = scenarioTag, Data = scenario
};
}
var tags = from id in MapIdsToCompare
where scenarios.ContainsKey(id)
select scenarios[id];
return(tags.ToList());
}
private void SetScenarioName(Stream stream, TagInstance tag, ref Dictionary <int, string> tagNames)
{
var context = new TagSerializationContext(stream, Info.Cache, Info.StringIds, tag);
var definition = Info.Deserializer.Deserialize <Scenario>(context);
var tagName = Info.StringIds.GetString(definition.ScenarioZonesetGroups[0].Name);
var slashIndex = tagName.LastIndexOf('\\');
var scenarioName = tagName.Substring(slashIndex + 1);
tagNames[tag.Index] = tagName;
var bsp = definition.StructureBsps[0].StructureBsp2;
if (bsp != null)
{
tagNames[bsp.Index] = tagName;
}
var design = definition.StructureBsps[0].Design;
if (design != null)
{
tagNames[design.Index] = $"{tagName}_design";
}
var cubemap = definition.StructureBsps[0].Cubemap;
if (cubemap != null)
{
tagNames[cubemap.Index] = $"{tagName}_{scenarioName}_cubemaps";
}
var skyObject = definition.SkyReferences[0].SkyObject;
if (skyObject != null)
{
tagNames[skyObject.Index] = $"{tagName.Substring(0, slashIndex)}\\sky\\sky";
}
}
private bool GetRenderMethodTemplate(
Mutex mutex,
Stream stream,
CachedTagInstance instance,
ConcurrentBag <int> serilaizedRmt2,
RenderMethod rm_shader_definition,
out RenderMethodTemplate rmt2_definition,
out TagSerializationContext rmt2_context,
out string rmt2_name
)
{
// get render method template
rmt2_definition = null;
rmt2_context = null;
rmt2_name = null;
{
stream.Position = 0;
rmt2_context = new TagSerializationContext(stream, CacheContext, rm_shader_definition.ShaderProperties[0].Template);
// Skip previously finished RMT2 tags
if (serilaizedRmt2.Contains(rmt2_context.Tag.Index))
{
mutex.ReleaseMutex();
return(true);
}
serilaizedRmt2.Add(rmt2_context.Tag.Index);
rmt2_definition = CacheContext.Deserializer.Deserialize <RenderMethodTemplate>(rmt2_context);
// console output
rmt2_name = rmt2_context?.Tag?.Name ?? rmt2_context.Tag.Index.ToString("X");
Console.WriteLine($"Regenerating {rmt2_name}");
}
return(false);
}
private void ExtractAnimationResource(string tagIndex, string cachePath, string dataPath, int permutationIndex)
{
var tag = ArgumentParser.ParseTagIndex(Info, tagIndex);
int resourceIndex;
ModelAnimationGraph animation;
using (var tagsStream = Info.OpenCacheRead())
{
var tagContext = new TagSerializationContext(tagsStream, Info.Cache, Info.StringIDs, tag);
animation = Info.Deserializer.Deserialize <ModelAnimationGraph>(tagContext);
}
try
{
using (var stream = File.OpenRead(Info.CacheFile.DirectoryName + "\\" + cachePath))
{
var cache = new ResourceCache(stream);
using (var outStream = File.Open(dataPath, FileMode.Create, FileAccess.Write))
{
try
{
resourceIndex = animation.ResourceGroups[permutationIndex].Resource.Index;
cache.Decompress(stream, resourceIndex, 0xFFFFFFFF, outStream);
Console.WriteLine("Wrote 0x{0:X} bytes to {1}. Resource index: {2}, 0x{3}.", outStream.Position, dataPath, resourceIndex, resourceIndex.ToString("X"));
}
catch (Exception ex)
{
Console.WriteLine("Failed to extract resource: {0}", ex.Message);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Failed to extract resource: {0}", ex.Message);
}
}
private void SetModelName(Stream stream, TagInstance tag, ref Dictionary <int, string> tagNames)
{
if (tag == null || tagNames.ContainsKey(tag.Index))
{
return;
}
var context = new TagSerializationContext(stream, Info.Cache, Info.StringIds, tag);
var definition = Info.Deserializer.Deserialize <Model>(context);
if (definition.RenderModel == null)
{
return;
}
SetRenderModelName(stream, definition.RenderModel, ref tagNames);
var tagName = tagNames[definition.RenderModel.Index];
if (tagName.StartsWith("0x"))
{
tagName = $"0x{tag.Index:X4}";
}
tagNames[tag.Index] = tagName;
if (definition.CollisionModel != null && !tagName.StartsWith("0x"))
{
tagNames[definition.CollisionModel.Index] = $"{tagName}";
}
if (definition.Animation != null && !tagName.StartsWith("0x"))
{
tagNames[definition.Animation.Index] = $"{tagName}";
}
}
private void SetGameObjectName(Stream stream, TagInstance tag, ref Dictionary <int, string> tagNames)
{
var context = new TagSerializationContext(stream, Info.Cache, Info.StringIds, tag);
var definition = (GameObject)Info.Deserializer.Deserialize(context, TagStructureTypes.FindByGroupTag(tag.Group.Tag));
if (definition.Model == null)
{
return;
}
context = new TagSerializationContext(stream, Info.Cache, Info.StringIds, definition.Model);
var modelDefinition = Info.Deserializer.Deserialize <Model>(context);
if (modelDefinition.RenderModel == null)
{
return;
}
context = new TagSerializationContext(stream, Info.Cache, Info.StringIds, modelDefinition.RenderModel);
var renderModelDefinition = Info.Deserializer.Deserialize <RenderModel>(context);
var objectName = Info.StringIds.GetString(renderModelDefinition.Name);
if (tag.Group.Tag == new Tag("bipd"))
{
var biped = (Biped)definition;
var isMultiplayer = objectName.StartsWith("mp_");
var isMonitor = objectName.StartsWith("monitor");
var objectRootName = isMultiplayer ?
objectName.Substring(3) :
objectName;
var objectGenericName = $"objects\\characters\\{objectRootName}\\{objectRootName}";
if (objectRootName != objectName)
{
objectName = $"objects\\characters\\{objectRootName}\\{objectName}\\{objectName}";
}
else if (isMonitor)
{
objectName = $"{objectGenericName}_editor";
}
else
{
objectName = objectGenericName;
}
tagNames[definition.Model.Index] = objectName;
if (modelDefinition.RenderModel != null)
{
tagNames[modelDefinition.RenderModel.Index] = objectName;
}
if (modelDefinition.CollisionModel != null)
{
tagNames[modelDefinition.CollisionModel.Index] = objectGenericName;
}
if (modelDefinition.PhysicsModel != null)
{
tagNames[modelDefinition.PhysicsModel.Index] = objectGenericName;
}
if (modelDefinition.Animation != null)
{
tagNames[modelDefinition.Animation.Index] = objectGenericName;
}
if (biped.CollisionDamage != null && !tagNames.ContainsKey(biped.CollisionDamage.Index))
{
tagNames[biped.CollisionDamage.Index] = isMonitor ?
"globals\\collision_damage\\invulnerable_harmless" :
"globals\\collision_damage\\biped_player";
}
if (biped.MaterialEffects != null && !tagNames.ContainsKey(biped.MaterialEffects.Index))
{
tagNames[biped.MaterialEffects.Index] =
$"fx\\material_effects\\objects\\characters\\{objectRootName}";
}
if (biped.MeleeImpact != null && !tagNames.ContainsKey(biped.MeleeImpact.Index))
{
tagNames[biped.MeleeImpact.Index] =
"sounds\\materials\\soft\\organic_flesh\\melee_impact";
}
if (biped.CameraTracks.Count != 0 && biped.CameraTracks[0].Track != null && !tagNames.ContainsKey(biped.CameraTracks[0].Track.Index))
{
tagNames[biped.CameraTracks[0].Track.Index] = isMonitor ?
"camera\\biped_follow_camera" :
"camera\\biped_support_camera";
}
if (biped.MeleeDamage != null && !tagNames.ContainsKey(biped.MeleeDamage.Index))
{
tagNames[biped.MeleeDamage.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_melee";
}
if (biped.BoardingMeleeDamage != null && !tagNames.ContainsKey(biped.BoardingMeleeDamage.Index))
{
tagNames[biped.BoardingMeleeDamage.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_boarding_melee";
}
if (biped.BoardingMeleeResponse != null && !tagNames.ContainsKey(biped.BoardingMeleeResponse.Index))
{
tagNames[biped.BoardingMeleeResponse.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_boarding_melee_response";
}
if (biped.EjectionMeleeDamage != null && !tagNames.ContainsKey(biped.EjectionMeleeDamage.Index))
{
tagNames[biped.EjectionMeleeDamage.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_ejection_melee";
}
if (biped.EjectionMeleeResponse != null && !tagNames.ContainsKey(biped.EjectionMeleeResponse.Index))
{
tagNames[biped.EjectionMeleeResponse.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_ejection_melee_response";
}
if (biped.LandingMeleeDamage != null && !tagNames.ContainsKey(biped.LandingMeleeDamage.Index))
{
tagNames[biped.LandingMeleeDamage.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_landing_melee";
}
if (biped.FlurryMeleeDamage != null && !tagNames.ContainsKey(biped.FlurryMeleeDamage.Index))
{
tagNames[biped.FlurryMeleeDamage.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_flurry_melee";
}
if (biped.ObstacleSmashMeleeDamage != null && !tagNames.ContainsKey(biped.ObstacleSmashMeleeDamage.Index))
{
tagNames[biped.ObstacleSmashMeleeDamage.Index] =
$"objects\\characters\\{objectRootName}\\damage_effects\\{objectRootName}_obstacle_smash";
}
if (biped.AreaDamageEffect != null && !tagNames.ContainsKey(biped.AreaDamageEffect.Index))
{
tagNames[biped.AreaDamageEffect.Index] =
$"fx\\material_effects\\objects\\characters\\contact\\collision\\blood_aoe_{objectRootName}";
}
}
else if (tag.Group.Tag == new Tag("weap"))
{
var weapon = (Weapon)definition;
if (weapon.HudInterface != null && !tagNames.ContainsKey(weapon.HudInterface.Index))
{
tagNames[weapon.HudInterface.Index] = $"ui\\chud\\{objectName}";
}
if (weapon.FirstPerson.Count > 0)
{
var spartanJmadTag = weapon.FirstPerson[0].FirstPersonAnimations;
if (spartanJmadTag != null)
{
tagNames[spartanJmadTag.Index] = $"objects\\characters\\mp_masterchief\\fp\\weapons\\fp_{objectName}\\fp_{objectName}";
}
}
if (weapon.FirstPerson.Count > 1)
{
var eliteJmadTag = weapon.FirstPerson[1].FirstPersonAnimations;
if (eliteJmadTag != null)
{
tagNames[eliteJmadTag.Index] = $"objects\\characters\\mp_elite\\fp\\weapons\\fp_{objectName}\\fp_{objectName}";
}
}
var weaponClassName =
// HUNTER WEAPONS
objectName.StartsWith("flak_cannon") ?
"hunter\\hunter_flak_cannon" :
// MELEE WEAPONS
objectName.StartsWith("energy_blade") ?
"melee\\energy_blade" :
objectName.StartsWith("gravity_hammer") ?
"melee\\gravity_hammer" :
// MULTIPLAYER WEAPONS
objectName.StartsWith("assault_bomb") ?
"multiplayer\\assault_bomb" :
objectName.StartsWith("ball") ?
"multiplayer\\ball" :
objectName.StartsWith("flag") ?
"multiplayer\\flag" :
// PISTOL WEAPONS
objectName.StartsWith("excavator") ?
"pistol\\excavator" :
objectName.StartsWith("magnum") ?
"pistol\\magnum" :
objectName.StartsWith("needler") ?
"pistol\\needler" :
objectName.StartsWith("plasma_pistol") ?
"pistol\\plasma_pistol" :
// RIFLE WEAPONS
(objectName.StartsWith("assault_rifle") || objectName.StartsWith("ar_variant")) ?
"rifle\\assault_rifle" :
(objectName.StartsWith("battle_rifle") || objectName.StartsWith("br_variant")) ?
"rifle\\battle_rifle" :
objectName.StartsWith("beam_rifle") ?
"rifle\\beam_rifle" :
objectName.StartsWith("covenant_carbine") ?
"rifle\\covenant_carbine" :
objectName.StartsWith("dmr") ?
"rifle\\dmr" :
objectName.StartsWith("needle_rifle") ?
"rifle\\needle_rifle" :
objectName.StartsWith("plasma_rifle") ?
"rifle\\plasma_rifle" :
objectName.StartsWith("shotgun") ?
"rifle\\shotgun" :
objectName.StartsWith("smg") ?
"rifle\\smg" :
objectName.StartsWith("sniper_rifle") ?
"rifle\\sniper_rifle" :
objectName.StartsWith("spike_rifle") ?
"rifle\\spike_rifle" :
// SUPPORT WEAPONS
objectName.StartsWith("rocket_launcher") ?
"support_high\\rocket_launcher" :
objectName.StartsWith("spartan_laser") ?
"support_high\\spartan_laser" :
objectName.StartsWith("brute_shot") ?
"support_low\\brute_shot" :
objectName.StartsWith("sentinel_gun") ?
"support_low\\sentinel_gun" :
// OTHER WEAPONS
objectName;
objectName = $"objects\\weapons\\{weaponClassName}\\{objectName}";
if (objectName.EndsWith("energy_blade") && definition.WaterDensity == GameObject.WaterDensityValue.Default)
{
objectName += "_useless";
}
tagNames[definition.Model.Index] = objectName;
if (modelDefinition.RenderModel != null)
{
tagNames[modelDefinition.RenderModel.Index] = objectName;
}
if (modelDefinition.CollisionModel != null)
{
tagNames[modelDefinition.CollisionModel.Index] = objectName;
}
if (modelDefinition.PhysicsModel != null)
{
tagNames[modelDefinition.PhysicsModel.Index] = objectName;
}
if (modelDefinition.Animation != null)
{
tagNames[modelDefinition.Animation.Index] = objectName;
}
}
else if (tag.Group.Tag == new Tag("eqip"))
{
var equipment = (Equipment)definition;
var equipmentClassName =
(objectName.StartsWith("health_pack") || objectName.EndsWith("ammo")) ?
$"powerups\\{objectName}" :
objectName.StartsWith("powerup") ?
$"multi\\powerups\\{objectName}" :
objectName.EndsWith("grenade") ?
$"weapons\\grenade\\{objectName}" :
$"equipment\\{objectName}";
objectName = $"objects\\{equipmentClassName}\\{objectName}";
}
else if (tag.Group.Tag == new Tag("vehi"))
{
}
else if (tag.Group.Tag == new Tag("armr"))
{
// TODO: figure out spartan/elite armor name differences
objectName = $"objects\\characters\\masterchief\\mp_masterchief\\armor\\{objectName}";
tagNames[definition.Model.Index] = objectName;
if (modelDefinition.RenderModel != null)
{
tagNames[modelDefinition.RenderModel.Index] = objectName;
}
if (modelDefinition.CollisionModel != null)
{
tagNames[modelDefinition.CollisionModel.Index] = objectName;
}
if (modelDefinition.PhysicsModel != null)
{
tagNames[modelDefinition.PhysicsModel.Index] = objectName;
}
if (modelDefinition.Animation != null)
{
tagNames[modelDefinition.Animation.Index] = objectName;
}
}
tagNames[tag.Index] = objectName;
}
public override bool Execute(List <string> args)
{
if (args.Count < 1 || args.Count > 2)
{
return(false);
}
string palette = "all";
if (args.Count == 2)
{
palette = args[0].ToLower();
args.RemoveAt(0);
}
if (ValidPalettes.Find(i => i == palette) == null)
{
Console.WriteLine($"ERROR: invalid forge palette specified: {palette}");
return(false);
}
var destinationTag = ArgumentParser.ParseTagIndex(Info, args[0]);
if (destinationTag == null || destinationTag.Group.Tag.ToString() != "scnr")
{
Console.WriteLine($"ERROR: invalid destination scenario index: {args[0]}");
return(false);
}
Console.Write("Loading destination scenario...");
Scenario destinationScenario = null;
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.ReadWrite))
{
var scenarioContext = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIDs, destinationTag);
destinationScenario = Info.Deserializer.Deserialize <Scenario>(scenarioContext);
}
Console.WriteLine("done.");
Console.Write("Copying specified forge palettes...");
destinationScenario.SandboxBudget = Definition.SandboxBudget;
if (palette == "all" || palette == "equipment")
{
destinationScenario.SandboxEquipment = Definition.SandboxEquipment;
}
if (palette == "all" || palette == "goal_objects")
{
destinationScenario.SandboxGoalObjects = Definition.SandboxGoalObjects;
}
if (palette == "all" || palette == "scenery")
{
destinationScenario.SandboxScenery = Definition.SandboxScenery;
}
if (palette == "all" || palette == "spawning")
{
destinationScenario.SandboxSpawning = Definition.SandboxSpawning;
}
if (palette == "all" || palette == "teleporters")
{
destinationScenario.SandboxTeleporters = Definition.SandboxTeleporters;
}
if (palette == "all" || palette == "vehicles")
{
destinationScenario.SandboxVehicles = Definition.SandboxVehicles;
}
if (palette == "all" || palette == "weapons")
{
destinationScenario.SandboxWeapons = Definition.SandboxWeapons;
}
Console.WriteLine("done.");
Console.Write("Serializing destination scenario...");
using (var cacheStream = Info.CacheFile.Open(FileMode.Open, FileAccess.ReadWrite))
{
var scenarioContext = new TagSerializationContext(cacheStream, Info.Cache, Info.StringIDs, destinationTag);
Info.Serializer.Serialize(scenarioContext, destinationScenario);
}
Console.WriteLine("done.");
return(true);
}
public override bool Execute(List <string> args)
{
if (args.Count < 1 || args.Count > 2)
{
return(false);
}
TagInstance destination = _cache.Tags[0x3317];
if (args.Count == 2)
{
destination = ArgumentParser.ParseTagIndex(_cache, args[0]);
if (!destination.IsInGroup("mode"))
{
Console.WriteLine("Specified tag is not a render_model: " + args[0]);
return(false);
}
args = args.Skip(1).ToList();
}
var builder = new RenderModelBuilder(_info.Version);
// Add a root node
var node = builder.AddNode(new RenderModel.Node
{
Name = _stringIds.GetStringId("street_cone"),
ParentNode = -1,
FirstChildNode = -1,
NextSiblingNode = -1,
DefaultRotation = new Vector4(0, 0, 0, -1),
DefaultScale = 1,
InverseForward = new Vector3(1, 0, 0),
InverseLeft = new Vector3(0, 1, 0),
InverseUp = new Vector3(0, 0, 1),
});
// Begin building the default region and permutation
builder.BeginRegion(_stringIds.GetStringId("default"));
builder.BeginPermutation(_stringIds.GetStringId("default"));
using (var importer = new AssimpContext())
{
Scene model;
using (var logStream = new LogStream((msg, userData) => Console.WriteLine(msg)))
{
logStream.Attach();
model = importer.ImportFile(args[0],
PostProcessSteps.CalculateTangentSpace |
PostProcessSteps.GenerateNormals |
PostProcessSteps.JoinIdenticalVertices |
PostProcessSteps.SortByPrimitiveType |
PostProcessSteps.PreTransformVertices |
PostProcessSteps.Triangulate);
logStream.Detach();
}
Console.WriteLine("Assembling vertices...");
// Build a multipart mesh from the model data,
// with each model mesh mapping to a part of one large mesh and having its own material
builder.BeginMesh();
ushort partStartVertex = 0;
ushort partStartIndex = 0;
var vertices = new List <RigidVertex>();
var indices = new List <ushort>();
foreach (var mesh in model.Meshes)
{
for (var i = 0; i < mesh.VertexCount; i++)
{
var position = mesh.Vertices[i];
var normal = mesh.Normals[i];
var uv = mesh.TextureCoordinateChannels[0][i];
var tangent = mesh.Tangents[i];
var bitangent = mesh.BiTangents[i];
vertices.Add(new RigidVertex
{
Position = new Vector4(position.X, position.Y, position.Z, 1),
Normal = new Vector3(normal.X, normal.Y, normal.Z),
Texcoord = new Vector2(uv.X, uv.Y),
Tangent = new Vector4(tangent.X, tangent.Y, tangent.Z, 1),
Binormal = new Vector3(bitangent.X, bitangent.Y, bitangent.Z),
});
}
// Build the index buffer
var meshIndices = mesh.GetIndices();
indices.AddRange(meshIndices.Select(i => (ushort)(i + partStartVertex)));
// Define a material and part for this mesh
var material = builder.AddMaterial(new RenderMaterial
{
RenderMethod = _cache.Tags[0x101F],
});
builder.DefinePart(material, partStartIndex, (ushort)meshIndices.Length, (ushort)mesh.VertexCount);
// Move to the next part
partStartVertex += (ushort)mesh.VertexCount;
partStartIndex += (ushort)meshIndices.Length;
}
// Bind the vertex and index buffers
builder.BindRigidVertexBuffer(vertices, node);
builder.BindIndexBuffer(indices, PrimitiveType.TriangleList);
builder.EndMesh();
}
builder.EndPermutation();
builder.EndRegion();
Console.WriteLine("Building Blam mesh data...");
var resourceStream = new MemoryStream();
var renderModel = builder.Build(_info.Serializer, resourceStream);
Console.WriteLine("Writing resource data...");
// Add a new resource for the model data
var resources = new ResourceDataManager();
resources.LoadCachesFromDirectory(_fileInfo.DirectoryName);
resourceStream.Position = 0;
resources.Add(renderModel.Geometry.Resource, ResourceLocation.Resources, resourceStream);
Console.WriteLine("Writing tag data...");
using (var cacheStream = _fileInfo.Open(FileMode.Open, FileAccess.ReadWrite))
{
var tag = destination;
var context = new TagSerializationContext(cacheStream, _cache, _stringIds, tag);
_info.Serializer.Serialize(context, renderModel);
}
Console.WriteLine("Model imported successfully!");
return(true);
}
