public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("sily");
s.WriteAttributeString("name", tag.Name);
{
s.WriteAttributeString("titleId", Title.ToString());
if (!Description.Handle.IsNull)
{
s.WriteAttributeString("descId", Description.ToString());
}
s.WriteAttributeString("param", Parameter.ToString());
SettingParameters[Parameter.Value] = tag.Name;
s.WriteStartElement("values");
s.WriteAttributeString("type", Type.ToString());
foreach (var vp in Values)
{
vp.ToStream(s, tag, this, Type.Value);
}
s.WriteEndElement();
}
s.WriteEndElement();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t\t\t\t";
if (Unknown20 != 0)
{
s.Write("{0}\t", Unknown20.Value.ToString("X8"));
}
if (!Title.Handle.IsNull)
{
s.Write("{0}", Title);
}
s.WriteLine();
if (!Settings.Datum.IsNull)
{
s.Write(k_ident + "\tSettings\t"); ReferenceToStream(s, Settings);
s.WriteLine();
}
if (!Template.Datum.IsNull)
{
s.Write(k_ident + "\tTemplate\t"); ReferenceToStream(s, Template);
s.WriteLine();
}
if (!ValuePairs.Datum.IsNull)
{
s.Write(k_ident + "\tValuePairs\t"); ReferenceToStream(s, ValuePairs);
s.WriteLine();
}
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner, int type)
{
s.WriteStartElement("entry");
s.WriteAttributeString("labelId", Name.ToString());
if (!Description.Handle.IsNull)
{
s.WriteAttributeString("descId", Description.ToString());
}
switch (type)
{
case 0: s.WriteAttributeString("int", Integer.Value.ToString()); break;
case 1: s.WriteAttributeString("stringId", StringId.ToString()); break;
case 2: System.Diagnostics.Debugger.Break(); break;
case 3: s.WriteAttributeString("real", Real.Value.ToString("r")); break;
}
if (Flags.Value != 0)
{
s.WriteAttributeString("flags", Flags.ToString());
}
s.WriteEndElement();
}
/// <summary>
/// Creates a DatumIndex list of the bitmaps used in a shader
/// </summary>
/// <param name="shader_datum"></param>
/// <returns></returns>
protected override List <DatumIndex> GetShaderBitmaps(DatumIndex shader_datum)
{
List <DatumIndex> bitmap_datums = new List <DatumIndex>();
if (!IsDatumValid(shader_datum))
{
return(bitmap_datums);
}
Managers.TagManager shader_man = tagIndex[shader_datum];
H2.Tags.shader_group shader = shader_man.TagDefinition as H2.Tags.shader_group;
H2.Tags.global_shader_parameter_block block;
if ((block = FindParameter(shader, "base_map")) != null && IsDatumValid(block.Bitmap.Datum))
{
bitmap_datums.Add(block.Bitmap.Datum);
}
if ((block = FindParameter(shader, "alpha_test_map")) != null && IsDatumValid(block.Bitmap.Datum))
{
bitmap_datums.Add(block.Bitmap.Datum);
}
return(bitmap_datums);
}
protected override Blam.Cache.BuilderItem BuildFromSource(Managers.TagManager source_tag)
{
BuilderItem bi = new BuilderItem(this, source_tag);
bi.Datum = Array.Add(bi);
return(bi);
}
///-------------------------------------------------------------------------------------------------
/// <summary> Halo1 Scenario exporter class. </summary>
/// <param name="settings"> Export arguments for the collada interface. </param>
/// <param name="tagIndex"> The tag index containing the tag being exported. </param>
/// <param name="tagManager"> The tag manager of the tag being exported. </param>
///-------------------------------------------------------------------------------------------------
public ColladaScenarioExporter(IColladaSettings settings
, Managers.TagIndexBase tagIndex
, Managers.TagManager tagManager)
: base(settings, tagIndex)
{
mTagManager = tagManager;
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("lgtd");
s.WriteAttributeString("name", tag.Name);
{
s.WriteStartElement("types");
foreach (var element in Loadouts)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("sets");
foreach (var element in LoadoutSets)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("names");
foreach (var element in LoadoutNames)
{
s.WriteStartElement("entry");
s.WriteAttributeString("name", element.Value.ToString());
s.WriteEndElement();
}
s.WriteEndElement();
}
s.WriteEndElement();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteLine("{0}\t{1}\t{2}\t{3}",
Unknown8, Points,
Name, Unknown4);
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("unic");
s.WriteAttributeString("name", tag.Name);
{
s.WriteStartElement("references");
foreach (var sr in StringRefs)
{
sr.ToStream(s, tag, this);
}
s.WriteEndElement();
if (false && BlockC.Count > 0)
{
s.WriteStartElement("unkC");
foreach (var sr in BlockC)
{
sr.ToStream(s, tag, this);
}
s.WriteEndElement();
}
}
s.WriteEndElement();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t";
s.WriteLine(k_ident + "Names");
for (int x = 0; x < Names.Count; x++)
{
s.Write(k_ident + "\t");
s.Write(x.ToString("X4"));
s.Write("\t");
s.WriteLine(Names[x]);
}
s.WriteLine();
s.WriteLine(k_ident + "BlockC");
for (int x = 0; x < BlockC.Count; x++)
{
s.Write(k_ident + "\t");
s.Write(x.ToString("X4"));
s.Write("\t");
BlockC[x].ToStream(s, tag, this);
}
s.WriteLine();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t";
s.WriteLine(k_ident + "Categories");
for (int x = 0; x < Categories.Count; x++)
{
s.Write(k_ident + "\t");
s.Write(x.ToString("X4"));
s.Write("\t");
Categories[x].ToStream(s, tag, this);
}
s.WriteLine();
s.WriteLine(k_ident + "Medals");
for (int x = 0; x < Medals.Count; x++)
{
s.Write(k_ident + "\t");
s.Write(x.ToString("X4"));
s.Write("\t");
Medals[x].ToStream(s, tag, this);
}
s.WriteLine();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.Write("{0}\t", Name);
DefinitionToStream(s);
s.WriteLine();
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("entry");
s.WriteAttributeString("name", Name.ToString());
if (!AppSlot1.Handle.IsNull)
{
s.WriteAttributeString("appSlot1", AppSlot1.ToString());
}
if (!AppSlot2.Handle.IsNull)
{
s.WriteAttributeString("appSlot2", AppSlot2.ToString());
}
if (!PrimaryWeapon.Handle.IsNull)
{
s.WriteAttributeString("primary", PrimaryWeapon.ToString());
}
if (!SecondaryWeapon.Handle.IsNull)
{
s.WriteAttributeString("secondary", SecondaryWeapon.ToString());
}
if (!Equipment.Handle.IsNull)
{
s.WriteAttributeString("equipment", Equipment.ToString());
}
s.WriteEndElement();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteLine("{0}\t{1}",
ObjectMappingIndex.Value.ToString("X4"),
Unknown0.Value.ToString("X8"));
}
public void Halo1TestTagIndex()
{
using (var handler = new TagIndexHandler <Managers.TagIndex>(BlamVersion.Halo1_CE, kTestTagIndexTagsPath))
{
var tagindex = handler.IndexInterface;
Blam.DatumIndex datum_scnr_index, datum_matg_index;
StartStopwatch();
{
StartSubStopwatch();
datum_scnr_index = tagindex.Open(@"levels\test\tutorial\tutorial", Blam.Halo1.TagGroups.scnr, IO.ITagStreamFlags.LoadDependents);
Console.WriteLine("SCENARIO LOAD: Time taken: {0}", StopSubStopwatch());
}
{
StartSubStopwatch();
datum_matg_index = tagindex.Open(@"globals\globals", Blam.Halo1.TagGroups.matg, IO.ITagStreamFlags.LoadDependents);
Console.WriteLine("GLOBALS LOAD: Time taken: {0}", StopSubStopwatch());
}
Console.WriteLine("TAG INDEX: Time taken: {0}", StopStopwatch());
Managers.TagManager tag_manager_scnr = tagindex[datum_scnr_index];
var tag_scenario = tag_manager_scnr.TagDefinition as Blam.Halo1.Tags.scenario_group;
tag_scenario = null;
tag_manager_scnr = null;
// using (var sw = new StreamWriter(Path.Combine(kTestResultsTagsPath, @"dump_tag_index.txt")))
// { tagindex.Dump(sw); }
Assert.IsTrue(tagindex.Unload(datum_scnr_index));
Assert.IsTrue(tagindex.Unload(datum_matg_index));
}
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("entry");
s.WriteAttributeString("name", Name.ToString());
s.WriteEndElement();
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("ggol");
s.WriteAttributeString("name", tag.Name);
{
s.WriteStartElement("types");
foreach (var element in OrdnanceList)
{
s.WriteStartElement("entry");
s.WriteAttributeString("name", element.Name.ToString());
s.WriteAttributeString("lookupName", element.LookupName.ToString());
s.WriteAttributeString("typeName", element.ObjectType.ToString());
s.WriteEndElement();
}
s.WriteEndElement();
s.WriteStartElement("sets");
foreach (var element in OrdnanceSets)
{
s.WriteStartElement("entry");
s.WriteAttributeString("name", element.Name.ToString());
s.WriteAttributeString("lookupName", element.LookupName.ToString());
s.WriteEndElement();
}
s.WriteEndElement();
}
s.WriteEndElement();
}
///-------------------------------------------------------------------------------------------------
/// <summary> Halo1 Scenario exporter class. </summary>
/// <param name="settings"> Export arguments for the collada interface. </param>
/// <param name="tagIndex"> The tag index containing the tag being exported. </param>
/// <param name="tagManager"> The tag manager of the tag being exported. </param>
///-------------------------------------------------------------------------------------------------
public ColladaScenarioExporter(IColladaSettings settings
, Managers.TagIndexBase tagIndex
, Managers.TagManager tagManager)
: base(settings, tagIndex)
{
mTagManager = tagManager;
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}",
Name,
Unknown8.Value.ToString("X4"), UnknownA.Value.ToString("X2"),
CategoryIndex, UnknownC, Points);
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("entry");
s.WriteAttributeString("component", Component.ToString());
s.WriteAttributeString("prop", Property.ToString());
s.WriteEndElement();
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("motl");
s.WriteAttributeString("name", tag.Name);
{
s.WriteStartElement("types");
foreach (var element in TypeList)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("weapons");
foreach (var element in WeaponsList)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("vehicles");
foreach (var element in VehiclesList)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("grenades");
foreach (var element in GrenadesList)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("equipment");
foreach (var element in EquipmentList)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("weaponSets");
foreach (var element in WeaponSets)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
s.WriteStartElement("vehicleSets");
foreach (var element in VehicleSets)
{
element.ToStream(s, tag, this);
}
s.WriteEndElement();
}
s.WriteEndElement();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}",
Name,
Unknown8.Value.ToString(), UnknownC.Value.ToString(),
Unknown10.Value.ToString("X4"), Unknown12.Value.ToString("X2"),
Unknown14.Value.ToString("X8"));
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t\t\t";
s.WriteLine(k_ident +
"Component={0}\t" + "Property={1}",
Component, Property);
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t\t\t";
var unic = owner as multilingual_unicode_string_list_group;
s.WriteLine(StringId);
s.Write(k_ident);
s.WriteLine(unic.GetStringUtf8(LanguageOffsets[(int)LanguageType.English]));
}
void UnloadForceWithDependentsRecursive(Blam.DatumIndex tag_index)
{
Managers.TagManager tagman = this[tag_index];
foreach (Blam.DatumIndex di in tagman.References)
{
UnloadWithDependentsRecursive(di);
}
UnloadForce(tag_index);
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t\t\t\t";
s.WriteLine(Name);
s.WriteLine(k_ident +
"Type={0}\t" + "Integer={1}\t" + "StringId={2}\t" + "Flags={3}\t",
Type, Integer.Value.ToString("X8"), StringId, Flags);
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t\t\t\t";
s.WriteLine(Name);
s.WriteLine(k_ident +
"Block0C={0}\t" + "Block18={1}\t" + "Block24={2}\t" +
"Block30={3}\t" + "Block3C={4}",
BlockC.Count, Block18.Count, Block24.Count,
Block30.Count, Block3C.Count);
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t\t";
s.WriteLine(Name);
for (int x = 0; x < Entries.Count; x++)
{
s.Write(k_ident);
s.Write("\t");
Entries[x].ToStream(s, tag, this);
}
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("entry");
if (!Title.Handle.IsNull)
{
s.WriteAttributeString("titleId", Title.ToString());
}
if (!Description.Handle.IsNull)
{
s.WriteAttributeString("descId", Description.ToString());
}
if (Unknown20 != 0)
{
s.WriteAttributeString("settingCategory", Unknown20.ToString());
if (!SettingCategories.ContainsKey(Unknown20.Value))
{
string title = Title.ToString();
string tagname = null;
if (!Settings.Datum.IsNull)
{
tagname = Settings.GetTagPath();
}
else if (!Template.Datum.IsNull)
{
tagname = Template.GetTagPath();
}
SettingCategories[Unknown20.Value] = new CategoryInfo(title, tagname);
}
}
if (!Settings.Datum.IsNull)
{
s.WriteElementString("settings", Settings.GetTagPath());
}
if (!Template.Datum.IsNull)
{
s.WriteElementString("template", Template.GetTagPath());
}
if (!ValuePairs.Datum.IsNull)
{
s.WriteElementString("values", ValuePairs.GetTagPath());
}
s.WriteEndElement();
}
public void ToStream(XmlWriter s,
Managers.TagManager tag, TI.Definition owner)
{
s.WriteStartElement("entry");
s.WriteAttributeString("name", Name.ToString());
if (Definition.GroupTag != TI.TagGroup.Null)
{
s.WriteAttributeString("groupTag", Definition.GroupTag.TagToString());
if (!Definition.Datum.IsNull)
{
s.WriteAttributeString("tagName", Definition.GetTagPath());
}
}
s.WriteEndElement();
}
public void ToStream(StreamWriter s,
Managers.TagManager tag, TI.Definition owner)
{
const string k_ident = "\t";
s.WriteLine(k_ident + "Effects");
for (int x = 0; x < Effects.Count; x++)
{
s.Write(k_ident + "\t");
s.Write(x.ToString("X4"));
s.Write("\t");
Effects[x].ToStream(s, tag, this);
}
s.WriteLine();
}
