////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Gets the model data from the tag. </summary>
///
/// <param name="tagIndex"> The parent tag index. </param>
/// <param name="tagManager"> The tags' manager. </param>
///
/// <returns> The model data. </returns>
private ModelData GetModelData(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager)
{
var data = new ModelData();
data.CollectData(tagIndex, tagManager);
return(data);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Gets the shader data from the tag. </summary>
///
/// <param name="tagIndex"> The parent tag index. </param>
/// <param name="tagManager"> The tags' manager. </param>
///
/// <returns> The shader data. </returns>
private StructureBSPShaderData GetShaderData(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager)
{
var data = new StructureBSPShaderData();
data.CollectData(tagIndex, tagManager);
return(data);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Gets the scenario data from the tag. </summary>
///
/// <param name="tagIndex"> Zero-based index of the tag. </param>
/// <param name="tagManager"> The tag's manager. </param>
///
/// <returns> The scenario data. </returns>
private ScenarioData GetScenarioData(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager)
{
var data = new ScenarioData();
data.MessageSent += MessageRedirect;
data.CollectData(tagIndex, tagManager);
data.MessageSent -= MessageRedirect;
return(data);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Gets the BSP data from the tag. </summary>
///
/// <param name="tagIndex"> The parent tag index. </param>
/// <param name="tagManager"> The tag's manager. </param>
///
/// <returns> The bsp data. </returns>
private StructureBSPData GetBSPData(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager)
{
var data = new StructureBSPData()
{
IncludeRenderMesh = mBspData.ExportRenderMesh,
IncludePortals = mBspData.ExportPortals,
IncludeFogPlanes = mBspData.ExportFogPlanes,
IncludeBSPMarkers = mBspData.ExportBSPMarkers
};
data.CollectData(tagIndex, tagManager);
return(data);
}
/// <summary>Extract an existing tag to a file</summary>
/// <param name="tag_datum">index of tag to extract</param>
/// <param name="base_directory">Root directory to extract the tag to</param>
/// <param name="name_override">Optional, if not null, this is the name of the file we store the tag in</param>
/// <returns>false if it can't save the tag</returns>
public bool Extract(Blam.DatumIndex tag_datum, string base_directory, string name_override)
{
Blam.DatumIndex handle = Open(tag_datum);
if (handle != Blam.DatumIndex.Null)
{
TagManager tm = Array[handle];
try {
tm.OpenForExtract(base_directory, name_override);
tm.Extract();
}
catch (Exception ex) { extractionTrace.WriteLine("Couldn't extract tag: '{0}'{1}{2}", tm.Name, Program.NewLine, ex); return(false); }
}
else
{
return(false);
}
return(true);
}
public bool Export(ScenarioData scenarioData
, BlamLib.Managers.TagManager tagManager
, string outputFile)
{
// Create the COLLADA exporter
var extractor = new ColladaScenarioExporter(mColladaSettings,
TagIndex,
tagManager);
extractor.MessageSent +=
(sender, args) =>
{
mMessageHandler.SendMessage("Exporter Error: {0}", args.Message);
};
extractor.AddDataProvider(scenarioData);
if (extractor.BuildColladaInstance())
{
extractor.SaveDAE(outputFile);
return(true);
}
return(false);
}
public TagIndexEventArgs(TagIndexBase index, TagManager tag)
{
tagIndex = index;
tagMan = tag;
}
bool Extract(Blam.CacheExtractionInfo cei, Blam.DatumIndex tag_datum, bool remove_from_state)
{
if (remove_from_state)
{
// don't process it if it's already been done
if (cacheFile.ExtractionState.Processed(tag_datum))
{
return(true);
}
cacheFile.ExtractionState.Dequeue(tag_datum);
}
cacheFile.ExtractionState.CurrentTag = tag_datum;
Blam.CacheIndex.Item ci = cacheFile.Index.Tags[tag_datum.Index];
bool error = false;
Blam.DatumIndex handle = Open(tag_datum);
if (handle != Blam.DatumIndex.Null)
{
// we're about to extract, update our depth level
cei.ExtractionDepth++;
TagManager tm = Array[handle];
#region read the tag from the cache
try { tm.OpenForExtract(cei.Arguments.OutputDirectory, null); }
catch (Exception ex) { extractionTrace.WriteLine("Failed to read tag, aborting extraction...'{0}.{1}'{2}{3}", tm.Name, tm.GroupTag.Name, Program.NewLine, ex); error = true; }
#endregion
#region if no errors
if (!error)
{
try { tm.Extract(); }
catch (Exception ex) { extractionTrace.WriteLine("Failed to write tag, aborting extraction...'{0}.{1}'{2}{3}", tm.Name, tm.GroupTag.Name, Program.NewLine, ex); error = true; }
tm.Close();
}
// something bad happened, so make sure we don't keep any bad tags
if (error)
{
System.IO.File.Delete(Path.Combine(cei.Arguments.OutputDirectory, tm.Name));
}
// process dependents if we want to
if (!error && cei.Arguments.WithDependents)
{
error = !ExtractWithDependents(cei, tm);
}
#endregion
// we're done with the extraction process, update depth level
cei.ExtractionDepth--;
// create and write database
if (cei.Arguments.OutputDatabase && cei.ExtractionDepth == 0)
{
ExtractWriteTagDatabases(cei, tm);
}
Unload(handle);
}
else
{
error = true;
}
return(!error);
}
/// <summary>
/// Open a tag in the cache file
/// </summary>
/// <param name="tag_datum">index of tag</param>
/// <returns>
/// The tag_index handle associated to the <see cref="TagManager"/> object used to open the tag,
/// or <see cref="Blam.DatumIndex.Null"/> if this operations fails
/// </returns>
public Blam.DatumIndex Open(Blam.DatumIndex tag_datum)
{
if (tag_datum == Blam.DatumIndex.Null)
{
return(Blam.DatumIndex.Null);
}
Blam.CacheIndex.Item i = cacheFile.Index.Tags[tag_datum.Index];
if (i.IsEmpty)
{
throw new ArgumentNullException("tag_datum", string.Format("The tag handle {0} references an empty tag. We can't open this!", tag_datum.ToString()));
}
// How can we open it if we don't know where it F*****G IS YOU C**T??
if (i.Location != Blam.CacheIndex.ItemLocation.Internal && !i.IsFeignItem)
{
return(Blam.DatumIndex.Null);
}
// Is this tag already loaded? if so, reuse handle
Blam.DatumIndex di = IsLoaded(i);
if (di != Blam.DatumIndex.Null)
{
Array.IncrementReference(di);
return(di);
}
TagManager tm = new TagManager(this);
tm.ReferenceName = i.ReferenceName; // sync the tag manager's name with the cache item's
bool group_tag_hack = false;
BlamBuild build = Engine.ToBuild();
// HACK: Halo1 PC uses gbx's variant of the model tag
if (Engine == BlamVersion.Halo1_CE && i.GroupTag == Blam.Halo1.TagGroups.mode)
{
tm.Manage(Blam.Halo1.TagGroups.mod2);
group_tag_hack = true;
}
else
// HACK: Halo 2/3 use a the 'sound' group tag for their 'cache_file_sound' definitions
#if !NO_HALO2
if (build == BlamBuild.Halo2 && i.GroupTag == Blam.Halo2.TagGroups.snd_)
{
tm.Manage(Blam.Halo2.TagGroups.shit);
group_tag_hack = true;
}
else
#endif
#if !NO_HALO3
if (build == BlamBuild.Halo3 && i.GroupTag == Blam.Halo3.TagGroups.snd_)
{
tm.Manage(Blam.Halo3.TagGroups.shit);
group_tag_hack = true;
}
else
#endif
#if !NO_HALO_ODST
if (build == BlamBuild.HaloOdst && i.GroupTag == Blam.Halo3.TagGroups.snd_)
{
tm.Manage(Blam.Halo3.TagGroups.shit);
group_tag_hack = true;
}
else
#endif
#if !NO_HALO_REACH
if (build == BlamBuild.HaloReach && i.GroupTag == Blam.HaloReach.TagGroups.snd_)
{
tm.Manage(Blam.HaloReach.TagGroups.shit);
group_tag_hack = true;
}
else
#endif
#if !NO_HALO4
if (build == BlamBuild.Halo4 && i.GroupTag == Blam.Halo4.TagGroups.snd_)
{
tm.Manage(Blam.Halo4.TagGroups.shit);
group_tag_hack = true;
}
else
#endif
{ tm.Manage(i.GroupTag); }
if (!i.IsFeignItem)
{
// We don't care about this shit when extracting or opening from a cache file
const uint k_open_flags = IO.ITagStreamFlags.DontTrackTagManagerReferences |
IO.ITagStreamFlags.DontTrackTagReferencers;
tm.Flags.Add(k_open_flags);
try { tm.Read(i, cacheFile, group_tag_hack); }
catch (Exception ex)
{
indexTrace.WriteLine("Cache Index: Failed to open tag from cache: {0}{1}'{2}.{3}'{4}{5}",
cacheFile.InputStream.FileName, Program.NewLine,
cacheFile.GetReferenceName(i), i.GroupTag.Name, Program.NewLine, ex);
return(Blam.DatumIndex.Null);
}
// Remove the flag we set before reading
tm.Flags.Remove(k_open_flags);
}
tm.TagIndex = Array.Add(tm);
base.OnEventOpen(new TagIndexEventArgs(this, tm));
return(tm.TagIndex);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Exports the provided bsp's lightmap sizes with a multiplier. </summary>
///
/// <param name="tagIndex"> Tag index the bsp belongs to. </param>
/// <param name="tagManager"> The bsp tag's manager. </param>
/// <param name="sizeMultiplier"> The lightmap size multiplier. </param>
/// <param name="outputFile"> The bsp's output file. </param>
public void Export(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager, int sizeMultiplier, string outputFile)
{
// Collect the necessary data
var structureBSP = tagManager.TagDefinition as BlamLib.Blam.Halo1.Tags.structure_bsp_group;
if (!TagIndex.IsValid(structureBSP.LightmapBitmaps.Datum))
{
mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString());
return;
}
var bitmapManager = tagIndex[structureBSP.LightmapBitmaps.Datum];
if (bitmapManager == null)
{
mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString());
return;
}
if (structureBSP.Lightmaps.Count == 0)
{
mMessageHandler.SendMessage("BSP has no lightmaps {0}", tagManager.Name);
return;
}
var bitmap = bitmapManager.TagDefinition as BlamLib.Blam.Halo1.Tags.bitmap_group;
if (bitmap == null)
{
mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString());
return;
}
// Build the lightmap size list
var lightmapSizeList = new List <string>();
var bspName = Path.GetFileNameWithoutExtension(tagManager.Name);
foreach (var lightmap in structureBSP.Lightmaps)
{
if (lightmap.Bitmap.Value == -1)
{
continue;
}
if (lightmap.Bitmap.Value >= bitmap.Bitmaps.Count)
{
mMessageHandler.SendMessage("Failed to export lightmap sizes. A lightmap bitmap and bsp do not have matching lightmap counts {0}", tagManager.Name);
return;
}
var bitmapInfo = bitmap.Bitmaps[lightmap.Bitmap.Value];
lightmapSizeList.Add(String.Format("{0}_{1}\t[{2},{3}]"
, bspName
, lightmap.Bitmap.Value
, bitmapInfo.Width * sizeMultiplier
, bitmapInfo.Height * sizeMultiplier));
}
// Save the sizes to file
var sizeFileName = Path.ChangeExtension(outputFile, "lmsz");
try
{
using (var outputStream = File.OpenWrite(sizeFileName))
{
var writer = new StreamWriter(outputStream);
writer.Write(String.Join("\r\n", lightmapSizeList));
writer.Flush();
}
mMessageHandler.SendMessage("BSP lightmap sizes saved");
}
catch (IOException)
{
mMessageHandler.SendMessage("Failed to open the lightmap sizes file");
}
}
