/// <summary>
/// The h 2 parsed prtm.
/// </summary>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public void H2ParsedPRTM(ref Meta meta)
{
string[] temps = meta.name.Split('\\');
name = temps[temps.Length - 1];
BoundingBox = new BoundingBoxContainer();
BinaryReader BR = new BinaryReader(meta.MS);
RawDataMetaChunks = new RawDataMetaChunk[1];
RawDataMetaChunks[0] = new PRTMRawDataMetaChunk(ref meta);
BR.BaseStream.Position = 28;
int tempshad = BR.ReadInt32();
int shadid = meta.Map.Functions.ForMeta.FindMetaByID(tempshad);
Shaders = new ShaderContainer();
Shaders.Shader = new ShaderInfo[1];
Shaders.Shader[0] = new ShaderInfo(shadid, meta.Map);
// LOD = new LODInfo(ref meta, meta.Map, ref RawDataMetaChunks);
Display = new DisplayedInfo();
Display.Chunk.Add(0);
Display.ShaderIndex = new int[1];
Display.ShaderIndex[0] = 0;
// MessageBox.Show("test");
}
public Enums(Meta meta, string iEntName, Map map, int iOffsetInChunk, int iType, object[] ioptions, int iLineNumber)
{
this.meta = meta;
this.LineNumber = iLineNumber;
this.Options = ioptions;
this.enumType = iType;
this.size = iType / 8;
this.chunkOffset = iOffsetInChunk;
this.map = map;
this.EntName = iEntName;
InitializeComponent();
this.Size = this.PreferredSize;
this.Dock = DockStyle.Top;
this.Controls[0].Text = EntName;
switch (iType)
{
case 8:
{
this.Controls[2].Text = "Enum8";
break;
}
case 16:
{
this.Controls[2].Text = "Enum16";
break;
}
case 32:
{
this.Controls[2].Text = "Enum32";
break;
}
}
this.AutoSize = false;
}
public DataValues(Meta meta, string iEntName, Map map, int iOffsetInChunk, IFPIO.ObjectEnum type, int iLineNumber)
{
this.meta = meta;
this.LineNumber = iLineNumber;
this.chunkOffset = iOffsetInChunk;
this.map = map;
this.EntName = iEntName;
InitializeComponent();
this.Dock = DockStyle.Top;
this.Controls[0].Text = EntName;
this.Controls[2].Text = type.ToString();
this.ValueType = type;
switch (this.ValueType)
{
case IFPIO.ObjectEnum.Byte:
this.size = 1;
break;
case IFPIO.ObjectEnum.Short:
case IFPIO.ObjectEnum.UShort:
this.size = 2;
break;
case IFPIO.ObjectEnum.Int:
case IFPIO.ObjectEnum.UInt:
case IFPIO.ObjectEnum.Float:
case IFPIO.ObjectEnum.Unknown:
this.size = 4;
break;
case IFPIO.ObjectEnum.Unused:
this.size = 0;
break;
}
this.AutoSize = false;
}
public MetaEditorControlPage(Meta meta, MapForms.MapForm mapForm)
{
InitializeComponent();
// Try to draw treeview nodes to "hide" "disabled" nodes; fail. Still leaves space where node is
//treeViewTagReflexives.DrawMode = TreeViewDrawMode.OwnerDrawAll;
//treeViewTagReflexives.DrawNode += new DrawTreeNodeEventHandler(myTreeView_DrawNode);
this.MapForm = mapForm;
this.map = mapForm.map;
this.meta = meta;
this.BR = new BinaryReader(meta.MS);
// Create a backup of the Tags memory stream, for restoring, comparing, etc
msBackup = new MemoryStream(meta.MS.ToArray());
msDebug = new MemoryStream((int)meta.MS.Length);
mainReflexive = createReflexiveList(); // Done
refreshTreeListing(mainReflexive); // Done
this.treeViewTagReflexives.Sort();
treeViewTagReflexives.SelectedNode = treeViewTagReflexives.Nodes[0];
// Default Peek/Poke to "Single Value"
this.tscbApplyTo.SelectedIndex = 0;
}
/// <summary>
/// Creates a color wheel with associated (A)RGB text boxes
/// </summary>
/// <param name="meta"></param>
/// <param name="iEntName">Control display name</param>
/// <param name="map"></param>
/// <param name="iOffsetInChunk"></param>
/// <param name="hasAlphaChannel">True if ARGB, False for RGB</param>
/// <param name="valueType">Float for 0f-1f, Int for 0-255</param>
/// <param name="iLineNumber"></param>
public argb_color(Meta meta, string iEntName, Map map, int iOffsetInChunk, bool hasAlphaChannel, IFPIO.ObjectEnum valueType,int iLineNumber)
{
InitializeComponent();
this.meta = meta;
this.LineNumber = iLineNumber;
this.chunkOffset = iOffsetInChunk;
this.map = map;
this.EntName = " " + iEntName + " ";
this.Dock = DockStyle.Top;
this.Controls[0].Text = EntName;
this.hasAlpha = hasAlphaChannel;
this.ValueType = valueType;
switch (valueType)
{
case IFPIO.ObjectEnum.Byte:
this.eachSize = 1;
break;
case IFPIO.ObjectEnum.Short:
case IFPIO.ObjectEnum.UShort:
this.eachSize = 2;
break;
case IFPIO.ObjectEnum.Int:
case IFPIO.ObjectEnum.UInt:
case IFPIO.ObjectEnum.Float:
case IFPIO.ObjectEnum.Unknown:
this.eachSize = 4;
break;
}
this.size = (hasAlpha ? eachSize * 4 : eachSize * 3);
CW = new ColorWheel();
CW.Location = new Point(180, 5);
Red = new DataValues(meta, "Red", map, iOffsetInChunk, valueType, iLineNumber);
Red.BackColor = System.Drawing.Color.DarkRed;
CW.setTextBox(Red.textBox1, Color.Red);
Blue = new DataValues(meta, "Blue", map, iOffsetInChunk + eachSize, valueType, iLineNumber);
Blue.BackColor = System.Drawing.Color.DarkBlue;
CW.setTextBox(Blue.textBox1, Color.Blue);
Green = new DataValues(meta, "Green", map, iOffsetInChunk + eachSize * 2, valueType, iLineNumber);
Green.BackColor = System.Drawing.Color.FromArgb(10, 80, 35);
CW.setTextBox(Green.textBox1, Color.Green);
if (hasAlpha)
{
Alpha = new DataValues(meta, "Alpha", map, iOffsetInChunk + eachSize * 3, valueType, iLineNumber);
Alpha.BackColor = System.Drawing.Color.Gray;
CW.setTextBox(Alpha.textBox1, Color.White);
gbRGBColor.Controls.Add(Alpha);
}
gbRGBColor.Controls.Add(CW);
CW.BringToFront();
gbRGBColor.Controls.Add(Green);
gbRGBColor.Controls.Add(Blue);
gbRGBColor.Controls.Add(Red);
}
/// <summary>
/// The get frames from halo 2 model.
/// </summary>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public void GetFramesFromHalo2Model(ref Meta meta)
{
BinaryReader BR = new BinaryReader(meta.MS);
BR.BaseStream.Position = 72;
int tempc = BR.ReadInt32();
int tempr = BR.ReadInt32() - meta.magic - meta.offset;
for (int x = 0; x < tempc; x++)
{
FrameInfo f = new FrameInfo();
BR.BaseStream.Position = tempr + (96 * x);
f.Name = meta.Map.Strings.Name[BR.ReadUInt16()];
BR.ReadUInt16();
f.Parent = BR.ReadInt16();
f.Child = BR.ReadInt16();
f.Sibling = BR.ReadInt16();
BR.BaseStream.Position = tempr + (96 * x) + 12;
f.x = BR.ReadSingle();
f.y = BR.ReadSingle();
f.z = BR.ReadSingle();
f.i = BR.ReadSingle();
f.j = BR.ReadSingle();
f.k = BR.ReadSingle();
f.w = BR.ReadSingle();
f.matrix = Matrix.Identity;
Quaternion q = new Quaternion(f.i, f.j, f.k, f.w);
f.matrix.Multiply(Matrix.Translation(f.x, f.y, f.z));
f.matrix.RotateQuaternion(q);
BR.ReadSingle();
f.skinweightmatrix = Matrix.Identity;
f.skinweightmatrix.M11 = BR.ReadSingle();
f.skinweightmatrix.M12 = BR.ReadSingle();
f.skinweightmatrix.M13 = BR.ReadSingle();
f.skinweightmatrix.M14 = 0.0f;
f.skinweightmatrix.M21 = BR.ReadSingle();
f.skinweightmatrix.M22 = BR.ReadSingle();
f.skinweightmatrix.M23 = BR.ReadSingle();
f.skinweightmatrix.M24 = 0.0f;
f.skinweightmatrix.M31 = BR.ReadSingle();
f.skinweightmatrix.M32 = BR.ReadSingle();
f.skinweightmatrix.M33 = BR.ReadSingle();
f.skinweightmatrix.M34 = 0.0f;
f.skinweightmatrix.M41 = BR.ReadSingle();
f.skinweightmatrix.M42 = BR.ReadSingle();
f.skinweightmatrix.M43 = BR.ReadSingle();
f.skinweightmatrix.M44 = 1.0f;
f.DistanceFromParent = BR.ReadSingle();
// f.matrix.MultiplyTranspose(f.skinweightmatrix);//=Matrix.Transformation(new Vector3(0, 0, 0), new Quaternion(),new Vector3(1,1,1), new Vector3(0, 0, 0), q, new Vector3(f.x, f.y, f.z));
Frame.Add(f);
}
}
public void loadMeta(Meta meta, HaloVersionEnum HaloVersion, string FileName)
{
this.fileName = fileName;
this.HaloVersion = HaloVersion;
this.meta = meta;
loadFile();
createTreeListing();
}
/// <summary>
/// The build meta.
/// </summary>
/// <param name="metasplit">The metasplit.</param>
/// <param name="map">The map.</param>
/// <returns></returns>
/// <remarks></remarks>
public static Meta BuildMeta(MetaSplitter metasplit, Map map)
{
metasize = 0;
MetaStream = new MemoryStream(metasplit.Header.chunksize);
BinaryWriter BW = new BinaryWriter(MetaStream);
// BW.BaseStream.Position = 0;
// BW.Write(metasplit.Header.MS.ToArray(), 0, metasplit.Header.chunksize);
metasize += metasplit.Header.chunksize;
TagIndex = metasplit.TagIndex;
Meta m = new Meta(map);
List<Meta.Item> NewItems = new List<Meta.Item>();
// Major error here! Size is not calculated right!
RecursivelyAddPiecesToMeta(metasplit.Header, ref NewItems, ref BW);
m.items = NewItems;
if (MetaStream.Length % 4 != 0)
{
metasize += (int)MetaStream.Length % 4;
MetaStream.SetLength(MetaStream.Length + MetaStream.Length % 4);
}
m.MS = MetaStream;
m.size = metasize;
m.type = metasplit.type;
m.name = metasplit.name;
m.rawType = metasplit.rawtype;
m.raw = metasplit.raw;
m.magic = metasplit.magic;
m.offset = metasplit.offset;
m.TagIndex = TagIndex;
m.RelinkReferences();
m.WriteReferences();
// m.items.Clear();
// MetaScanner Ms = new MetaScanner();
if (m.rawType != RawDataContainerType.Empty)
{
map.OpenMap(MapTypes.Internal);
m.raw = map.Functions.ForMeta.ReadRaw(m.TagIndex, false);
map.CloseMap();
}
// map.OpenMap(MapTypes.Internal);
// IFPIO ifp=IFP.IFPHashMap.GetIfp(m.type);
// m.parsed = true;
// Ms.ScanWithIFP(ref ifp, ref m, map) ;
// map.CloseMap();
return m;
}
public StringBox(Meta meta, string iEntName, Map map, int iOffsetInChunk, int iLineNumber, int chunkCount)
{
this.meta = meta;
this.LineNumber = iLineNumber;
this.chunkOffset = iOffsetInChunk;
this.map = map;
this.EntName = iEntName;
this.size = chunkCount;
InitializeComponent();
this.Size = this.PreferredSize;
this.Dock = DockStyle.Top;
this.label3.Text = EntName;
this.AutoSize = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="ParsedBitmap"/> class.
/// </summary>
/// <param name="meta">The meta.</param>
/// <param name="map">The map.</param>
/// <remarks></remarks>
public ParsedBitmap(ref Meta meta, Map map)
{
BitmapHeader = new HaloBitmapHeader(ref meta);
switch (map.HaloVersion)
{
case HaloVersionEnum.Halo2:
case HaloVersionEnum.Halo2Vista:
ReadH2ParsedBitmap(ref meta);
break;
case HaloVersionEnum.HaloCE:
case HaloVersionEnum.Halo1:
ReadCEParsedBitmap(ref meta);
break;
}
}
/// <summary>
/// The add.
/// </summary>
/// <param name="tagIndex">Index of the tag.</param>
/// <param name="metasplit">The metasplit.</param>
/// <remarks></remarks>
public void Add(int tagIndex, MetaSplitter metasplit)
{
// TagIndex - Global Variable
this.TagIndex = tagIndex;
ArrayList metas = new ArrayList(0);
for (int x = 0; x < map.IndexHeader.metaCount; x++)
{
// sender.setProgressBar(x / map.IndexHeader.metaCount);
Meta m = new Meta(map);
m.ReadMetaFromMap(x, true);
// Read meta layout of TAG from .ENT file
IFPIO ifpx = IFPHashMap.GetIfp(m.type, map.HaloVersion);
m.headersize = ifpx.headerSize;
if (m.type == "sbsp")
{
}
else
{
// anything but "sbsp"
m.scanner.ScanWithIFP(ref ifpx);
// metaScanner.ScanManually(ref m, ref map);
}
metas.Add(m);
}
// sender.setProgressBar(0);
Meta targetTag = (Meta)metas[tagIndex];
Meta tempm = MetaBuilder.BuildMeta(metasplit, map); // (Meta) metas[TagIndex];
metas[tagIndex] = tempm;
// ((Meta)metas[TagIndex]).RelinkReferences(map);
SizeOfShift = tempm.size - targetTag.size;
// Map IS already open? I guess it's a safety check.
map.OpenMap(MapTypes.Internal);
FixReflexives(metas);
map.CloseMap();
}
/// <summary>
/// Creates a new EntStrings class for a set-length unicode or ASCII string.
/// </summary>
/// <param name="meta">The controls meta data</param>
/// <param name="iEntName">The identifying name of the meta string</param>
/// <param name="map">The metas map file</param>
/// <param name="iOffsetInChunk">The offset to the string in the memory stream</param>
/// <param name="ilength">The set length of the string (usually 32, 64 or 256, but will handle any length strings)</param>
/// <param name="itype">Set to false for ASCII strings, true for Unicode (UTF-8) strings</param>
/// <param name="iLineNumber">The associated line number</param>
public EntStrings(Meta meta, string iEntName, Map map, int iOffsetInChunk, int ilength, bool itype, int iLineNumber)
{
this.meta = meta;
this.LineNumber = iLineNumber;
this._entUnicode = itype;
this._length = ilength;
this.size = this._length;
this.map = map;
this.EntName = iEntName;
this.chunkOffset = iOffsetInChunk;
InitializeComponent();
this.label2.Text = EntName;
this.Dock = DockStyle.Top;
this.Size = this.PreferredSize;
this.AutoSize = false;
this.Leave += new EventHandler(String_Leave);
}
public MetaEditorControlPage(Meta meta, MapForms.MapForm mapForm)
{
InitializeComponent();
this.MapForm = mapForm;
this.map = mapForm.map;
this.meta = meta;
this.BR = new BinaryReader(meta.MS);
// Create a backup of the Tags memory stream, for restoring, comparing, etc
msBackup = new MemoryStream(meta.MS.ToArray());
msDebug = new MemoryStream((int)meta.MS.Length);
createTreeListing();
this.treeViewTagReflexives.Sort();
treeViewTagReflexives.SelectedNode = treeViewTagReflexives.Nodes[0];
}
public SID(Meta meta, string iEntName, Map map, int iOffsetInChunk,int iLineNumber)
{
this.meta = meta;
this.LineNumber = iLineNumber;
this.chunkOffset = iOffsetInChunk;
this.map = map;
this.EntName = iEntName;
this.size = 4;
InitializeComponent();
this.Size = this.PreferredSize;
this.Dock = DockStyle.Top;
this.Controls[0].Text = EntName;
this.AutoSize = false;
//this.comboBox1.DataSource = map.Strings.Name;
this.comboBox1.DataSource = null; // Loading data source takes a long time. Only do it when needed.
}
/// <summary>
/// The split with ifp.
/// </summary>
/// <param name="ifp">The ifp.</param>
/// <param name="meta">The meta.</param>
/// <param name="map">The map.</param>
/// <remarks></remarks>
public void SplitWithIFP(ref IFPIO ifp, ref Meta meta, Map map)
{
this.type = meta.type;
this.TagIndex = meta.TagIndex;
this.name = meta.name;
this.offset = meta.offset;
this.magic = meta.magic;
this.raw = meta.raw;
this.rawtype = meta.rawType;
map.OpenMap(MapTypes.Internal);
if (ifp.items != null)
{
map.BR.BaseStream.Position = meta.offset;
Header = new SplitReflexive();
Header.offset = 0;
Header.Chunks = new List<SplitReflexive>();
Header.translation = 0;
// Header.MS = new MemoryStream(ifp.headerSize);
// Header.MS.Write(map.BR.ReadBytes(ifp.headerSize), 0, ifp.headerSize);
Header.chunksize = ifp.headerSize;
Header.chunkcount = 1;
Header.splitReflexiveType = SplitReflexive.SplitReflexiveType.Container;
Header.realtranslation = meta.offset;
if (meta.type == "sbsp")
{
int p = map.BSP.FindBSPNumberByBSPIdent(meta.ident);
CycleElements(
ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.BSP.sbsp[p].magic);
}
else if (meta.type == "ltmp")
{
int p = map.BSP.FindBSPNumberByLightMapIdent(meta.ident);
CycleElements(
ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.BSP.sbsp[p].magic);
}
else
{
// not "sbsp" or "ltmp"
CycleElements(ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.SecondaryMagic);
}
}
map.CloseMap();
}
/// <summary>
/// Initializes a new instance of the <see cref="MetaItemComparer"/> class.
/// </summary>
/// <param name="currentForm">The current form.</param>
/// <remarks></remarks>
public MetaItemComparer(MapForm currentForm)
{
Map map = currentForm.map;
int counter = 0;
for (counter = 0; counter < map.MapHeader.fileCount; counter++)
{
currentForm.SetProgressBar(counter * 100 / map.MapHeader.fileCount);
ifpMeta = new Meta(map);
manualMeta = new Meta(map);
manualMeta.ReadMetaFromMap(counter, false);
ifpMeta.ReadMetaFromMap(counter, false);
// parse ifp and scan meta with it
try
{
IFPIO io = IFPHashMap.GetIfp(ifpMeta.type, map.HaloVersion);
ifpMeta.headersize = io.headerSize;
manualMeta.headersize = io.headerSize;
try
{
ifpMeta.scanner.ScanWithIFP(ref io);
}
catch (Exception ex)
{
Global.ShowErrorMsg("Broken IFP - " + ifpMeta.type, ex);
}
manualMeta.scanner.ScanManually();
check(map);
}
catch (Exception ex)
{
Globals.Global.ShowErrorMsg(string.Empty, ex);
}
}
currentForm.SetProgressBar(0);
}
/// <summary>
/// The (Tag Type &) Ident Class
/// </summary>
/// <param name="meta">The controls meta data</param>
/// <param name="iEntName">The identifying name of the meta string</param>
/// <param name="map">The metas map file</param>
/// <param name="iOffsetInChunk">The offset to the string in the memory stream</param>
/// <param name="idoesHaveTagType">States whether there is a preceding Tag Type or just an Ident</param>
/// <param name="iLineNumber">The associated line number</param>
public Ident(Meta meta, string iEntName, Map map, int iOffsetInChunk, bool idoesHaveTagType, int iLineNumber)
{
InitializeComponent();
this.meta = meta;
this.LineNumber = iLineNumber;
this.doesHaveTagType = idoesHaveTagType;
// Even though !iDoesHaveTagType does not save a Tag Type, it is still loaded through the Ident
if (!idoesHaveTagType)
this.label1.Text = "Ident";
this.size = 4 + (this.doesHaveTagType ? 4 : 0);
this.map = map;
this.EntName = iEntName;
// Offset - 4 to account for Tag Type if applicable
this.chunkOffset = iOffsetInChunk - (idoesHaveTagType ? 4 : 0);
this.label4.Text = EntName;
this.Dock = DockStyle.Top;
//this.Size = this.PreferredSize;
this.AutoSize = false;
}
/// <summary>
/// Opens a new tab and loads the meta into it
/// </summary>
/// <param name="meta">The meta to load into the new tab</param>
/// <param name="allowDuplicate">if false, will look for a tab with the same meta and activate.
/// if true, will open a new tab with a duplicated meta</param>
/// <returns>Page Number of active tab</returns>
public int addNewTab( Meta meta, bool allowDuplicate)
{
string typeAndTag = "[" + meta.type.ToLower() + "] " + meta.name.Substring(meta.name.LastIndexOf('\\') + 1);
if (!allowDuplicate)
for (int i = 0; i < this.tabs.Tabs.Count; i++)
if (this.tabs.Tabs[i].Text == typeAndTag)
{
this.tabs.SelectedTabIndex = i;
//this.tabs.SelectedTab.Focus();
return i;
}
MetaEditorControlPage mecp = new MetaEditorControlPage(meta, mapForm);
this.BackColor = bgColor;
this.ForeColor = fgColor;
mecp.setFormColors(fgColor, bgColor);
// mapName = map.filePath.Substring(map.filePath.LastIndexOf('\\') + 1).ToUpper() +
TabItem tp = tabs.CreateTab(typeAndTag);
mecp.Parent = tp.AttachedControl;
mecp.Dock = DockStyle.Fill;
tp.Tooltip = "[" + @meta.type.ToLower() + "] " + @meta.name;
this.tabs.AllowDrop = true;
//this.tabs.DragDrop += new DragEventHandler(tp_DragDrop);
//this.tabs.DragEnter += new DragEventHandler(tp_DragEnter);
//this.tabs.DragLeave += new EventHandler(tp_DragLeave);
//// These tabs don't change selected index till MouseUp, so do it on MouseDown!
//this.tabs.MouseDown += new MouseEventHandler(tabControl1_MouseDown);
//this.tabs.MouseMove += new MouseEventHandler(tabControl1_MouseMove);
this.tabs.SelectedTabIndex = tabs.Tabs.IndexOf(tp);
this.WindowState = FormWindowState.Normal;
this.Show();
this.Focus();
return tabs.Tabs.IndexOf(tp);
}
/// <summary>
/// The Bitmask class
/// </summary>
/// <param name="meta">The controls meta data</param>
/// <param name="iEntName">The identifying name of the meta string</param>
/// <param name="map">The metas map file</param>
/// <param name="iOffsetInChunk">The offset to the string in the memory stream</param>
/// <param name="iBitCount">8 for Bitmask8, 16 for Bitmask16, 32 for Bitmask32 types</param>
/// <param name="ioptions">The array of options available</param>
/// <param name="iLineNumber"></param>
public Bitmask(Meta meta, string iEntName, Map map, int iOffsetInChunk, int iBitCount, IFPIO.Option[] ioptions, int iLineNumber)
{
this.meta = meta;
this.LineNumber = iLineNumber;
this.Options = ioptions;
this.Bits = new bool[iBitCount];
this.visibleBits = new bool[iBitCount];
this.bitCount = iBitCount;
this.size = iBitCount / 8;
this.chunkOffset = iOffsetInChunk;
this.map = map;
this.EntName = iEntName;
InitializeComponent();
this.label1.Text = "Bitmask" + iBitCount.ToString();
this.label1.Left -= iBitCount.ToString().Length * 8;
this.getLongestName();
this.MakeControls();
this.Size = this.PreferredSize;
this.Dock = DockStyle.Top;
this.Controls[0].Text = EntName;
this.AutoSize = true;
}
/// <summary>
/// The dissect meta.
/// </summary>
/// <param name="m">The m.</param>
/// <remarks></remarks>
public static void DissectMeta(ref Meta m)
{
object tempobject = Results[m.type];
if (tempobject == null)
{
MetaResult mr = new MetaResult();
IFPIO io = IFPHashMap.GetIfp(m.type, m.Map.HaloVersion);
mr.IFP = io;
Results.Add(m.type, mr);
tempobject = Results[m.type];
}
MetaResult CurrentResult = tempobject as MetaResult;
// figure out headersize for current meta
int headersize = m.size;
for (int x = 0; x < m.items.Count; x++)
{
if (m.items[x].type == Meta.ItemType.Reflexive)
{
Meta.Reflexive tempr = m.items[x] as Meta.Reflexive;
if (tempr.translation < headersize && tempr.intag == m.TagIndex)
{
headersize = tempr.translation;
}
}
}
if (CurrentResult.HeaderSizes.IndexOf(headersize) == -1)
{
CurrentResult.HeaderSizes.Add(headersize);
}
//
AnalyzeReferences(ref m);
}
/// <summary>
/// The read h 2 parsed bitmap.
/// </summary>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public void ReadH2ParsedBitmap(ref Meta meta)
{
BinaryReader BR = new BinaryReader(meta.MS);
BR.BaseStream.Position = 68;
int tempc = BR.ReadInt32();
int tempr = BR.ReadInt32() - meta.Map.SecondaryMagic - meta.offset;
headersize = tempr;
Properties = new BitmapInfo[tempc];
int okay = -1;
for (int x = 0; x < tempc; x++)
{
Properties[x] = new BitmapInfo(tempr + (116 * x), ref meta);
if (Properties[x].bitsPerPixel == 0)
{
okay = x;
}
if (Properties[x].format == 23)
{
}
}
if (okay != -1)
{
MessageBox.Show(
Properties[okay].formatname +
"\nFormat not supported, please inform developer of above format name.");
}
}
/// <summary>
/// The read ce parsed bitmap.
/// </summary>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public void ReadCEParsedBitmap(ref Meta meta)
{
using (BinaryReader BR = new BinaryReader(meta.MS))
{
int tempr;
if (meta.Map.MetaInfo.external[meta.TagIndex])
{
BR.BaseStream.Position = 96;
int tempc = BR.ReadInt32();
tempr = BR.ReadInt32();
headersize = tempr;
Properties = new BitmapInfo[tempc];
for (int x = 0; x < tempc; x++)
{
Properties[x] = new BitmapInfo(tempr + (48 * x), ref meta);
}
}
else
{
BR.BaseStream.Position = 96;
int tempc = BR.ReadInt32();
tempr = BR.ReadInt32() - meta.Map.PrimaryMagic - meta.Map.MetaInfo.Offset[meta.TagIndex];
headersize = tempr;
Properties = new BitmapInfo[tempc];
for (int x = 0; x < tempc; x++)
{
Properties[x] = new BitmapInfo(tempr + (48 * x), ref meta);
}
}
}
}
// visualchunkindex is for lightmaps only
/// <summary>
/// The find chunk and decode.
/// </summary>
/// <param name="bitmap">The bitmap.</param>
/// <param name="chunknumber">The chunknumber.</param>
/// <param name="mipmap">The mipmap.</param>
/// <param name="meta">The meta.</param>
/// <param name="map">The map.</param>
/// <param name="visualchunkindex">The visualchunkindex.</param>
/// <param name="bspnumber">The bspnumber.</param>
/// <returns></returns>
/// <remarks></remarks>
public Bitmap FindChunkAndDecode(
int bitmap,
int chunknumber,
int mipmap,
ref Meta meta,
Map map,
int visualchunkindex,
int bspnumber)
{
for (int x = 0; x < meta.raw.rawChunks.Count; x++)
{
BitmapRawDataChunk tempb = (BitmapRawDataChunk)meta.raw.rawChunks[x];
if (tempb.inchunk == bitmap && tempb.num == chunknumber)
{
int width = this.Properties[bitmap].width >> chunknumber;
int height = this.Properties[bitmap].height >> chunknumber;
int depth = this.Properties[bitmap].depth >> chunknumber;
depth = depth < 1 ? 1 : depth;
int pixeloff = this.Properties[bitmap].pixelOffset;
int bpp = this.Properties[bitmap].bitsPerPixel;
int offset = 0;
byte[] guh;
#region 2D & 3D (Volume) Textures
if (this.Properties[bitmap].typename != BitmapType.BITM_TYPE_CUBEMAP)
{
for (int i = 0; i < mipmap; i++)
{
//offset += Math.Max(width >> i, 1) * Math.Max(height >> i, 1) * Math.Max(depth >> i, 1) * (bpp >> 3);
switch (this.Properties[bitmap].formatname)
{
case BitmapFormat.BITM_FORMAT_DXT1:
offset += Math.Max( Math.Max(width >> i, 1) * Math.Max(height >> i, 1) * Math.Max(depth >> i, 1) * (bpp >> 3) / 8, 8);
break;
case BitmapFormat.BITM_FORMAT_DXT2AND3:
case BitmapFormat.BITM_FORMAT_DXT4AND5:
offset += Math.Max(Math.Max(width >> i, 1) * Math.Max(height >> i, 1) * Math.Max(depth >> i, 1) * (bpp >> 3) / 4, 16);
break;
/*
case BitmapFormat.BITM_FORMAT_DXT1:
offset /= 8;
break;
case BitmapFormat.BITM_FORMAT_DXT2AND3:
case BitmapFormat.BITM_FORMAT_DXT4AND5:
offset /= 4;
break;
*/
default:
offset += Math.Max(width >> i, 1) * Math.Max(height >> i, 1) * Math.Max(depth >> i, 1) * (bpp >> 3);
break;
}
}
// XZodia hack to fix issue in 03b_newmombosa, 2nd BSP, G8B8 bitmap issue
if (offset > tempb.size)
offset = tempb.size;
int tempsize = tempb.size - offset;
guh = new byte[tempsize];
Array.Copy(tempb.MS.ToArray(), offset, guh, 0, tempsize);
}
#endregion
#region Cubemap
else
{
for (int i = 0; i < mipmap; i++)
{
offset += tempb.mipmaps[i].size;
}
int tempsize = tempb.size - offset * 6;
guh = new byte[tempsize];
tempsize /= 6;
for (int i = 0; i < 6; i++)
{
Array.Copy(
tempb.MS.ToArray(), i * (offset + tempsize) + offset, guh, i * tempsize, tempsize);
}
}
#endregion
width = Math.Max(width >> mipmap, 1);
height = Math.Max(height >> mipmap, 1);
depth = Math.Max(depth >> mipmap, 1);
int widthPad = 0;
// 2D AY8 bitmaps are 64 byte padded?
int padding = (this.Properties[bitmap].formatname == BitmapFormat.BITM_FORMAT_AY8)
? 64 : 16;
if (this.Properties[bitmap].width % padding != 0 && width % padding != 0)
widthPad += padding - (width % padding);
Bitmap b;
try
{
b = DecodeBitm(
guh,
height,
width + widthPad,
depth,
bpp,
this.Properties[bitmap].typename,
this.Properties[bitmap].formatname,
this.Properties[bitmap].swizzle,
map,
visualchunkindex,
bspnumber);
}
catch
{
b = DecodeBitm(
guh,
height,
width,
depth,
bpp,
this.Properties[bitmap].typename,
this.Properties[bitmap].formatname,
this.Properties[bitmap].swizzle,
map,
visualchunkindex,
bspnumber);
}
return b;
}
}
return null;
}
/// <summary>
/// The convert c eto h 2 parsed bitmap.
/// </summary>
/// <param name="meta">The meta.</param>
/// <param name="map">The map.</param>
/// <remarks></remarks>
public void ConvertCEtoH2ParsedBitmap(ref Meta meta, Map map)
{
meta.MS = new MemoryStream();
meta.items.Clear();
BinaryWriter BW = new BinaryWriter(meta.MS);
BitmapHeader.WriteHeaderHaloBitmapHeader(ref BW);
BW.BaseStream.Position = 32;
BW.Write(new char[44]);
int size = 76;
int tempc = 1;
int tempr = meta.offset + size + meta.magic;
BW.BaseStream.Position = 60;
BW.Write(tempc);
BW.Write(tempr);
Meta.Reflexive reflex = new Meta.Reflexive();
reflex.offset = 60;
reflex.translation = size;
reflex.intag = meta.TagIndex;
reflex.intagname = meta.name;
reflex.intagtype = meta.type;
reflex.chunkcount = tempc;
reflex.pointstoTagIndex = meta.TagIndex;
reflex.pointstotagname = meta.name;
reflex.pointstotagtype = meta.type;
reflex.pointstotagname = meta.name;
reflex.pointstotagtype = meta.type;
meta.items.Add(reflex);
tempc = 1;
tempr = meta.offset + size + 60 + meta.magic;
BW.BaseStream.Position = 128;
BW.Write(tempc);
BW.Write(tempr);
reflex = new Meta.Reflexive();
reflex.offset = 128;
reflex.translation = size + 60;
reflex.intag = meta.TagIndex;
reflex.intagname = meta.name;
reflex.intagtype = meta.type;
reflex.chunkcount = tempc;
reflex.pointstoTagIndex = meta.TagIndex;
reflex.pointstotagname = meta.name;
reflex.pointstotagtype = meta.type;
reflex.pointstotagname = meta.name;
reflex.pointstotagtype = meta.type;
meta.items.Add(reflex);
BW.BaseStream.Position = size;
BW.Write(new char[92]);
size += 92;
tempc = Properties.Length;
tempr = meta.offset + size + meta.magic;
BW.BaseStream.Position = 68;
BW.Write(tempc);
BW.Write(tempr);
reflex = new Meta.Reflexive();
reflex.offset = 68;
reflex.translation = size;
reflex.intag = meta.TagIndex;
reflex.intagname = meta.name;
reflex.intagtype = meta.type;
reflex.chunkcount = tempc;
reflex.pointstoTagIndex = meta.TagIndex;
reflex.pointstotagname = meta.name;
reflex.pointstotagtype = meta.type;
reflex.pointstotagname = meta.name;
reflex.pointstotagtype = meta.type;
meta.items.Add(reflex);
for (int x = 0; x < tempc; x++)
{
BW.BaseStream.Position = size + (x * 116);
BW.Write(new char[116]);
BW.BaseStream.Position = size + (x * 116);
Properties[x].Write(ref BW);
int neg = -1;
meta.raw.rawChunks[x].pointerMetaOffset = size + (x * 116) + 28;
BW.BaseStream.Position = meta.raw.rawChunks[x].pointerMetaOffset + 4;
BW.Write(neg);
BW.Write(neg);
BW.Write(neg);
BW.Write(neg);
BW.Write(neg);
BW.Write(meta.raw.rawChunks[x].size);
Meta.Ident id = new Meta.Ident();
id.offset = size + (x * 116) + 76;
BW.BaseStream.Position = id.offset;
BW.Write(meta.ident);
id.pointstoTagIndex = meta.TagIndex;
id.pointstotagname = meta.name;
id.pointstotagtype = meta.type;
id.intag = meta.TagIndex;
id.intagname = meta.name;
id.intagtype = meta.type;
id.ident = meta.ident;
meta.items.Add(id);
}
meta.size = size + (Properties.Length * 116);
}
/// <summary>
/// Initializes a new instance of the <see cref="MetaScanner"/> class.
/// </summary>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public MetaScanner(Meta meta)
{
this.meta = meta;
}
/// <summary>
/// The bitmap internalize.
/// </summary>
/// <param name="bitmapMeta">The bitmap meta.</param>
/// <remarks></remarks>
public static void bitmapInternalize(Meta bitmapMeta)
{
if (bitmapMeta.raw.rawChunks[0].rawLocation == MapTypes.Internal)
{
return;
}
string sharedMapPath = string.Empty;
switch (bitmapMeta.raw.rawChunks[0].rawLocation)
{
case MapTypes.Internal:
sharedMapPath = bitmapMeta.Map.filePath;
break;
case MapTypes.Bitmaps:
sharedMapPath = Prefs.pathBitmaps;
break;
case MapTypes.MainMenu:
sharedMapPath = Prefs.pathMainmenu;
break;
case MapTypes.MPShared:
sharedMapPath = Prefs.pathShared;
break;
case MapTypes.SPShared:
sharedMapPath = Prefs.pathSPShared;
break;
}
Map sharedMap = Map.LoadFromFile(sharedMapPath);
//long sizeToShift = 0;
sharedMap.OpenMap(MapTypes.Internal);
bitmapMeta.Map.OpenMap(MapTypes.Internal, false);
// Find size of aall raw chunks and insert that amount into our bitmapMeta.Map
long rawSize = biGetRawTotalSize(bitmapMeta.raw, true);
shift(bitmapMeta.Map.FS, bitmapMeta.Map.MapHeader.indexOffset, rawSize);
long offsetInShared;
long offsetToWrite = bitmapMeta.Map.MapHeader.indexOffset;
bitmapMeta.Map.BW.BaseStream.Position = offsetToWrite;
byte[] rawData;
// loop for each tag
int tempRawSize;
// loop for each chunk
for (int j = 0; j < bitmapMeta.raw.rawChunks.Count; j++)
{
// loop for each LOD
{
// for (int k = 0; k < bitmapMeta.raw.rawChunks.lod.Count; k++)
tempRawSize = bitmapMeta.raw.rawChunks[j].size; // .lods.get(k).rawSize;
offsetInShared = bitmapMeta.raw.rawChunks[j].offset;
rawData = new byte[tempRawSize];
// RandomAccessFileSP shared = sharedMaps.get(selectedTag.bitmChunks[j].rawLocation);
// reads the data into the array
sharedMap.BR.BaseStream.Position = offsetInShared;
sharedMap.BR.BaseStream.Read(rawData, 0, rawData.Length);
bitmapMeta.raw.rawChunks[j].offset = (int)bitmapMeta.Map.BW.BaseStream.Position;
bitmapMeta.raw.rawChunks[j].rawLocation = MapTypes.Internal;
bitmapMeta.Map.BW.Write(rawData);
// writes padding after chunk
int paddingSize = genPaddingSize(tempRawSize, 512);
bitmapMeta.Map.BW.Write(genPadding(paddingSize, 0));
offsetToWrite += tempRawSize + paddingSize;
}
}
// fix pointers to point to internal bitmapMeta.Map
for (int j = 0; j < bitmapMeta.raw.rawChunks.Count; j++)
{
{
// for (int k = 0; k < selectedTag.bitmChunks[j].lods.size(); k++)
bitmapMeta.Map.BW.BaseStream.Position = bitmapMeta.offset + rawSize +
bitmapMeta.raw.rawChunks[j].pointerMetaOffset; // +28; //+ (k * 4);
bitmapMeta.Map.BW.Write(bitmapMeta.raw.rawChunks[j].offset); // 37063680
}
}
biUpdateMapInfo(bitmapMeta.Map, (int)rawSize);
sharedMap.CloseMap();
bitmapMeta.Map.CloseMap();
}
/// <summary>
/// Initializes a new instance of the <see cref="HaloBitmapHeader"/> class.
/// </summary>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public HaloBitmapHeader(ref Meta meta)
{
BinaryReader BR = new BinaryReader(meta.MS);
BR.BaseStream.Position = 0;
type = BR.ReadInt16();
format = BR.ReadInt16();
usage = BR.ReadInt16();
usageflags = BR.ReadInt16();
detailfadefactor = BR.ReadSingle();
sharpenamount = BR.ReadSingle();
bumpheight = BR.ReadSingle();
spritebudgesize = BR.ReadInt16();
spritebudgetcount = BR.ReadInt16();
colorplatewidth = BR.ReadInt16();
colorplateheight = BR.ReadInt16();
compressedcolorplatedata = BR.ReadInt16();
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapInfo"/> class.
/// </summary>
/// <param name="offset">The offset.</param>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public BitmapInfo(int offset, ref Meta meta)
{
BinaryReader BR = new BinaryReader(meta.MS);
BR.BaseStream.Position = offset;
tagtype = BR.ReadChars(4);
width = BR.ReadUInt16();
height = BR.ReadUInt16();
depth = BR.ReadUInt16();
type = BR.ReadUInt16();
typename = (BitmapType)type;
// case BitmapFormat.BITM_TYPE_LIGHTMAP:
format = BR.ReadUInt16();
formatname = (BitmapFormat)format;
switch (formatname)
{
case BitmapFormat.BITM_FORMAT_A8:
case BitmapFormat.BITM_FORMAT_P8:
case BitmapFormat.BITM_FORMAT_Y8:
case BitmapFormat.BITM_FORMAT_AY8:
case BitmapFormat.BITM_FORMAT_LIGHTMAP:
bitsPerPixel = 8;
break;
case BitmapFormat.BITM_FORMAT_A1R5G5B5:
case BitmapFormat.BITM_FORMAT_A4R4G4B4:
case BitmapFormat.BITM_FORMAT_A8Y8:
case BitmapFormat.BITM_FORMAT_R5G6B5:
case BitmapFormat.BITM_FORMAT_G8B8:
case BitmapFormat.BITM_FORMAT_UNKNOWN:
bitsPerPixel = 16;
break;
case BitmapFormat.BITM_FORMAT_X8R8G8B8:
case BitmapFormat.BITM_FORMAT_A8R8G8B8:
case BitmapFormat.BITM_FORMAT_DXT1:
case BitmapFormat.BITM_FORMAT_DXT2AND3:
case BitmapFormat.BITM_FORMAT_DXT4AND5:
bitsPerPixel = 32;
break;
default:
bitsPerPixel = 0;
break;
}
flags = BR.ReadUInt16();
// if ((flags & 0x1000) == 0x1000) { swizzle = true; }
if ((flags & 0x8) == 0x8)
{
swizzle = true;
}
regPointX = BR.ReadUInt16();
regPointY = BR.ReadUInt16();
mipMapCount = BR.ReadUInt16();
pixelOffset = BR.ReadUInt16();
}
/// <summary>
/// The scan map for lay out.
/// </summary>
/// <param name="map">The map.</param>
/// <param name="addexternalchunks">The addexternalchunks.</param>
/// <returns></returns>
/// <remarks></remarks>
public MapLayout ScanMapForLayOut(Map map, bool addexternalchunks)
{
MapLayout layout = new MapLayout();
for (int x = 0; x < map.BSP.sbsp.Length; x++)
{
LayOutChunk l = new LayOutChunk(0);
l.rawType = RawDataContainerType.BSPMeta;
l.startoffset = map.BSP.sbsp[x].offset;
l.endoffset = map.BSP.sbsp[x].offset + map.BSP.sbsp[x].size;
l.size = map.BSP.sbsp[x].size;
layout.chunks.Add(l);
}
LayOutChunk lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.Header;
lo.startoffset = 0;
lo.size = 2048;
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
if (map.HaloVersion == HaloVersionEnum.Halo2 ||
map.HaloVersion == HaloVersionEnum.Halo2Vista)
{
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.StringsIndex;
lo.startoffset = map.MapHeader.offsetToStringIndex;
lo.size = map.MapHeader.scriptReferenceCount * 4;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.Strings1;
lo.startoffset = map.MapHeader.offsetToStringNames1;
lo.size = map.MapHeader.scriptReferenceCount * 128;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.Strings2;
lo.startoffset = map.MapHeader.offsetToStringNames2;
lo.size = map.MapHeader.sizeOfScriptReference;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.Crazy;
lo.startoffset = map.MapHeader.offsetToCrazy;
lo.size = map.MapHeader.sizeOfCrazy;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.FileNamesIndex;
lo.startoffset = map.MapHeader.offsetTofileIndex;
lo.size = map.MapHeader.fileCount * 4;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
}
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.FileNames;
lo.startoffset = map.MapHeader.offsetTofileNames;
lo.size = map.MapHeader.fileNamesSize;
if (map.HaloVersion == HaloVersionEnum.Halo2 ||
map.HaloVersion == HaloVersionEnum.Halo2Vista)
{
lo.size += map.Functions.Padding(lo.size, 512);
}
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.MetaIndex;
lo.startoffset = map.MapHeader.indexOffset;
if (map.HaloVersion == HaloVersionEnum.Halo2 ||
map.HaloVersion == HaloVersionEnum.Halo2Vista)
{
lo.size = map.MapHeader.metaStart;
lo.size += map.Functions.Padding(lo.size, 512);
// map.MapHeader.fileSize - map.MapHeader.indexOffset;
}
else
{
lo.size = map.MapHeader.offsetTofileNames - map.MapHeader.indexOffset;
// map.MetaInfo.Offset[map.IndexHeader.metaCount - 1] + map.MetaInfo.Size[map.IndexHeader.metaCount-1];
}
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.MetaData;
lo.startoffset = map.MetaInfo.Offset[0];
// How can you adjust for padding past the end of the file???
lo.size = map.MapHeader.fileSize - lo.startoffset;
if (map.HaloVersion == HaloVersionEnum.Halo2 ||
map.HaloVersion == HaloVersionEnum.Halo2Vista)
{
int padding = map.Functions.Padding(lo.startoffset + lo.size, 4096);
lo.size += padding;
}
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
if (map.HaloVersion == HaloVersionEnum.Halo2 ||
map.HaloVersion == HaloVersionEnum.Halo2Vista)
{
for (int x = 0; x < map.Unicode.ut.Length; x++)
{
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.UnicodeNamesIndex;
lo.startoffset = map.Unicode.ut[x].indexOffset;
lo.size = map.Unicode.ut[x].count * 8;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
lo = new LayOutChunk(0);
lo.rawType = RawDataContainerType.UnicodeNames;
lo.startoffset = map.Unicode.ut[x].tableOffset;
lo.size = map.Unicode.ut[x].tableSize;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
}
}
map.OpenMap(MapTypes.Internal);
for (int x = 0; x < map.IndexHeader.metaCount; x++)
{
if (map.HaloVersion == HaloVersionEnum.Halo2 ||
map.HaloVersion == HaloVersionEnum.Halo2Vista)
{
if (map.MetaInfo.TagType[x] == "snd!" | map.MetaInfo.TagType[x] == "ltmp")
{
continue;
}
Application.DoEvents();
}
Meta m = new Meta(map);
m.offset = map.MetaInfo.Offset[x];
// checks if type has raw data
m.rawType = map.Functions.ForMeta.CheckForRaw(map.MetaInfo.TagType[x]);
if (m.rawType != RawDataContainerType.Empty)
{
m.raw = map.Functions.ForMeta.ReadRaw(x, true);
LayOutChunk l = new LayOutChunk(map.MapHeader.fileSize);
int tempint = layout.FindByType(m.rawType);
if (tempint == -1)
{
l = new LayOutChunk(map.MapHeader.fileSize);
l.rawType = m.rawType;
layout.chunks.Add(l);
tempint = layout.FindByType(m.rawType);
}
else
{
l = (LayOutChunk)layout.chunks[tempint];
}
for (int y = 0; y < m.raw.rawChunks.Count; y++)
{
RawDataChunk r = m.raw.rawChunks[y];
if (r.offset == -1)
{
continue;
}
if (r.rawLocation == MapTypes.Internal)
{
RawInfoChunk tempr = new RawInfoChunk();
tempr.offset = (uint)r.offset;
tempr.size = r.size;
tempr.rawType = r.rawDataType;
tempr.location = r.rawLocation;
tempr.offsetOfPointer = m.offset + r.pointerMetaOffset;
l.rawPieces.Add(tempr);
}
else if (addexternalchunks)
{
RawInfoChunk tempr = new RawInfoChunk();
tempr.offset = (uint)r.offset;
tempr.size = r.size;
tempr.rawType = r.rawDataType;
tempr.location = r.rawLocation;
tempr.offsetOfPointer = m.offset + r.pointerMetaOffset;
l.rawPieces.Add(tempr);
}
if (r.offset < l.startoffset && r.rawLocation == MapTypes.Internal)
{
l.startoffset = r.offset;
l.size = l.endoffset - l.startoffset;
layout.chunks[tempint] = l;
}
if (r.offset + r.size > l.endoffset && r.rawLocation == MapTypes.Internal)
{
l.endoffset = r.offset + r.size;
l.endoffset += map.Functions.Padding(l.endoffset, 512);
l.size = l.endoffset - l.startoffset;
layout.chunks[tempint] = l;
}
}
}
m = null;
GC.WaitForPendingFinalizers();
// GC.Collect();
}
map.CloseMap();
if (map.HaloVersion == HaloVersionEnum.Halo2 ||
map.HaloVersion == HaloVersionEnum.Halo2Vista)
{
lo = new LayOutChunk(0);
LayOutChunk templo = (LayOutChunk)layout.chunks[layout.FindByType(RawDataContainerType.Model)];
lo.rawType = RawDataContainerType.Sound;
lo.startoffset = 2048;
lo.size = templo.startoffset - 2048;
lo.size += map.Functions.Padding(lo.size, 512);
lo.endoffset = lo.startoffset + lo.size;
layout.chunks.Add(lo);
}
for (int y = 0; y < layout.chunks.Count; y++)
{
LayOutChunk l = (LayOutChunk)layout.chunks[y];
if (l.size == 0)
{
layout.chunks.RemoveAt(y);
y--;
}
}
layout.SortChunksByOffset();
layout.SortRawByOffset();
return layout;
}
/// <summary>
/// Initializes a new instance of the <see cref="coll"/> class.
/// </summary>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public coll(ref Meta meta)
{
BinaryReader BR = new BinaryReader(meta.MS);
BR.BaseStream.Position = 28;
int tempc = BR.ReadInt32();
int tempr = BR.ReadInt32() - meta.magic - meta.offset;
for (int xxx = 0; xxx < tempc; xxx++)
{
BR.BaseStream.Position = tempr + (xxx * 12);
string index1string = meta.Map.Strings.Name[BR.ReadUInt16()];
BR.BaseStream.Position = tempr + (xxx * 12) + 4;
int tempcxx = BR.ReadInt32();
int temprxx = BR.ReadInt32() - meta.magic - meta.offset;
for (int xx = 0; xx < tempcxx; xx++)
{
BR.BaseStream.Position = temprxx + (xx * 20);
string index2string = meta.Map.Strings.Name[BR.ReadUInt16()];
BR.BaseStream.Position = temprxx + (xx * 20) + 4;
int tempcx = BR.ReadInt32();
int temprx = BR.ReadInt32() - meta.magic - meta.offset;
// Meshes = new CollisionMesh[tempc];
for (int x = 0; x < tempcx; x++)
{
CollisionMesh cm = new CollisionMesh();
cm.index1 = xxx;
cm.index1string = index1string;
cm.index2 = xx;
cm.index2string = index2string;
if (ConditionStrings.IndexOf(cm.index2string) == -1)
{
ConditionStrings.Add(cm.index2string);
}
cm.index3 = x;
BR.BaseStream.Position = temprx + (x * 68) + 52;
int tempc2 = BR.ReadInt32();
int tempr2 = BR.ReadInt32() - meta.magic - meta.offset;
cm.Faces = new ushort[tempc2 * 3];
for (int y = 0; y < tempc2; y++)
{
BR.BaseStream.Position = tempr2 + (y * 12);
cm.Faces[y * 3] = BR.ReadUInt16();
cm.Faces[(y * 3) + 1] = BR.ReadUInt16();
cm.Faces[(y * 3) + 2] = cm.Faces[(y * 3) + 1]; // BR.ReadUInt16();
}
// ***** Test Code ****//
BR.BaseStream.Position = temprx + (x * 68) + 12;
tempc2 = BR.ReadInt32();
tempr2 = BR.ReadInt32() - meta.magic - meta.offset;
cm.Normals = new Vector4[tempc2];
for (int y = 0; y < tempc2; y++)
{
BR.BaseStream.Position = tempr2 + (y * 16) + 0;
cm.Normals[y].X = BR.ReadSingle();
cm.Normals[y].Y = BR.ReadSingle();
cm.Normals[y].Z = BR.ReadSingle();
cm.Normals[y].W = BR.ReadSingle();
}
BR.BaseStream.Position = temprx + (x * 68) + 44;
tempc2 = BR.ReadInt32();
tempr2 = BR.ReadInt32() - meta.magic - meta.offset;
cm.SurfaceData = new surfaceData[tempc2];
for (int y = 0; y < tempc2; y++)
{
BR.BaseStream.Position = tempr2 + (y * 8) + 0;
cm.SurfaceData[y] = new surfaceData();
cm.SurfaceData[y].Plane = BR.ReadInt16();
}
BR.BaseStream.Position = temprx + (x * 68) + 52;
tempc2 = BR.ReadInt32();
tempr2 = BR.ReadInt32() - meta.magic - meta.offset;
int[] startEdges = new int[tempc2];
int[] endEdges = new int[tempc2];
int[] forwardEdges = new int[tempc2];
int[] reverseEdges = new int[tempc2];
int[] face1 = new int[tempc2];
int[] face2 = new int[tempc2];
for (int y = 0; y < tempc2; y++)
{
BR.BaseStream.Position = tempr2 + (y * 12) + 0;
startEdges[y] = BR.ReadUInt16();
endEdges[y] = BR.ReadUInt16();
BR.BaseStream.Position = tempr2 + (y * 12) + 4;
forwardEdges[y] = BR.ReadUInt16();
reverseEdges[y] = BR.ReadUInt16();
BR.BaseStream.Position = tempr2 + (y * 12) + 8;
face1[y] = BR.ReadUInt16();
face2[y] = BR.ReadUInt16();
}
for (int y = 0; y < forwardEdges.Length; y++)
{
int cSurface = face1[y];
if (cm.SurfaceData[cSurface].Vertices == null)
{
cm.SurfaceData[cSurface].Vertices = new List<int>();
int edge = y;
int nextEdge = 0;
cm.SurfaceData[cSurface].Vertices.Add(startEdges[edge]);
do
{
if (cSurface == face1[edge])
{
cm.SurfaceData[cSurface].Vertices.Add(endEdges[edge]);
edge = forwardEdges[edge];
}
else if (cSurface == face2[edge])
{
cm.SurfaceData[cSurface].Vertices.Add(startEdges[edge]);
edge = reverseEdges[edge];
}
if (cSurface == face1[edge])
{
nextEdge = endEdges[edge];
}
else if (cSurface == face2[edge])
{
nextEdge = startEdges[edge];
}
}
while (!cm.SurfaceData[cSurface].Vertices.Contains(nextEdge));
}
}
for (int y = 0; y < reverseEdges.Length; y++)
{
int cSurface = face2[y];
if (cm.SurfaceData[cSurface].Vertices == null)
{
cm.SurfaceData[cSurface].Vertices = new List<int>();
int edge = y;
int nextEdge = 0;
cm.SurfaceData[cSurface].Vertices.Add(endEdges[edge]);
do
{
if (cSurface == face1[edge])
{
cm.SurfaceData[cSurface].Vertices.Add(endEdges[edge]);
edge = forwardEdges[edge];
}
else if (cSurface == face2[edge])
{
cm.SurfaceData[cSurface].Vertices.Add(startEdges[edge]);
edge = reverseEdges[edge];
}
if (cSurface == face1[edge])
{
nextEdge = endEdges[edge];
}
else if (cSurface == face2[edge])
{
nextEdge = startEdges[edge];
}
}
while (!cm.SurfaceData[cSurface].Vertices.Contains(nextEdge));
}
}
// ***** End Test Code ****//
BR.BaseStream.Position = temprx + (x * 68) + 60;
tempc2 = BR.ReadInt32();
tempr2 = BR.ReadInt32() - meta.magic - meta.offset;
// Meshes[x] = new CollisionMesh();
cm.Vertices = new Vector3[tempc2];
for (int y = 0; y < tempc2; y++)
{
BR.BaseStream.Position = tempr2 + (y * 16);
cm.Vertices[y].X = BR.ReadSingle();
cm.Vertices[y].Y = BR.ReadSingle();
cm.Vertices[y].Z = BR.ReadSingle();
}
Meshes.Add(cm);
}
}
}
BR.BaseStream.Position = 36;
tempc = BR.ReadInt32();
tempr = BR.ReadInt32() - meta.magic - meta.offset;
for (int xxx = 0; xxx < tempc; xxx++)
{
BR.BaseStream.Position = tempr + (20 * xxx);
PathfindingSphere ps = new PathfindingSphere();
ps.nodeindex = BR.ReadInt32();
ps.position = new Vector3();
ps.position.X = BR.ReadSingle();
ps.position.Y = BR.ReadSingle();
ps.position.Z = BR.ReadSingle();
ps.radius = BR.ReadSingle();
Spheres.Add(ps);
}
}
public Skin(Map map, Meta meta)
{
this.map = map;
this.meta = meta;
loadFontNames();
}
