public void DoProcessMeta(ref TSFReader sr, MemoryStream FI, ref FileStream FO, ref FileStream VertsFile, ref FileStream IndFile, ref FileStream BSPFile, uint Count, string[] IndexStrings, StructInfo Info)
{
TabReplace += (char)TabByte;
Name = sr.GetUName(); //CMD[2];
Size = sr.GetSOC();
TagBuff = new byte[Size * Count];
FI.Read(TagBuff, 0, TagBuff.Length);
//FixIntPosition(ref FO);
long StructPosition = FO.Position;
FO.Write(TagBuff, 0, TagBuff.Length);
uint StartOfStruct = sr.Position;
uint sc = 0;
bool ExitStruct = false;
do
{
do
{
//InLine = sr.Read();
//CMD = InLine.Replace(TabReplace,"").ToLower().Trim().Split(new char[]{' '},256);
sr.Read();
switch (sr.GetCMD())
{
case TSFReader.TSFStruct: // "struct":
uint ChildCount = GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)));
if (ChildCount != 0)
{
PCMeta Child = new PCMeta();
PutUInt(ref TagBuff, (uint)(sr.GetOIP() + 4 + (sc * Size)), (uint)(FO.Position + Info.TagMagic));
Child.DoProcessMeta(ref sr, FI, ref FO, ref VertsFile, ref IndFile, ref BSPFile, ChildCount, IndexStrings, Info);
FixIntPosition(ref FO);
}
else
{
sr.SeekAheadTo(0xA7, sr.GetUName());
//sr.SeekAheadTo("end " + CMD[2]);
//sr.Seek(sr.Position + 1);
}
break;
case TSFReader.TSFBSPTagRef: // "bspstagref":
case TSFReader.TSFTagRef: // "tagref":
uint tStringSize = 0;
GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x08, ref tStringSize);
if (tStringSize != 0x00)
{
PutUInt(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x04, 0x00000000);
PutUInt(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x08, 0x00000000);
uint TagClass = GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)));
string TagClassString = GetTagClassRev(BitConverter.GetBytes(TagClass), 0);
byte[] tmpStr = new byte[tStringSize + 1];
FI.Read(tmpStr, 0, tmpStr.Length);
string tag = ReadString(tmpStr, 0);
int t = 0;
//string[] test;
bool con = false;
do
{
string[] test = Info.Items[t].NameString.Split(new char[] { '.' }, 256); //IndexStrings[t].Split(new char[]{'.'},256);
string testClass = GetTagClassRev(BitConverter.GetBytes(Info.Items[t].TagClass1), 0);
if (testClass == TagClassString && test[0] == tag)
{
con = true;
}
else
{
t += 1;
}
}while (con == false); // testClass != TagClass);
PutUInt(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x04, Info.Items[t].StringOffset);
PutUShort(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x0C, (ushort)Info.Items[t].IndexID1);
PutUShort(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x0E, (ushort)Info.Items[t].IndexID2);
if (Name == 0x0468)
{
uint SaveTagMagic = Info.TagMagic;
byte[] BspHeader = new byte[0x18];
PutUInt(ref TagBuff, 0x00 + (sc * Size), (uint)(0x800 + BSPFile.Position));
uint CurrentPosition = (uint)BSPFile.Position;
Info.CurrentOffset = (uint)BSPFile.Position;
MTSFReader mr = new MTSFReader();
mr.MTSFRead("Core.Compiler.HALO_PC_SET.MTSF");
TSFReader tmpSTSF = new TSFReader();
//SwapInt(TagClasses,0);
tmpSTSF.TSF(ref mr, 0x70736273); // 73627370);
//MAG tmpsr = new MAG(Info.StructurePath + "sbsp.mag");
//FileInfo BspMetaFile_info = new FileInfo(Info.TagsPath + tag + "." + tmpSTSF.Name);
//FileStream BspMetaFile;
//BspMetaFile = BspMetaFile_info.Open(FileMode.Open,FileAccess.Read);
//BspMetaFile.Seek(0x40,SeekOrigin.Begin);
TagFileName tfnTAG = new TagFileName(tag + "." + tmpSTSF.Name, MapfileVersion.HALOPC);
TagBase tbTAG = new TagBase();
tbTAG.LoadTagBuffer(tfnTAG);
string[] gh;
int tt = -1;
do
{
tt += 1;
}while((tag + "." + tmpSTSF.Name) != Info.Items[tt].NameString);
uint BSPFileSize = (0x800 - ((uint)(Info.Items[tt].MetaSize) % 0x800));
BSPFileSize += (uint)(Info.Items[tt].MetaSize);
uint tmpMagic = (uint)(0x41B40000 - BSPFileSize);
Info.TagMagic = tmpMagic;
PutUInt(ref TagBuff, 0x08 + (sc * Size), tmpMagic);
PutUInt(ref BspHeader, 0x00 + (sc * Size), 0x18 + tmpMagic);
PutUInt(ref BspHeader, 0x14 + (sc * Size), 0x73627370);
BSPFile.Write(BspHeader, 0, BspHeader.Length);
PCMeta BspMeta = new PCMeta();
BspMeta.DoProcessMeta(ref tmpSTSF, tbTAG.Stream, ref BSPFile, ref VertsFile, ref IndFile, ref BSPFile, 1, IndexStrings, Info);
FixIntPosition2K(ref BSPFile);
PutUInt(ref TagBuff, 0x04 + (sc * Size), (uint)(CurrentPosition + BSPFile.Position));
//BspMetaFile.Close();
tbTAG = null;
Info.TagMagic = SaveTagMagic;
int a = 0;
}
}
break;
case TSFReader.TSFInternalRaw: // "internalraw":
uint RawSize = GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size))); //Compile Mag.Map
if (RawSize == 0)
{
break;
}
uint RawOffset = GetUInt(TagBuff, (uint)(sr.GetOIP() + 0x0c + (sc * Size))); //Tag Text
PutUInt(ref TagBuff, (uint)(sr.GetOIP()) + 0x0c + (sc * Size), ((uint)FO.Position + Info.TagMagic));
byte[] tmp = new byte[RawSize];
FI.Read(tmp, 0, tmp.Length);
FO.Write(tmp, 0, tmp.Length);
FixIntPosition(ref FO);
tmp = null;
break;
case TSFReader.TSFBitmapRaw: // "bitmapraw":
uint TiffSize = 0; GetUInt(TagBuff, 0x1C, ref TiffSize);
byte[] TiffBuffer = new byte[TiffSize];
FI.Read(TiffBuffer, 0, TiffBuffer.Length);
uint BitmapSize = GetUInt(TagBuff, 0x30);
TiffBuffer = new byte[BitmapSize];
FI.Read(TiffBuffer, 0, TiffBuffer.Length);
TiffBuffer = null;
break;
case TSFReader.TSFModelData: // "modeldata":
long SaveMapFilePos = (uint)FI.Position;
uint TrueVerticesSize = (GetUInt(TagBuff, (uint)(88 + (sc * Size)))) * 68;
uint TrueIndicesSize = (((GetUInt(TagBuff, (uint)(72 + (sc * Size)))) / 3) + 1) * 6;
uint NewIndicesDataSize = (GetUInt(TagBuff, (uint)(72 + (sc * Size))) / 3) + 1;
byte[] RawModelBuffer = new byte[TrueVerticesSize];
FI.Read(RawModelBuffer, 0, RawModelBuffer.Length);
PutUInt(ref TagBuff, (uint)(0x64 + (sc * Size)), (uint)VertsFile.Position);
PutUInt(ref TagBuff, (uint)(0x4C + (sc * Size)), (uint)IndFile.Position);
PutUInt(ref TagBuff, (uint)(0x50 + (sc * Size)), (uint)IndFile.Position);
VertsFile.Write(RawModelBuffer, 0, RawModelBuffer.Length);
RawModelBuffer = new byte[TrueIndicesSize];
FI.Read(RawModelBuffer, 0, RawModelBuffer.Length);
IndFile.Write(RawModelBuffer, 0, RawModelBuffer.Length);
byte[] TestBuffer = new byte[6];
FI.Read(TestBuffer, 0, 6);
if (TestBuffer[4] == 0xff)
{
IndFile.Write(TestBuffer, 0, TestBuffer.Length);
}
else
{
FI.Seek(FI.Position - 6, SeekOrigin.Begin);
}
FixIntPosition(ref IndFile);
break;
case TSFReader.TSFBSPModel: // "bspmodel":
uint UnCompressedVerts = sr.GetOIP();
uint CompressedVerts = sr.GetSOC();
uint UnCompressedVertsOffset = sr.GetOIP();
//uint VertsOffset = GetUInt(TagBuff,CompressedVerts);
uint TrueVertCount = GetUInt(TagBuff, 180 + (sc * Size));
uint TrueLightMapDataCount = GetUInt(TagBuff, 200 + (sc * Size));
uint UnCompressedLightMapData = (TrueLightMapDataCount * 20);
uint CompressedLightMapData = (TrueLightMapDataCount * 8);
UnCompressedVerts = (TrueVertCount * 56);
CompressedVerts = (TrueVertCount * 32);
byte[] BspVertsUnCompressed = new byte[UnCompressedVerts];
FI.Read(BspVertsUnCompressed, 0, BspVertsUnCompressed.Length);
PutUInt(ref TagBuff, 0xe4 + (sc * Size), (uint)(FO.Position + Info.TagMagic));
FO.Write(BspVertsUnCompressed, 0, BspVertsUnCompressed.Length);
//byte[] BspVertsCompressed = new byte[CompressedVerts];
byte[] BspLightMapDataUnCompressed = new byte[UnCompressedLightMapData];
FI.Read(BspLightMapDataUnCompressed, 0, BspLightMapDataUnCompressed.Length);
FO.Write(BspLightMapDataUnCompressed, 0, BspLightMapDataUnCompressed.Length);
//byte[] BspLightMapDataCompressed = new byte[CompressedLightMapData];
//viper told me to skip past compressed data as a quick fix to
// the crash problem - Grenadiac
FI.Seek(CompressedVerts, SeekOrigin.Current); //gren added this
FI.Seek(CompressedLightMapData, SeekOrigin.Current); //gren added this
break;
case TSFReader.TSFResource: // "resources":
ushort rStringSize = GetUShort(TagBuff, 0x06 + (sc * Size));
if (rStringSize != 0x00)
{
uint TagClassFlag = GetUShort(TagBuff, 0x00 + (sc * Size));
string TagClassString = "";
switch (TagClassFlag)
{
case 0x00:
TagClassString = "bitm";
break;
case 0x01:
TagClassString = "snd!";
break;
}
//MAG tmpMR = new MAG(Info.StructurePath + TagClassString.Trim() + ".mag");
byte[] tmpStr = new byte[rStringSize + 1];
FI.Read(tmpStr, 0, tmpStr.Length);
string tag = ReadString(tmpStr, 0);
//tmpMR.Seek(0);
int t = 0;
//string[] test;
bool con = false;
do
{
string[] test = Info.Items[t].GetString().Split(new char[] { '.' }, 256); //IndexStrings[t].Split(new char[]{'.'},256);
string testClass = GetTagClassRev(BitConverter.GetBytes(Info.Items[t].TagClass1), 0);
if (testClass == TagClassString && test[0] == tag)
{
con = true;
}
else
{
t += 1;
}
}while (con == false);
PutUShort(ref TagBuff, (uint)(0x04 + (sc * Size)), (ushort)Info.Items[t].IndexID1);
PutUShort(ref TagBuff, (uint)(0x06 + (sc * Size)), (ushort)Info.Items[t].IndexID2);
}
break;
case TSFReader.TSFSoundData: // "sounddata":
uint sRawSize = GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)));
uint sRawOffset = GetUInt(TagBuff, (uint)(sr.GetUName() + (sc * Size)));
byte[] stmp = new byte[sRawSize];
FI.Read(stmp, 0, stmp.Length);
stmp = null;
break;
case TSFReader.TSFEnd: // "end":
if (sr.GetOIP() == Name)
{
ExitStruct = true;
}
else
{
ExitStruct = false;
}
break;
}
}while(ExitStruct == false);
if (Count != 0)
{
sc += 1;
if (sc != Count)
{
sr.Seek(StartOfStruct);
ExitStruct = false;
}
}
}while(sc != Count);
long tmpPosSave = FO.Position;
FO.Seek(StructPosition, SeekOrigin.Begin);
FO.Write(TagBuff, 0, TagBuff.Length);
FO.Seek(tmpPosSave, SeekOrigin.Begin);
}
public static void Build()
{
TagFileName scenario_tag = ProjectManager.ScenarioTagFileName;
//IndexBuilder IndexBuild = new IndexBuilder();
Compiler_Gren.DependencyBuilder IndexBuild = new Compiler_Gren.DependencyBuilder();
//FileInfo TagFile_info = new FileInfo(scenario_tag.RelativePath);
string BasFolder = Application.StartupPath + @"\Extracted Tags\";
string StructFolder = Application.StartupPath + @"\Tag Structures\PcHalo\";
//string MapsFolder = Application.StartupPath + @"\Maps\";
if (true)
{
//Create the index table
//lbCurTag.Text = "Building Index Table....";
Application.DoEvents();
//string[] IndexList = IndexBuild.BuildIndex(scenario_tag.RelativePath, BasFolder, StructFolder);
string[] IndexList = IndexBuild.BuildIndex(scenario_tag);
HaloPCMAP.HaloPC NewMap = new HaloPCMAP.HaloPC();
NewMap.PCIndexHeader.Create((uint)IndexList.Length);
NewMap.PCIndexHeader.IndexMagic = 0x40440028;
uint StringTableSize = 0;
//Fixing index items
ushort gt = 0xE174;
//lbCurTag.Text = "Building Index Table Items....";
Application.DoEvents();
for (int sc = 0; sc < IndexList.Length; sc++)
{
//FileInfo TagFile2_info = new FileInfo(BasFolder + IndexList[sc]);
//FileStream TagFile2;
//TagFile2 = TagFile2_info.Open(FileMode.Open,FileAccess.Read);
//byte[] tmp = new byte[0x40];
//TagFile2.Read(tmp,0x00,tmp.Length);
//TagFile2.Close();
TagFileName tfnTAG = new TagFileName(IndexList[sc], MapfileVersion.HALOPC);
TagBase tbTAG = new TagBase();
tbTAG.LoadTagBuffer(tfnTAG);
//uint TagClass1 = BitConverter.ToUInt32(tmp,0x24);
//uint TagClass2 = BitConverter.ToUInt32(tmp,0x28);
//uint TagClass3 = BitConverter.ToUInt32(tmp,0x2C);
NewMap.PCIndexHeader.IndexItems[sc].Create();
NewMap.PCIndexHeader.IndexItems[sc].TagClass1 = SwapUInt(tbTAG.Header.TagClass0); // TagClass1;
NewMap.PCIndexHeader.IndexItems[sc].TagClass2 = SwapUInt(tbTAG.Header.TagClass1); // TagClass2;
NewMap.PCIndexHeader.IndexItems[sc].TagClass3 = SwapUInt(tbTAG.Header.TagClass2); // TagClass3;
NewMap.PCIndexHeader.IndexItems[sc].IndexID1 = (ushort)sc;
NewMap.PCIndexHeader.IndexItems[sc].IndexID2 = gt;
NewMap.PCIndexHeader.IndexItems[sc].NameString = IndexList[sc];
if (tbTAG.Header.TagClass0 == 0x70736273 || tbTAG.Header.TagClass0 == 0x73627370)
{
NewMap.PCIndexHeader.IndexItems[sc].MetaSize = IndexBuild.BSPSizes[0];
}
else
{
NewMap.PCIndexHeader.IndexItems[sc].MetaSize = 0;
}
if (tbTAG.Header.TagClass0 == 0x7274656d || tbTAG.Header.TagClass0 == 0x6d657472)// 6d657472)
{
gt += 2;
}
else
{
gt += 1;
}
string[] RemoveExt = IndexList[sc].Split(new char[] { '.' }, 256);
NewMap.PCIndexHeader.IndexItems[sc].String = new byte[RemoveExt[0].Length + 1];
HaloPCMAP.StringToByteArray(ref NewMap.PCIndexHeader.IndexItems[sc].String, RemoveExt[0]);
StringTableSize += (uint)(IndexList[sc].Length + 1);
tbTAG = null;
}
//Creating the temp files for map building
FileInfo VertsFile_info = new FileInfo(Application.StartupPath + "TempVerts.Map");
FileStream VertsFile;
VertsFile = VertsFile_info.Open(FileMode.Create, FileAccess.ReadWrite);
FileInfo IndicesFile_info = new FileInfo(Application.StartupPath + "TempIndices.Map");
FileStream IndicesFile;
IndicesFile = IndicesFile_info.Open(FileMode.Create, FileAccess.ReadWrite);
FileInfo MetaFile_info = new FileInfo(Application.StartupPath + "TempMeta.map");
FileStream MetaFile;
MetaFile = MetaFile_info.Open(FileMode.Create, FileAccess.ReadWrite);
FileInfo BSPFile_info = new FileInfo(Application.StartupPath + "TempBSP.map");
FileStream BSPFile;
BSPFile = BSPFile_info.Open(FileMode.Create, FileAccess.ReadWrite);
//lbCurTag.Text = "Writeing Index Table....";
Application.DoEvents();
//writing the index table the temp files
for (int sc = 0; sc < NewMap.PCIndexHeader.IndexItems.Length; sc++)
{
NewMap.PCIndexHeader.IndexItems[sc].Write(ref MetaFile);
}
//Rewriting index items to temp file to fix string offsets.
//lbCurTag.Text = "Rewriteing Index Table....";
Application.DoEvents();
for (int sc = 0; sc < NewMap.PCIndexHeader.IndexItems.Length; sc++)
{
NewMap.PCIndexHeader.IndexItems[sc].StringOffset = (uint)MetaFile.Position + NewMap.PCIndexHeader.IndexMagic;
MetaFile.Write(NewMap.PCIndexHeader.IndexItems[sc].String, 0, NewMap.PCIndexHeader.IndexItems[sc].String.Length);
}
//save MetaFile position to return for meta writing.
long TmpPosSave = MetaFile.Position;
//lbCurTag.Text = "Writing Index Table with Srtring Offsets....";
Application.DoEvents();
for (int sc = 0; sc < NewMap.PCIndexHeader.IndexItems.Length; sc++)
{
MetaFile.Seek(NewMap.PCIndexHeader.IndexItems[sc].Position, SeekOrigin.Begin);
NewMap.PCIndexHeader.IndexItems[sc].Write(ref MetaFile);
}
//restore position for meta writing
MetaFile.Seek(TmpPosSave, SeekOrigin.Begin);
//Add info to the Meta info struct
PCMeta.StructInfo Info = new PCMeta.StructInfo();
Info.MapMagic = NewMap.PCIndexHeader.IndexMagic;
Info.TagMagic = NewMap.PCIndexHeader.IndexMagic;
Info.StructurePath = StructFolder;
Info.TagsPath = BasFolder;
Info.Items = NewMap.PCIndexHeader.IndexItems;
//Starts processing meta and writing it to the meta file
//lbCurTag.Text = "Adding Tags to map....";
Application.DoEvents();
for (int sc = 0; sc < NewMap.PCIndexHeader.IndexItems.Length; sc++)
{
if (NewMap.PCIndexHeader.IndexItems[sc].TagClass1 != 0x70736273) // 70736273)
{
PCMeta Meta = new PCMeta();
//FileInfo Tag_info = new FileInfo(BasFolder + IndexList[sc]);
//FileStream Tag;
//Tag = Tag_info.Open(FileMode.Open,FileAccess.Read);
//byte[] head = new byte[0x40];
//Tag.Read(head,0,head.Length);
TagFileName tfnTAG = new TagFileName(IndexList[sc], MapfileVersion.HALOPC);
TagBase tbTAG = new TagBase();
tbTAG.LoadTagBuffer(tfnTAG);
//string Class = Meta.GetTagClass(head,0x24);
//MAG sr = new MAG(StructFolder + Class.Trim() + ".mag");
//sr.Seek(1);
MTSFReader mr = new MTSFReader();
mr.MTSFRead("Core.Compiler.HALO_PC_SET.MTSF");
TSFReader STSF = new TSFReader();
//SwapInt(TagClasses,0);
STSF.TSF(ref mr, tbTAG.Header.TagClass0);
HaloPCMAP.FixIntPosition(ref MetaFile);
Info.CurrentOffset = (uint)MetaFile.Position;
NewMap.PCIndexHeader.IndexItems[sc].MetaOffset = (uint)(MetaFile.Position + NewMap.PCIndexHeader.IndexMagic);
Meta.DoProcessMeta(ref STSF, tbTAG.Stream, ref MetaFile, ref VertsFile, ref IndicesFile, ref BSPFile, 1, IndexList, Info);
tbTAG = null;
//Tag.Flush();
//Tag.Close();
}
}
//Create a new map header
//lbCurTag.Text = "Creating New Map....";
Application.DoEvents();
NewMap.PCHeader.Create();
string[] tmpName = scenario_tag.RelativePath.Split(new char[] { '\\' }, 256);
tmpName = tmpName[tmpName.Length - 1].Split(new char[] { '.' }, 256);
NewMap.PCHeader.MapName = tmpName[0];//otf.FileName.Split(new char[]{'/'},256 //"Cool";
//NewMap.PCHeader.Write(ref HeadFile);
//Rewrite indextable of meta offsets
//lbCurTag.Text = "Fixing Meta Offsets in Index Table....";
Application.DoEvents();
TmpPosSave = MetaFile.Position;
for (int sc = 0; sc < NewMap.PCIndexHeader.IndexItems.Length; sc++)
{
MetaFile.Seek(NewMap.PCIndexHeader.IndexItems[sc].Position, SeekOrigin.Begin);
NewMap.PCIndexHeader.IndexItems[sc].Write(ref MetaFile);
}
MetaFile.Seek(TmpPosSave, SeekOrigin.Begin);
//Create the new map file to begin construction of the new map.
FileInfo Map_info = new FileInfo(Application.StartupPath + NewMap.PCHeader.MapName + ".Map");
FileStream Map;
Map = Map_info.Open(FileMode.Create, FileAccess.ReadWrite);
//lbCurTag.Text = "Copying Data to new map file....";
Application.DoEvents();
//Write the header to the new map file
NewMap.PCHeader.Write(ref Map);
//Flush the tmp BSPFile to get FileSize.
BSPFile.Flush();
uint BSPFileSize = (uint)BSPFile.Length;
//Seek to the begining of the tmp bsp file
BSPFile.Seek(0, SeekOrigin.Begin);
//Copy the Tmp bsp file to the new map file
for (int bc = 0; bc < BSPFileSize; bc += 4)
{
byte[] copy = new byte[4];
BSPFile.Read(copy, 0, copy.Length);
Map.Write(copy, 0, copy.Length);
}
//Flush the Temp verts file to get File size;
VertsFile.Flush();
uint VertsFileSize = (uint)VertsFile.Length;
//Put Current Map Position in the indexheader, this sets the position of the verts in the map.
NewMap.PCIndexHeader.VertsOffset = (uint)Map.Position;
//seek to begining of the Verts file for coping to the new map file
VertsFile.Seek(0, SeekOrigin.Begin);
//Copy the verts to the map file
for (int bc = 0; bc < VertsFileSize; bc += 4)
{
byte[] copy = new byte[4];
VertsFile.Read(copy, 0, copy.Length);
Map.Write(copy, 0, copy.Length);
}
//Flush Indeices file to get size
IndicesFile.Flush();
uint IndicesFileSize = (uint)IndicesFile.Length;
//Put the Scnr index ID in the IndexHeader, you can move the scnr any were as long as you set this to the currect ID.
NewMap.PCIndexHeader.ScnrID = (uint)((NewMap.PCIndexHeader.IndexItems[0].IndexID2 << 16) + NewMap.PCIndexHeader.IndexItems[0].IndexID1);
//ajust the IndicesOffset with verts offset and map position
NewMap.PCIndexHeader.IndicesOffset = (uint)Map.Position - NewMap.PCIndexHeader.VertsOffset;
NewMap.PCIndexHeader.ModelAreaSize = VertsFileSize + IndicesFileSize;
//Seek to begining of IndicesFile for coping
IndicesFile.Seek(0, SeekOrigin.Begin);
//Copy Indices to new map file
for (int bc = 0; bc < IndicesFileSize; bc += 4)
{
byte[] copy = new byte[4];
IndicesFile.Read(copy, 0, copy.Length);
Map.Write(copy, 0, copy.Length);
}
//put the Current map position in the header so we know where the index header will be
NewMap.PCHeader.IndexOffset = (uint)Map.Position;
//Now we write the Index header to the map.
NewMap.PCIndexHeader.Write(ref Map);
//Flush the temp meta file so we can get the size.
MetaFile.Flush();
uint MetaFileSize = (uint)MetaFile.Length;
//seek to the begining of the temp meta file for coping to the new map file
MetaFile.Seek(0, SeekOrigin.Begin);
//Copy the meta file to the new map file.
for (int bc = 0; bc < MetaFileSize; bc += 4)
{
byte[] copy = new byte[4];
MetaFile.Read(copy, 0, copy.Length);
Map.Write(copy, 0, copy.Length);
}
//Now we fix the map version map size and rewrite it to the map.
Map.Flush();
NewMap.PCHeader.MapVersion = 0x07;
NewMap.PCHeader.MapSize = (uint)Map.Length;
NewMap.PCHeader.MetaSize = MetaFileSize + 0x28;
Map.Seek(NewMap.PCHeader.Position, SeekOrigin.Begin);
NewMap.PCHeader.Write(ref Map);
//Now close the files and delete the temp files.
VertsFile.Close();
IndicesFile.Close();
MetaFile.Flush();
MetaFile.Close();
BSPFile.Close();
Map.Close();
//FileStream TagFile;
//TagFile = Tag
}
}
