private bool plugin_GetPath(TagFourCc root, out string path)
{
//Set path
path = Path.Combine(AbideRegistry.Halo2PluginsDirectory, $"{root.FourCc.Replace('<', '_').Replace('>', '_')}.ent");
//Return
return(File.Exists(path));
}
/// <summary>
/// Attempts to remove a tag hierarchy whose root matches the specified tag.
/// </summary>
/// <param name="tagRoot">The root of the tag hierarchy to remove.</param>
/// <returns></returns>
public bool Remove(TagFourCc tagRoot)
{
//Check and remove
if (tagHierarchies.ContainsKey(tagRoot))
{
return(tagHierarchies.Remove(tagRoot));
}
return(false);
}
/// <summary>
/// Sets the index entry's internal object entry.
/// </summary>
/// <param name="tag">The tag.</param>
/// <param name="id">The tag identifier.</param>
/// <param name="size">The length of the data.</param>
/// <param name="address">The memory address of the data.</param>
public void SetObjectEntry(TagFourCc tag, TagId id, uint size, uint address)
{
objectEntry = new ObjectEntry()
{
Tag = tag,
Id = id,
Size = size,
Offset = address
};
}
public void Prepare(TagFourCc tag)
{
//Create group
ITagGroup group = TagLookup.CreateTagGroup(tag);
if (group != null)
{
Prepare(group); //Prepare
}
}
/// <summary>
/// Determines if this <see cref="IFileEditor"/> is valid for a specified file.
/// </summary>
/// <param name="path">The path of the file name.</param>
/// <returns>your mum lul</returns>
public override bool IsValidEditor(string path)
{
//Prepare
bool succeeded = true;
try
{
//Open file
using (FileStream fs = File.OpenRead(path))
{
//Check length
if (fs.Length < 6144)
{
succeeded = false;
}
//Create reader
using (BinaryReader reader = new BinaryReader(fs))
{
//Read parts of header
_ = fs.Seek(0, SeekOrigin.Begin);
TagFourCc head = reader.Read <TagFourCc>();
uint version = reader.ReadUInt32();
uint fileLength = reader.ReadUInt32();
_ = fs.Seek(720, SeekOrigin.Begin);
uint checksum = reader.ReadUInt32();
_ = fs.Seek(2044, SeekOrigin.Begin);
TagFourCc foot = reader.Read <TagFourCc>();
//Check header...
if (head != HaloTags.head || foot != HaloTags.foot)
{
succeeded = false;
}
else if (version != 8)
{
succeeded = false;
}
else if (fileLength != fs.Length)
{
succeeded = false;
}
else if (checksum != 0)
{
succeeded = false;
}
}
}
}
catch { succeeded = false; }
//Return
return(succeeded);
}
/// <summary>
/// Initializes a new <see cref="IndexEntryWrapper"/> instance.
/// </summary>
/// <param name="mapFile">The map file that contains this entry.</param>
/// <param name="root">The root of the entry.</param>
/// <param name="filename">The filename of the entry.</param>
/// <param name="id">The ID of the entry.</param>
/// <param name="tagData">The Tag data stream of the entry.</param>
/// <param name="offset">The offset of the entry.</param>
/// <param name="size">The size of the entry.</param>
private IndexEntryWrapper(MapFile mapFile, TagFourCc root, string filename, TagId id, VirtualStream tagData, uint offset, uint size)
{
//Setup
this.mapFile = mapFile;
this.root = root;
this.filename = filename;
this.id = id;
this.tagData = tagData;
this.offset = offset;
this.size = size;
}
private void Xbox_ConnectionStateChanged(object sender, EventArgs e)
{
if (Xbox.Connected)
{
_ = Xbox.MemoryStream.Seek(0x80061000, SeekOrigin.Begin);
Reader = new BinaryReader(Xbox.MemoryStream);
Writer = new BinaryWriter(Xbox.MemoryStream);
uint objectsOffset = Reader.ReadUInt32();
TagId scenarioId = Reader.ReadTagId();
uint unknown = Reader.ReadUInt32();
int objectCount = Reader.ReadInt32();
TagFourCc tags = Reader.ReadTag();
Tags.Clear();
_ = Xbox.MemoryStream.Seek(objectsOffset, SeekOrigin.Begin);
using (VirtualStream stream = new VirtualStream(objectsOffset, Reader.ReadBytes(32 * objectCount)))
{
BinaryReader reader = new BinaryReader(stream);
for (int i = 0; i < objectCount; i++)
{
TagFourCc root = reader.ReadTag();
TagFourCc parent = reader.ReadTag();
TagFourCc @class = reader.ReadTag();
TagId id = reader.ReadTagId();
uint tagNameAddress = reader.ReadUInt32();
uint tagDataAddress = reader.ReadUInt32();
uint size = reader.ReadUInt32();
Tags.Add(new Tag()
{
Root = root,
Parent = parent,
Class = @class,
Id = id,
TagNameAddress = tagNameAddress,
TagDataAddress = tagDataAddress,
Length = (int)size
});
}
}
Tags.ForEach(t =>
{
Xbox.MemoryStream.Position = t.TagNameAddress;
t.TagName = Reader.ReadUTF8NullTerminated();
});
}
else
{
Reader = null;
Writer = null;
}
}
/// <summary>
/// Set's the index entry's internal object entry.
/// </summary>
/// <param name="root"></param>
/// <param name="parent"></param>
/// <param name="class"></param>
/// <param name="id"></param>
/// <param name="size"></param>
/// <param name="address"></param>
public void SetObjectEntry(TagFourCc root, TagFourCc parent, TagFourCc @class, TagId id, uint size, uint address)
{
objectEntry = new ObjectEntry()
{
Root = root,
Class = @class,
Parent = parent,
Id = id,
Size = size,
TagDataOffset = address,
FileNameOffset = Index.IndexMemoryAddress
};
}
/// <summary>
/// Gets and returns the <see cref="TagHierarchy"/> whose root is the specified <see cref="TagFourCc"/>.
/// </summary>
/// <param name="tag">The root of the <see cref="TagHierarchy"/> to get.</param>
/// <returns>A <see cref="TagHierarchy"/> structure whose <see cref="TagHierarchy.Root"/> value is the specified <see cref="TagFourCc"/> value.</returns>
/// <exception cref="ArgumentException">Occurs when the specified tag root is not found.</exception>
public TagHierarchy this[TagFourCc tag]
{
get
{
if (tagHierarchies.ContainsKey(tag))
{
return(tagHierarchies[tag]);
}
else
{
throw new ArgumentException("Unable to find tag hierarchy for the supplied tag.", "tag");
}
}
}
public override bool IsValidEditor(string path)
{
try
{
using (FileStream fs = File.OpenRead(path))
{
if (fs.Length < 6144)
{
return false;
}
using (BinaryReader reader = new BinaryReader(fs))
{
_ = fs.Seek(0, SeekOrigin.Begin);
TagFourCc head = reader.Read<TagFourCc>();
uint version = reader.ReadUInt32();
uint fileLength = reader.ReadUInt32();
_ = fs.Seek(720, SeekOrigin.Begin);
uint checksum = reader.ReadUInt32();
_ = fs.Seek(2044, SeekOrigin.Begin);
TagFourCc foot = reader.Read<TagFourCc>();
if (head != HaloTags.head || foot != HaloTags.foot)
{
return false;
}
else if (version != 8)
{
return false;
}
else if (fileLength != fs.Length)
{
return false;
}
else if (checksum == 0)
{
return false;
}
return true;
}
}
}
catch { }
return false;
}
/// <summary>
/// Initializes a new instance of the <see cref="TagGroupDefinition"/> class using the supplied guerilla reader.
/// </summary>
/// <param name="reader">The guerilla binary reader.</param>
internal TagGroupDefinition(H2Guerilla.GuerillaBinaryReader reader) : this()
{
//Read tag group
H2Guerilla.TagGroup tagGroup = reader.ReadTagGroup();
//Setup
flags = tagGroup.Flags;
groupTag = tagGroup.GroupTag;
parentGroupTag = tagGroup.ParentGroupTag;
version = tagGroup.Version;
initialized = tagGroup.Initialized;
definitionAddress = tagGroup.DefinitionAddress;
childGroupTags = tagGroup.ChildGroupTags;
childsCount = tagGroup.ChildsCount;
defaultTagPath = reader.ReadLocalizedString(tagGroup.DefaultTagPathAddress);
name = reader.ReadLocalizedString(tagGroup.NameAddress);
}
/// <summary>
/// Reads this field using the supplied guerilla binary reader.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void Read(GuerillaBinaryReader reader)
{
//Read
base.Read(reader);
//Goto
reader.BaseStream.Seek(DefinitionAddress - Guerilla.BaseAddress, System.IO.SeekOrigin.Begin);
//Read fields
nameAddress = reader.ReadInt32();
groupTag = reader.ReadTag();
int displayNameAddress = reader.ReadInt32();
blockDefinitionAddress = reader.ReadInt32();
//Read strings
name = reader.ReadLocalizedString(nameAddress);
displayName = reader.ReadLocalizedString(displayNameAddress);
}
private void valueTextBox_TextChanged(object sender, EventArgs e)
{
switch (Field.Type)
{
case FieldType.FieldCharInteger:
byte value8 = 0;
try { value8 = byte.Parse(valueTextBox.Text); } catch { }
Field.Value = value8;
break;
case FieldType.FieldShortInteger:
short value16 = 0;
try { value16 = short.Parse(valueTextBox.Text); } catch { }
Field.Value = value16;
break;
case FieldType.FieldLongInteger:
int value32 = 0;
try { value32 = int.Parse(valueTextBox.Text); } catch { }
Field.Value = value32;
break;
case FieldType.FieldAngle:
float angle = 0;
try { angle = float.Parse(valueTextBox.Text); } catch { }
Field.Value = angle;
break;
case FieldType.FieldTag:
TagFourCc tag = "\0\0\0\0";
try { tag = valueTextBox.Text; } catch { }
Field.Value = tag;
break;
case FieldType.FieldReal:
case FieldType.FieldRealFraction:
float real = 0;
try { real = float.Parse(valueTextBox.Text); } catch { }
Field.Value = real;
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AbideTagGroupCodeCompileUnit"/> class.
/// </summary>
/// <param name="tagGroup">The tag group definition.</param>
/// <param name="namespaceString">The optional namespace string. This defaults to "Cache".</param>
/// <param name="tagNamespace"></param>
public AbideTagGroupCodeCompileUnit(AbideTagGroup tagGroup, string namespaceString = "Cache", string tagNamespace = "Abide.Tag", TypeAttributes typeAttributes = TypeAttributes.Public)
{
//Prepare
string blockTypeName = AbideCodeDomGlobals.GetMemberName(AbideCodeDomGlobals.GetTagBlock(tagGroup.BlockName));
string groupTypeName = AbideCodeDomGlobals.GetMemberName(tagGroup);
//Create namespace
CodeNamespace generatedCodeNamespace = new CodeNamespace($"{namespaceString}.Generated");
//Add imports
generatedCodeNamespace.Imports.Add(new CodeNamespaceImport(AbideCodeDomGlobals.SystemNamespace));
generatedCodeNamespace.Imports.Add(new CodeNamespaceImport(AbideCodeDomGlobals.HaloLibraryNamespace));
generatedCodeNamespace.Imports.Add(new CodeNamespaceImport(tagNamespace));
//Create type
tagGroupCodeTypeDeclaration = new CodeTypeDeclaration(groupTypeName)
{
TypeAttributes = typeAttributes,
IsClass = true
};
tagGroupCodeTypeDeclaration.BaseTypes.Add(nameof(Group));
tagGroupCodeTypeDeclaration.Comments.Add(new CodeCommentStatement("<summary>", true));
tagGroupCodeTypeDeclaration.Comments.Add(new CodeCommentStatement($"Represents the generated {tagGroup.Name} " +
$"({tagGroup.GroupTag.FourCc.Replace("<", "<").Replace(">", ">")}) tag group.", true));
tagGroupCodeTypeDeclaration.Comments.Add(new CodeCommentStatement("</summary>", true));
//Name property
CodeMemberProperty nameMemberProperty = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Override,
Name = nameof(Group.Name),
Type = new CodeTypeReference(typeof(string))
};
nameMemberProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(tagGroup.Name)));
nameMemberProperty.Comments.Add(new CodeCommentStatement("<summary>", true));
nameMemberProperty.Comments.Add(new CodeCommentStatement($"Gets and returns the name of the {tagGroup.Name} tag group.", true));
nameMemberProperty.Comments.Add(new CodeCommentStatement("</summary>", true));
tagGroupCodeTypeDeclaration.Members.Add(nameMemberProperty);
//GroupTag property
CodeMemberProperty groupTagMemberProperty = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Override,
Name = nameof(Group.Tag),
Type = new CodeTypeReference(nameof(TagFourCc))
};
groupTagMemberProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(tagGroup.GroupTag.FourCc)));
groupTagMemberProperty.Comments.Add(new CodeCommentStatement("<summary>", true));
groupTagMemberProperty.Comments.Add(new CodeCommentStatement($"Gets and returns the group tag of the {tagGroup.Name} tag group.", true));
groupTagMemberProperty.Comments.Add(new CodeCommentStatement("</summary>", true));
tagGroupCodeTypeDeclaration.Members.Add(groupTagMemberProperty);
//Constructor
CodeConstructor constructor = new CodeConstructor()
{
Attributes = MemberAttributes.Public,
};
constructor.Comments.Add(new CodeCommentStatement("<summary>", true));
constructor.Comments.Add(new CodeCommentStatement($"Initializes a new instance of the <see cref=\"{groupTypeName}\"/> class.", true));
constructor.Comments.Add(new CodeCommentStatement("</summary>", true));
tagGroupCodeTypeDeclaration.Members.Add(constructor);
//Initialize Blocks
int index = 0;
TagFourCc parent = tagGroup.ParentGroupTag;
while (parent.Dword != 0)
{
//Get Parent
var parentGroup = AbideCodeDomGlobals.GetTagGroup(parent);
//Add Block
constructor.Statements.Insert(0, new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), nameof(Group.TagBlocks)), nameof(List <Block> .Add)), new CodeObjectCreateExpression(
new CodeTypeReference(AbideCodeDomGlobals.GetMemberName(AbideCodeDomGlobals.GetTagBlock(parentGroup.BlockName)))))));
constructor.Statements.Insert(0, new CodeCommentStatement($"Add parent {parentGroup.Name} tag block to list."));
CreateBlockProperty(index++, AbideCodeDomGlobals.GetTagBlock(parentGroup.BlockName));
//Get parent's parent group
parent = parentGroup.ParentGroupTag;
}
//Add Block
constructor.Statements.Add(new CodeCommentStatement($"Add tag block to list."));
constructor.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), nameof(Group.TagBlocks)), nameof(List <ITagBlock> .Add)), new CodeObjectCreateExpression(
new CodeTypeReference(AbideCodeDomGlobals.GetMemberName(AbideCodeDomGlobals.GetTagBlock(tagGroup.BlockName))))));
//Add type to namespace
generatedCodeNamespace.Types.Add(tagGroupCodeTypeDeclaration);
//Add namespace
Namespaces.Add(generatedCodeNamespace);
}
private void Click(object obj)
{
List <string> strings = new List <string>();
List <TagReference> tags = new List <TagReference>();
List <IndexEntry> entries = new List <IndexEntry>();
TagId currentId = TagId.Null;
var openDlg = new OpenFileDialog()
{
Filter = "XML Files (*.xml)|*.xml"
};
if (openDlg.ShowDialog() ?? false)
{
XmlDocument document = new XmlDocument();
document.Load(openDlg.FileName);
var tagsRoot = Path.GetDirectoryName(openDlg.FileName);
var manifest = document["AbideTagManifest"];
var tagNameManifest = manifest["TagNames"];
foreach (XmlNode node in tagNameManifest)
{
var tagName = node.Attributes["Name"].InnerText;
var groupTag = new TagFourCc(node.Attributes["GroupTag"].InnerText);
tags.Add(new TagReference()
{
TagName = tagName,
GroupTag = groupTag
});
}
var globals = Map.GetTagById(Map.GlobalsTagId);
using (var tagData = Map.ReadTagData(globals))
{
_ = tagData.Stream.Seek(globals.MemoryAddress, SeekOrigin.Begin);
var globalsTagGroup = TagLookup.CreateTagGroup(globals.Tag);
globalsTagGroup.Read(tagData.Stream.CreateReader());
var soundGlobals = (BlockField)globalsTagGroup.TagBlocks[0].Fields[4];
if (soundGlobals.BlockList.Count == 1)
{
var soundGlobalsBlock = soundGlobals.BlockList[0];
currentId = (TagId)soundGlobalsBlock.Fields[4].Value;
}
}
using (var map = new HaloMap(Map.FileName))
{
var soundCacheFileGestaltEntry = map.IndexEntries[currentId];
foreach (var tag in tags)
{
if (map.IndexEntries.Any(e => e.Filename == tag.TagName && e.Root == tag.GroupTag))
{
tag.Id = map.IndexEntries.First(e => e.Filename == tag.TagName && e.Root == tag.GroupTag).Id;
}
else
{
var tagGroup = TagLookup.CreateTagGroup(tag.GroupTag);
tag.FileName = Path.Combine(tagsRoot, $"{tag.TagName}.{tagGroup.Name}");
var tagGroupFile = new AbideTagGroupFile();
tagGroupFile.Load(tag.FileName);
var entry = new IndexEntry()
{
Filename = tag.TagName,
Id = currentId++,
Tag = map.Tags.First(t => t.Root == tag.GroupTag),
};
entries.Add(entry);
tag.TagGroup = tagGroupFile.TagGroup;
tag.Id = entry.Id;
foreach (var offset in tagGroupFile.GetResourceAddresses())
{
var resource = tagGroupFile.GetResource(offset);
_ = entry.Resources.AddResource((int)offset, resource);
}
}
}
soundCacheFileGestaltEntry.Id = currentId;
int insertionIndex = map.IndexEntries.IndexOf(e => e == soundCacheFileGestaltEntry);
foreach (var tag in tags.Where(t => File.Exists(t.FileName)))
{
ConvertToCache(tag.TagGroup, map, tags);
var entry = entries.First(e => e.Id == tag.Id);
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
tag.TagGroup.Write(writer);
entry.Data.SetBuffer(stream.ToArray());
_ = map.IndexEntries.Insert(insertionIndex, entry);
}
}
map.Save(Path.Combine(tagsRoot, $"{map.Name}.map"));
}
}
}
/// <summary>
/// Returns a <see cref="Group"/> instance based on the supplied tag.
/// </summary>
/// <param name="groupTag">The group tag.</param>
public static Group CreateTagGroup(TagFourCc groupTag)
{
// ai_dialogue_globals
if ((groupTag == "adlg"))
{
return(new AiDialogueGlobals());
}
// ai_mission_dialogue
if ((groupTag == "mdlg"))
{
return(new AiMissionDialogue());
}
// antenna
if ((groupTag == "ant!"))
{
return(new Antenna());
}
// biped
if ((groupTag == "bipd"))
{
return(new Biped());
}
// bitmap
if ((groupTag == "bitm"))
{
return(new Bitmap());
}
// breakable_surface
if ((groupTag == "bsdt"))
{
return(new BreakableSurface());
}
// cache_file_sound
if ((groupTag == "$#!+"))
{
return(new CacheFileSound());
}
// camera_track
if ((groupTag == "trak"))
{
return(new CameraTrack());
}
// cellular_automata
if ((groupTag == "devo"))
{
return(new CellularAutomata());
}
// cellular_automata2d
if ((groupTag == "whip"))
{
return(new CellularAutomata2d());
}
// character
if ((groupTag == "char"))
{
return(new Character());
}
// chocolate_mountain
if ((groupTag == "gldf"))
{
return(new ChocolateMountain());
}
// cloth
if ((groupTag == "clwd"))
{
return(new Cloth());
}
// collision_model
if ((groupTag == "coll"))
{
return(new CollisionModel());
}
// colony
if ((groupTag == "coln"))
{
return(new Colony());
}
// color_table
if ((groupTag == "colo"))
{
return(new ColorTable());
}
// contrail
if ((groupTag == "cont"))
{
return(new Contrail());
}
// crate
if ((groupTag == "bloc"))
{
return(new Crate());
}
// creature
if ((groupTag == "crea"))
{
return(new Creature());
}
// damage_effect
if ((groupTag == "jpt!"))
{
return(new DamageEffect());
}
// decal
if ((groupTag == "deca"))
{
return(new Decal());
}
// decorators
if ((groupTag == "DECP"))
{
return(new Decorators());
}
// decorator_set
if ((groupTag == "DECR"))
{
return(new DecoratorSet());
}
// detail_object_collection
if ((groupTag == "dobc"))
{
return(new DetailObjectCollection());
}
// device
if ((groupTag == "devi"))
{
return(new Device());
}
// device_control
if ((groupTag == "ctrl"))
{
return(new DeviceControl());
}
// device_light_fixture
if ((groupTag == "lifi"))
{
return(new DeviceLightFixture());
}
// device_machine
if ((groupTag == "mach"))
{
return(new DeviceMachine());
}
// dialogue
if ((groupTag == "udlg"))
{
return(new Dialogue());
}
// effect
if ((groupTag == "effe"))
{
return(new Effect());
}
// equipment
if ((groupTag == "eqip"))
{
return(new Equipment());
}
// garbage
if ((groupTag == "garb"))
{
return(new Garbage());
}
// globals
if ((groupTag == "matg"))
{
return(new Globals());
}
// grenade_hud_interface
if ((groupTag == "grhi"))
{
return(new GrenadeHudInterface());
}
// hud_globals
if ((groupTag == "hudg"))
{
return(new HudGlobals());
}
// hud_message_text
if ((groupTag == "hmt "))
{
return(new HudMessageText());
}
// hud_number
if ((groupTag == "hud#"))
{
return(new HudNumber());
}
// item
if ((groupTag == "item"))
{
return(new Item());
}
// item_collection
if ((groupTag == "itmc"))
{
return(new ItemCollection());
}
// lens_flare
if ((groupTag == "lens"))
{
return(new LensFlare());
}
// light
if ((groupTag == "ligh"))
{
return(new Light());
}
// light_volume
if ((groupTag == "MGS2"))
{
return(new LightVolume());
}
// liquid
if ((groupTag == "tdtl"))
{
return(new Liquid());
}
// material_effects
if ((groupTag == "foot"))
{
return(new MaterialEffects());
}
// material_physics
if ((groupTag == "mpdt"))
{
return(new MaterialPhysics());
}
// meter
if ((groupTag == "metr"))
{
return(new Meter());
}
// model
if ((groupTag == "hlmt"))
{
return(new Model());
}
// model_animation_graph
if ((groupTag == "jmad"))
{
return(new ModelAnimationGraph());
}
// mouse_cursor_definition
if ((groupTag == "mcsr"))
{
return(new MouseCursorDefinition());
}
// multilingual_unicode_string_list
if ((groupTag == "unic"))
{
return(new MultilingualUnicodeStringList());
}
// multiplayer_globals
if ((groupTag == "mulg"))
{
return(new MultiplayerGlobals());
}
// multiplayer_scenario_description
if ((groupTag == "mply"))
{
return(new MultiplayerScenarioDescription());
}
// multiplayer_variant_settings_interface_definition
if ((groupTag == "goof"))
{
return(new MultiplayerVariantSettingsInterfaceDefinition());
}
// new_hud_definition
if ((groupTag == "nhdt"))
{
return(new NewHudDefinition());
}
// object
if ((groupTag == "obje"))
{
return(new Object());
}
// particle
if ((groupTag == "prt3"))
{
return(new Particle());
}
// particle_model
if ((groupTag == "PRTM"))
{
return(new ParticleModel());
}
// particle_physics
if ((groupTag == "pmov"))
{
return(new ParticlePhysics());
}
// patchy_fog
if ((groupTag == "fpch"))
{
return(new PatchyFog());
}
// physics
if ((groupTag == "phys"))
{
return(new Physics());
}
// physics_model
if ((groupTag == "phmo"))
{
return(new PhysicsModel());
}
// pixel_shader
if ((groupTag == "pixl"))
{
return(new PixelShader());
}
// planar_fog
if ((groupTag == "fog "))
{
return(new PlanarFog());
}
// point_physics
if ((groupTag == "pphy"))
{
return(new PointPhysics());
}
// projectile
if ((groupTag == "proj"))
{
return(new Projectile());
}
// render_model
if ((groupTag == "mode"))
{
return(new RenderModel());
}
// scenario
if ((groupTag == "scnr"))
{
return(new Scenario());
}
// scenario_ai_resource
if ((groupTag == "ai**"))
{
return(new ScenarioAiResource());
}
// scenario_bipeds_resource
if ((groupTag == "*ipd"))
{
return(new ScenarioBipedsResource());
}
// scenario_cinematics_resource
if ((groupTag == "cin*"))
{
return(new ScenarioCinematicsResource());
}
// scenario_cluster_data_resource
if ((groupTag == "clu*"))
{
return(new ScenarioClusterDataResource());
}
// scenario_comments_resource
if ((groupTag == "/**/"))
{
return(new ScenarioCommentsResource());
}
// scenario_creature_resource
if ((groupTag == "*rea"))
{
return(new ScenarioCreatureResource());
}
// scenario_decals_resource
if ((groupTag == "dec*"))
{
return(new ScenarioDecalsResource());
}
// scenario_decorators_resource
if ((groupTag == "dc*s"))
{
return(new ScenarioDecoratorsResource());
}
// scenario_devices_resource
if ((groupTag == "dgr*"))
{
return(new ScenarioDevicesResource());
}
// scenario_equipment_resource
if ((groupTag == "*qip"))
{
return(new ScenarioEquipmentResource());
}
// scenario_hs_source_file
if ((groupTag == "hsc*"))
{
return(new ScenarioHsSourceFile());
}
// scenario_lights_resource
if ((groupTag == "*igh"))
{
return(new ScenarioLightsResource());
}
// scenario_scenery_resource
if ((groupTag == "*cen"))
{
return(new ScenarioSceneryResource());
}
// scenario_sound_scenery_resource
if ((groupTag == "*sce"))
{
return(new ScenarioSoundSceneryResource());
}
// scenario_structure_bsp
if ((groupTag == "sbsp"))
{
return(new ScenarioStructureBsp());
}
// scenario_structure_lighting_resource
if ((groupTag == "sslt"))
{
return(new ScenarioStructureLightingResource());
}
// scenario_structure_lightmap
if ((groupTag == "ltmp"))
{
return(new ScenarioStructureLightmap());
}
// scenario_trigger_volumes_resource
if ((groupTag == "trg*"))
{
return(new ScenarioTriggerVolumesResource());
}
// scenario_vehicles_resource
if ((groupTag == "*ehi"))
{
return(new ScenarioVehiclesResource());
}
// scenario_weapons_resource
if ((groupTag == "*eap"))
{
return(new ScenarioWeaponsResource());
}
// scenery
if ((groupTag == "scen"))
{
return(new Scenery());
}
// screen_effect
if ((groupTag == "egor"))
{
return(new ScreenEffect());
}
// shader
if ((groupTag == "shad"))
{
return(new Shader());
}
// shader_light_response
if ((groupTag == "slit"))
{
return(new ShaderLightResponse());
}
// shader_pass
if ((groupTag == "spas"))
{
return(new ShaderPass());
}
// shader_template
if ((groupTag == "stem"))
{
return(new ShaderTemplate());
}
// sky
if ((groupTag == "sky "))
{
return(new Sky());
}
// sound
if ((groupTag == "snd!"))
{
return(new Sound());
}
// sound_cache_file_gestalt
if ((groupTag == "ugh!"))
{
return(new SoundCacheFileGestalt());
}
// sound_classes
if ((groupTag == "sncl"))
{
return(new SoundClasses());
}
// sound_dialogue_constants
if ((groupTag == "spk!"))
{
return(new SoundDialogueConstants());
}
// sound_effect_collection
if ((groupTag == "sfx+"))
{
return(new SoundEffectCollection());
}
// sound_effect_template
if ((groupTag == "<fx>"))
{
return(new SoundEffectTemplate());
}
// sound_environment
if ((groupTag == "snde"))
{
return(new SoundEnvironment());
}
// sound_looping
if ((groupTag == "lsnd"))
{
return(new SoundLooping());
}
// sound_mix
if ((groupTag == "snmx"))
{
return(new SoundMix());
}
// sound_scenery
if ((groupTag == "ssce"))
{
return(new SoundScenery());
}
// stereo_system
if ((groupTag == "BooM"))
{
return(new StereoSystem());
}
// style
if ((groupTag == "styl"))
{
return(new Style());
}
// text_value_pair_definition
if ((groupTag == "sily"))
{
return(new TextValuePairDefinition());
}
// unit
if ((groupTag == "unit"))
{
return(new Unit());
}
// unit_hud_interface
if ((groupTag == "unhi"))
{
return(new UnitHudInterface());
}
// user_interface_globals_definition
if ((groupTag == "wgtz"))
{
return(new UserInterfaceGlobalsDefinition());
}
// user_interface_list_skin_definition
if ((groupTag == "skin"))
{
return(new UserInterfaceListSkinDefinition());
}
// user_interface_screen_widget_definition
if ((groupTag == "wgit"))
{
return(new UserInterfaceScreenWidgetDefinition());
}
// user_interface_shared_globals_definition
if ((groupTag == "wigl"))
{
return(new UserInterfaceSharedGlobalsDefinition());
}
// vehicle
if ((groupTag == "vehi"))
{
return(new Vehicle());
}
// vehicle_collection
if ((groupTag == "vehc"))
{
return(new VehicleCollection());
}
// vertex_shader
if ((groupTag == "vrtx"))
{
return(new VertexShader());
}
// weapon
if ((groupTag == "weap"))
{
return(new Weapon());
}
// weapon_hud_interface
if ((groupTag == "wphi"))
{
return(new WeaponHudInterface());
}
// weather_system
if ((groupTag == "weat"))
{
return(new WeatherSystem());
}
// wind
if ((groupTag == "wind"))
{
return(new Wind());
}
return(null);
}
public TagResourceInfo(string fileName, TagFourCc root, TagId id)
{
TagPath = fileName;
Root = root;
Id = id;
}
/// <summary>
/// Checks if the list contains an tag hierarchy whose root matches the specified tag.
/// </summary>
/// <param name="tag">The ID to check.</param>
/// <returns>True if the list contains an tag hierarchy whose root matches the supplied tag, false if not.</returns>
public bool ContainsTag(TagFourCc tag)
{
return(tagHierarchies.ContainsKey(tag));
}
/// <summary>
/// Creates a map of data objects.
/// </summary>
/// <param name="document">The IFP document.</param>
/// <param name="entry">The index entry.</param>
public void Layout(IfpDocument document, IndexEntry entry)
{
//Clear
objects.Clear();
objectLookup.Clear();
//Set
root = document.Plugin.Class;
//Loop
int index = 0;
foreach (IfpNode node in document.Plugin.Nodes)
{
//Prepare
DataObject childObject = null;
//Handle type
switch (node.Type)
{
case IfpNodeType.TagBlock:
case IfpNodeType.Byte:
case IfpNodeType.SignedByte:
case IfpNodeType.Short:
case IfpNodeType.UnsignedShort:
case IfpNodeType.Int:
case IfpNodeType.UnsignedInt:
case IfpNodeType.Long:
case IfpNodeType.UnsignedLong:
case IfpNodeType.Single:
case IfpNodeType.Double:
case IfpNodeType.Enumerator8:
case IfpNodeType.Enumerator16:
case IfpNodeType.Enumerator32:
case IfpNodeType.Enumerator64:
case IfpNodeType.Bitfield8:
case IfpNodeType.Bitfield16:
case IfpNodeType.Bitfield32:
case IfpNodeType.Bitfield64:
case IfpNodeType.String32:
case IfpNodeType.String64:
case IfpNodeType.Unicode128:
case IfpNodeType.Unicode256:
case IfpNodeType.Tag:
case IfpNodeType.TagId:
case IfpNodeType.StringId:
childObject = new DataObject(node, entry.TagData)
{
UniqueId = index++
};
break;
}
//Check
if (childObject != null)
{
//Add
objects.Add(childObject);
objectLookup.Add(childObject.UniqueId, childObject);
//Layout Child
if (childObject.Node.Type == IfpNodeType.TagBlock)
{
Layout(childObject, ref index);
}
}
}
}
public TagReferenceField(string name, int groupTag = 0) : base(FieldType.FieldTagReference, name)
{
GroupTag = new TagFourCc(groupTag);
Value = string.Empty;
}
public TagReferenceField(string name, string groupTag) : base(FieldType.FieldTagReference, name)
{
GroupTag = groupTag;
}
