示例#1
0
            public void Read(ref FileStream FI)
            {
                Buffer = new byte[2048];
                FI.Read(Buffer, 0, Buffer.Length);
                FileSize              = BitConverter.ToUInt32(Buffer, 0x08);
                IndexOffset           = BitConverter.ToUInt32(Buffer, 0x10);
                MetaStart             = BitConverter.ToUInt32(Buffer, 0x14);
                OffsetToFirstObject   = IndexOffset + MetaStart;
                StringTableOffset     = BitConverter.ToUInt32(Buffer, 0x2c4);
                StringTableListOffset = BitConverter.ToUInt32(Buffer, 0x2cc);
                StringTableSize       = BitConverter.ToUInt32(Buffer, 0x2c8);
                StringTableListSize   = BitConverter.ToUInt32(Buffer, 0x2c0) * 4;
                ScriptStringsOffset   = BitConverter.ToUInt32(Buffer, 0x160);
                ScriptStringsCount    = BitConverter.ToUInt32(Buffer, 0x164);

                byte[] ScriptBuff = new byte[0x80];
                long   savpox     = FI.Position;

                ScriptStringArray = new string[0];
                FI.Seek((long)ScriptStringsOffset, System.IO.SeekOrigin.Begin);
                for (int i = 0; i < ScriptStringsCount; i += 1)
                {
                    FI.Read(ScriptBuff, 0, 0x80);
                    AppendString(ref ScriptStringArray, CompUtil.ReadString(ScriptBuff));
                }

                FI.Seek(savpox, System.IO.SeekOrigin.Begin);
            }
        public MemoryStream ConvertTag(string FileName)
        {
            //Open Tag and create a memeory stream//
            FileInfo   fi_FileInfo = new FileInfo(FileName);
            FileStream fs_File     = fi_FileInfo.Open(FileMode.Open, FileAccess.Read);

            byte[] inFileHeader = new byte[0x40];
            fs_File.Read(inFileHeader, 0, 0x40);
            byte[] inFileBuffer = new byte[fs_File.Length - 0x40];
            fs_File.Read(inFileBuffer, 0, inFileBuffer.Length);
            fs_File.Close();
            MemoryStream ms_inFile = new MemoryStream(inFileBuffer, 0, inFileBuffer.Length);

            //Create a memory stream for output tag//
            byte[]       outFileBuffer = new byte[inFileBuffer.Length];
            MemoryStream ms_outFile    = new MemoryStream(outFileBuffer, 0, outFileBuffer.Length);
            //Get the TagClass and open the MTSFReader//
            uint       TagClass = CompUtil.GetUInt(inFileHeader, 0x24);
            MTSFReader mr;

            mr = new MTSFReader();
            mr.MTSFRead("Core.Compiler.TAG_CONVERSION_SET.MTSF");
            TSFReader STSF = new TSFReader();

            STSF.TSF(ref mr, TagClass);
            //Now Convert the tag From ce to prom//
            Converter Convert = new Converter();

            Convert.TagStruct(ref STSF, ref ms_inFile, ref ms_outFile, 1, STSF.GetUName());
            ms_inFile.Close();
            return(ms_outFile);
        }
示例#3
0
            public void Create()
            {
                data      = new byte[0x800];
                BuildDate = new byte[32];
                string test = "01.10.12.2276";

                CompUtil.StringToByteArray(ref BuildDate, test);
            }
示例#4
0
        static public string GetTagLongName(uint TagType)
        {
            byte[] sf = new byte[4];
            sf = BitConverter.GetBytes(TagType);
            string Class    = CompUtil.GetTagClass(sf, 0);
            string LongName = (string)strConversionTable[Class];

            return(LongName);
        }
示例#5
0
 public void Read(ref FileStream FI)
 {
     data = new byte[0x800];
     FI.Read(data, 0, data.Length);
     CompUtil.GetUInt(data, 0x00, ref Head);
     CompUtil.GetUInt(data, 0x04, ref MapVersion);
     CompUtil.GetUInt(data, 0x08, ref MapSize);
     CompUtil.GetUInt(data, 0x10, ref IndexOffset);
 }
示例#6
0
 public void Read(ref FileStream FI)
 {
     StringBuffer  = new byte[StringBufferSize];
     OffsetsBuffer = new byte[OffsetsBufferSize];
     TagStrings    = new string[OffsetsBufferSize / 4];
     FI.Seek(StringOffset, System.IO.SeekOrigin.Begin);
     FI.Read(StringBuffer, 0, StringBuffer.Length);
     FI.Seek(OffsetsOffset, System.IO.SeekOrigin.Begin);
     FI.Read(OffsetsBuffer, 0, OffsetsBuffer.Length);
     for (int sc = 0; sc < (TagStrings.Length); sc += 1)
     {
         TagStrings[sc] = CompUtil.GetString(StringBuffer, OffsetsBuffer, (uint)sc);
     }
 }
示例#7
0
 public void Write(ref FileStream FO)
 {
     Position = FO.Position;
     CompUtil.PutUInt(ref data, 0x00, IndexMagic);
     CompUtil.PutUInt(ref data, 0x04, ScnrID);
     CompUtil.PutUInt(ref data, 0x08, 0xfafafafa);
     CompUtil.PutUInt(ref data, 0x0C, TagCount);
     CompUtil.PutUInt(ref data, 0x10, ModelCount1);
     CompUtil.PutUInt(ref data, 0x14, VertsOffset);
     CompUtil.PutUInt(ref data, 0x18, ModelCount2);
     CompUtil.PutUInt(ref data, 0x1C, IndicesOffset);
     CompUtil.PutUInt(ref data, 0x20, 0x74616773);
     FO.Write(data, 0, data.Length);
 }
示例#8
0
 public void Write(ref FileStream FO)
 {
     Position = FO.Position;
     CompUtil.PutUInt(ref data, 0x00, 0x68656164);
     CompUtil.PutUInt(ref data, 0x04, MapVersion);
     CompUtil.PutUInt(ref data, 0x08, MapSize);
     CompUtil.PutUInt(ref data, 0x10, IndexOffset);
     CompUtil.PutUInt(ref data, 0x14, MetaSize);
     CompUtil.PutUInt(ref data, 0x7FC, 0x666F6F74);
     Name = new byte[0x20];
     CompUtil.StringToByteArray(ref Name, MapName);
     Name.CopyTo(data, 0x20);
     BuildDate.CopyTo(data, 0x40);
     FO.Write(data, 0, data.Length);
 }
示例#9
0
 public void Write(ref FileStream FO)
 {
     Position = FO.Position;
     CompUtil.PutUInt(ref data, 0x00, TagClass1);
     CompUtil.SwapInt(ref data, 0x00);
     CompUtil.PutUInt(ref data, 0x04, TagClass2);
     CompUtil.SwapInt(ref data, 0x04);
     CompUtil.PutUInt(ref data, 0x08, TagClass3);
     CompUtil.SwapInt(ref data, 0x08);
     CompUtil.PutUShort(ref data, 0x0C, IndexID1);
     CompUtil.PutUShort(ref data, 0x0E, IndexID2);
     CompUtil.PutUInt(ref data, 0x10, StringOffset);
     CompUtil.PutUInt(ref data, 0x14, MetaOffset);
     CompUtil.PutUInt(ref data, 0x18, MetaDataID);
     CompUtil.PutUInt(ref data, 0x1C, 0x00000000);
     FO.Write(data, 0, data.Length);
 }
示例#10
0
        private void ExtractTag(int index)
        {
            FileStream fsBitmap = OptionsManager.GetBitmapStream(m_MapVersion);
            FileStream fsSound  = OptionsManager.GetSoundStream(m_MapVersion);

            //string TagClass = GetTagClass(BitConverter.GetBytes(HaloMap.IndexItems[index].Type1),0);

            //Loading Tag Long name and seting the map version folder
            //string ProcessTagFile = TagClass.Trim() + ".mag";
            //string MagfilePathRoot = "";
            string OutputPathRoot = "";

            switch (m_MapVersion)
            {
            case MapfileVersion.HALOPC:
                //MagfilePathRoot = Application.StartupPath + @"\Tag Structures\PcHalo\";
                OutputPathRoot = Application.StartupPath + @"\Games\Pc\Halo\";
                break;

            case MapfileVersion.HALOCE:
                //MagfilePathRoot = Application.StartupPath + @"\Tag Structures\CeHalo\";
                OutputPathRoot = Application.StartupPath + @"\Games\Pc\Halo\";
                break;

            case MapfileVersion.XHALO1:
                //MagfilePathRoot = Application.StartupPath + @"\Tag Structures\XHalo\";
                OutputPathRoot = Application.StartupPath + @"\Games\Xbox\Halo\";
                break;
            }

            //Creating Directorys for extracted tags;
            string[] Directorys = new string[256];
            string   DirSep     = @"\";

            Directorys = HaloMap.IndexItemStringList[index].Split(DirSep.ToCharArray(), 256);
            uint   Dircount = (uint)Directorys.Length - 1;
            string NewDirectoryStructure = "";

            for (uint Count = 0; Count < Dircount; Count += 1)
            {
                if (Directory.Exists(OutputPathRoot + NewDirectoryStructure + Directorys[Count]) == false)
                {
                    //Directory.CreateDirectory(OutputPathRoot + NewDirectoryStructure + Directorys[Count]);
                    NewDirectoryStructure += Directorys[Count] + @"\";
                }
                else
                {
                    NewDirectoryStructure += Directorys[Count] + @"\";
                }
            }

            MTSFReader mr;

            mr = new MTSFReader();
            mr.MTSFRead("Core.Compiler.HALO_PC_SET.MTSF");
            TSFReader STSF = new TSFReader();

            STSF.TSF(ref mr, CompUtil.RevUInt(HaloMap.IndexItems[index].Type1));
            //string ExtName = STSF.Name;

            //FileInfo fiout = new FileInfo(OutputPathRoot + HaloMap.IndexItemStringList[index]);
            MemoryStream msout = new MemoryStream();

            //msout = fiout.Open(FileMode.Create,FileAccess.ReadWrite);  //Grenadiac changed this to RW for archive hack
            TagHeader.SeekToTagDataStart(ref msout);

            fsin.Seek(HaloMap.IndexItems[index].MetaOffset, System.IO.SeekOrigin.Begin);

            byte   TabByte    = 0x09;
            string TabReplace = "";

            TabReplace += (char)TabByte;

            Struct.StructInfo TagInfo = new Struct.StructInfo();
            TagInfo.MapMagic       = HaloMap.Map_Magic;
            TagInfo.MapVersion     = HaloMap.MapHeader.Map_Version;
            TagInfo.SoundsFile     = fsSound;
            TagInfo.BitmapsFile    = fsBitmap;
            TagInfo.IndexItems     = HaloMap.IndexItems;
            TagInfo.TagMagic       = HaloMap.IndexItems[index].MetaMagic;
            TagInfo.IndicesOffset  = HaloMap.IndexHeader.Index_Offset;
            TagInfo.VerticesOffset = HaloMap.IndexHeader.Verts_Offset;
            TagInfo.CurrentIndex   = (uint)index;
            TagInfo.TagHeaderSize  = 0x40;
            // Create a new struct processor
            Struct MainStruct = new Struct();

            string[] Tags = null;
            MainStruct.DoProcessStruct(ref STSF, ref fsin, ref msout, 1, STSF.GetUName(), ref TagInfo, ref Tags, ref Tags);
            //******FIX ME ******//  Structure2 MainStruct = new Structure2();
            //******FIX ME ******//  MainStruct.StructureCS(HaloMap.IndexItems[index].MetaOffset,(uint)MagIndex,HaloMap.IndexItems[index].MetaMagic,HaloMap.Map_Magic,MagArray,1,fsin,msout,fsBitmap,fsSound,HaloMap.IndexHeader.Verts_Offset,HaloMap.IndexHeader.Index_Offset,HaloMap.MapHeader.Map_Version);
            //public void StructureCS(uint MetaOffset,uint MagIndex,uint OffsetMagic,uint MapMagic,string[] StructureArray,uint ChunkCount,FileStream MapFile,FileStream TagFile,FileStream BitmapFile,FileStream SoundFile,uint VerticesOffset,uint IndicesOffset,StreamWriter ObjFile,uint MapVersion)

            // Initialize and write out the PROM tag header
            TagHeader tag_hdr = new TagHeader();

            tag_hdr.TagClass0   = HaloMap.IndexItems[index].Type1;
            tag_hdr.TagClass1   = HaloMap.IndexItems[index].Type2;
            tag_hdr.TagClass2   = HaloMap.IndexItems[index].Type3;
            tag_hdr.GameVersion = m_MapVersion;
            tag_hdr.TagSize     = (int)msout.Position - TagHeader.PROM_HEADER_SIZE;
            tag_hdr.Write(ref msout);

            //Write out a zero-attachment header
            tag_hdr.SeekToAttachStart(ref msout);
            AttachmentHeader attach_hdr = new AttachmentHeader();

            attach_hdr.Write(ref msout);

            //GRENADIAC HACK to put tagfile into archive
            if (m_OutputArchive != null)
            {
                //m_OutputArchive.AddTagfileToArchive(HaloMap.IndexItemStringList[index], msout.GetBuffer(), (int)msout.Position);
                m_OutputArchive.AddFile(HaloMap.IndexItemStringList[index], GetSubArray(msout.GetBuffer(), 0, (int)msout.Position - 12));
            }


            msout.Close();
            fsBitmap.Close();
            fsSound.Close();
        }
示例#11
0
            public void Load(ref FileStream FI)
            {
                MapHeader = new H1_MapHeader();
                //IndexHeader = new H1_Index_Header();
                MapHeader.Load(ref FI);
                switch (MapHeader.Map_Version)
                {
                case 0x05:
                    IndexHeader = new IndexHeaderBase.XIndexHeader();
                    break;

                case 0x07:
                case 0x261:
                    IndexHeader = new IndexHeaderBase.IndexHeader();
                    break;
                }

                FI.Seek(MapHeader.Offset_To_Index, System.IO.SeekOrigin.Begin);
                IndexHeader.Load(ref FI);

                uint StartOfTags = (uint)FI.Position;//MapHeader.Offset_To_Index + 36 + 4;

                Map_Magic = IndexHeader.IndexMagic - StartOfTags;
                //FI.Seek(StartOfTags,System.IO.SeekOrigin.Begin);
                IndexItems          = new h1_Tag_Index_Item[IndexHeader.TagCount];
                IndexItemStringList = new string[IndexHeader.TagCount];
                uint BSPCount = 0;

                for (int ind = 0; ind < IndexHeader.TagCount; ind += 1)
                {
                    IndexItems[ind] = new h1_Tag_Index_Item();
                    IndexItems[ind].Load(ref FI);
                    if (IndexItems[ind].Type1 == 0x73627370) //Test for BSP tags
                    {
                        uint MapFileSavePos = (uint)FI.Position;
                        //Seek to Scnr
                        FI.Seek(IndexItems[0].MetaOffset, System.IO.SeekOrigin.Begin);
                        //Read SCNR header
                        byte[] SCNRHeader = new byte[1456];
                        FI.Read(SCNRHeader, 0, SCNRHeader.Length);
                        //uint BSPSectionChunkCount = BitConverter.ToUInt32(SCNRHeader,1444);
                        uint   BSPSectionOffset = BitConverter.ToUInt32(SCNRHeader, 1444 + 4) - Map_Magic;
                        byte[] BSPInfo          = new byte[32];
                        FI.Seek(BSPSectionOffset + (32 * BSPCount), System.IO.SeekOrigin.Begin);
                        FI.Read(BSPInfo, 0, BSPInfo.Length);
                        IndexItems[ind].MetaOffset = BitConverter.ToUInt32(BSPInfo, 0);
                        IndexItems[ind].MetaMagic  = BitConverter.ToUInt32(BSPInfo, 8) - IndexItems[ind].MetaOffset;

                        FI.Seek(IndexItems[ind].MetaOffset, SeekOrigin.Begin);
                        byte[] tmpBSPNormalHeader = new byte[0x18];
                        FI.Read(tmpBSPNormalHeader, 0, 0x18);
                        IndexItems[ind].MetaOffset = BitConverter.ToUInt32(tmpBSPNormalHeader, 0) - IndexItems[ind].MetaMagic;

                        IndexItems[ind].OffsetToString = IndexItems[ind].OffsetToString - Map_Magic;//BitConverter.ToUInt32(BSPInfo,20) - Map_Magic;//IndexItems[ind].OffsetToString - Map_Magic;
                        BSPCount += 1;
                        FI.Seek(MapFileSavePos, System.IO.SeekOrigin.Begin);
                    }
                    else
                    {
                        IndexItems[ind].MetaOffset     = IndexItems[ind].MetaOffset - Map_Magic;
                        IndexItems[ind].OffsetToString = IndexItems[ind].OffsetToString - Map_Magic;
                        IndexItems[ind].MetaMagic      = Map_Magic;
                    }
                }
                FilenameTable = new Hashtable((int)IndexHeader.TagCount);
                for (int strs = 0; strs < IndexHeader.TagCount; strs += 1)
                {
                    TSFReader STSF = new TSFReader();

                    STSF.TSF(ref mr, IndexItems[strs].Type1);

                    IndexItemStringList[strs] = CompUtil.StringLoader(ref FI, IndexItems[strs].OffsetToString) + STSF.Name;
                    STSF = null;
                    FilenameTable.Add(IndexItemStringList[strs], strs);
                }
            }
示例#12
0
        private void ExtractH2Tag(int index)
        {
            //Load Shared Map streams
            FileStream fsShared             = OptionsManager.GetHalo2SharedStream();
            FileStream fsSinglePlayerShared = OptionsManager.GetHalo2SinglePlayerSharedStream();
            FileStream fsMainMenu           = OptionsManager.GetHalo2MainMenuStream();

            //Tag Header loader start
            string TagClass = CompUtil.GetTagClass(BitConverter.GetBytes(Halo2Map.IndexItem[index].TagType), 0);

            if (TagClass == "<fx>")
            {
                TagClass = "FXFX";
            }

            byte[] TagHeaderBuffer = new byte[64];
            OptionsManager.GetGuerillaHeader(m_MapVersion, TagClass, TagHeaderBuffer);

            string MagfilePathRoot = Application.StartupPath + @"\Tag Structures\Halo2\";
            string OutputPathRoot  = Application.StartupPath + @"\Games\Xbox\Halo2\";


            //Creating Directorys for extacted tag
            string[] Directorys = new string[256];
            string   DirSep     = @"\";

            Directorys = Halo2Map.StringTable.TagStrings[index].Split(DirSep.ToCharArray(), 256);
            uint   Dircount = (uint)Directorys.Length - 1;
            string NewDirectoryStructure = "";

            for (uint Count = 0; Count < Dircount; Count += 1)
            {
                if (Directory.Exists(OutputPathRoot + NewDirectoryStructure + Directorys[Count]) == false)
                {
                    Directory.CreateDirectory(OutputPathRoot + NewDirectoryStructure + Directorys[Count]);
                    NewDirectoryStructure += Directorys[Count] + @"\";
                }
                else
                {
                    NewDirectoryStructure += Directorys[Count] + @"\";
                }
            }

            //Loading Tag Long name from mag file
            string       ProcessTagFile = TagClass.Trim() + ".mag";
            StreamReader MagReader      = new StreamReader(MagfilePathRoot + ProcessTagFile);
            string       InLine         = MagReader.ReadLine();

            //Create the Tag on disk
            string SplitChar = ".";

            string[] FixTagName = Halo2Map.StringTable.TagStrings[index].Split(SplitChar.ToCharArray(), 2);
            //FileInfo fiout = new FileInfo(OptionsManager.GetExtractPath(m_MapVersion) + FixTagName[0] + "." + InLine.Trim());
            string       FileName = FixTagName[0] + "." + InLine.Trim();
            MemoryStream msout    = new MemoryStream();

            TagHeader.SeekToTagDataStart(ref msout);

            // Create a tag table for
            byte[] TagTable = new byte[TagCount * 16];
            fsin.Seek(Halo2Map.IndexHeader.OffsetToTags, System.IO.SeekOrigin.Begin);
            fsin.Read(TagTable, 0, TagTable.Length);

            // Move File pointer to start of tag
            fsin.Seek(Halo2Map.IndexItem[index].TagOffset, System.IO.SeekOrigin.Begin);

            // Create the Tab char to provent errors
            byte   TabByte    = 0x09;
            string TabReplace = "";

            TabReplace += (char)TabByte;

            // Read the Structure from the mag file
            string[] MagArray = new string[256];
            int      MagIndex = 0;

            do
            {
                InLine             = MagReader.ReadLine();
                MagArray[MagIndex] = InLine.Replace(TabReplace, "").ToLower().Trim();
                MagIndex           = MagIndex + 1;
            }while(MagReader.Peek() != -1);
            MagReader.Close();

            // Create debug stream writer
            //StreamWriter DebugFile;
            //DebugFile = new StreamWriter(msout.Name + ".txt" );

            // Start the Tags extraction
            Halo2Structure MainStruct = new Halo2Structure();

            //if(TagClass == "sbsp")
            MainStruct.StructureCS((uint)MagIndex, Halo2Map.IndexItem[index].TagOffsetMagic, Halo2Map.IndexItem[index].TagMagic, MagArray, 1, fsin, msout, fsShared, 0, 0, Halo2Map.StringTable.StringBuffer, Halo2Map.StringTable.OffsetsBuffer, fsSinglePlayerShared, fsMainMenu, fsShared, Halo2Map.MapHeader.MetaStart, Halo2Map.MapHeader.FileSize, null, TagTable, Halo2Map.MapHeader.ScriptStringArray);
            //DebugFile.Flush();
            //DebugFile.Close();
            //For Refernce only
            //public void StructureCS(uint MagIndex,uint OffsetMagic,uint MapMagic,string[] StructureArray,uint ChunkCount,FileStream MapFile,FileStream TagFile,FileStream BitmapFile,uint VerticesOffset,uint IndicesOffset,byte[] StringTable,byte[] StringTableOffsetList,FileStream single_player_shared_map,FileStream mainmenu_map,FileStream shared_map,uint StartOfTags,uint MapSize,StreamWriter DebugFile,byte[] TagTable,string[] ScriptStringArray)

            // Initialize and write out the PROM tag header
            TagHeader tag_hdr = new TagHeader();

            tag_hdr.TagClass0   = Halo2Map.IndexItem[index].TagType;
            tag_hdr.GameVersion = m_MapVersion;
            tag_hdr.TagSize     = (int)msout.Position - TagHeader.PROM_HEADER_SIZE;
            tag_hdr.Write(ref msout);

            //Write out a zero-attachment header
            tag_hdr.SeekToAttachStart(ref msout);
            AttachmentHeader attach_hdr = new AttachmentHeader();

            attach_hdr.Write(ref msout);

            if (m_OutputArchive != null)
            {
                //m_OutputArchive.AddTagfileToArchive(HaloMap.IndexItemStringList[index], msout.GetBuffer(), (int)msout.Position);
                m_OutputArchive.AddFile(FileName, GetSubArray(msout.GetBuffer(), 0, (int)msout.Position - 12));
            }

            msout.Close();
            fsShared.Close();
            fsSinglePlayerShared.Close();
            fsMainMenu.Close();
        }
示例#13
0
        public void DoProcessMeta(ref TSFReader sr, MemoryStream FI, ref FileStream FO, ref FileStream BSPFile, uint Count, string[] IndexStrings, StructInfo Info, ref XBoxHaloMap.sXBoxHalo XBoxMap, ref IndexBuilder IndexBuild)
        {
            TabReplace += (char)TabByte;
            Name        = sr.GetUName();
            Size        = sr.GetSOC();

            TagBuff = new byte[Size * Count];
            FI.Read(TagBuff, 0, TagBuff.Length);
            long StructPosition = FO.Position;

            FO.Write(TagBuff, 0, TagBuff.Length);
            uint StartOfStruct = sr.Position;
            uint sc            = 0;

            bool ExitStruct = false;

            do
            {
                do
                {
                    sr.Read();
                    switch (sr.GetCMD())
                    {
                    case TSFReader.TSFStruct:                             // "struct":
                        #region Structure
                        uint ChildCount = CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)));
                        if (ChildCount != 0)
                        {
                            XBoxMeta Child = new XBoxMeta();
                            CompUtil.PutUInt(ref TagBuff, (uint)(sr.GetOIP() + 4 + (sc * Size)), (uint)(FO.Position + Info.TagMagic));
                            Child.DoProcessMeta(ref sr, FI, ref FO, ref BSPFile, ChildCount, IndexStrings, Info, ref XBoxMap, ref IndexBuild);
                            CompUtil.FixIntPosition(ref FO);
                        }
                        else
                        {
                            sr.SeekAheadTo(0xA7, sr.GetUName());

                            //sr.SeekAheadTo("end " + CMD[2]);
                            //sr.Seek(sr.Position + 1);
                        }
                        break;

                        #endregion
                    case TSFReader.TSFBSPTagRef:                          // "bspstagref":
                    case TSFReader.TSFTagRef:                             // "tagref":
                        #region TagRefernce
                        uint tStringSize = 0;
                        CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x08, ref tStringSize);
                        if (tStringSize != 0x00)
                        {
                            CompUtil.PutUInt(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x04, 0x00000000);
                            CompUtil.PutUInt(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x08, 0x00000000);
                            uint   TagClass       = CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)));
                            string TagClassString = CompUtil.GetTagClassRev(BitConverter.GetBytes(TagClass), 0);
                            byte[] tmpStr         = new byte[tStringSize + 1];

                            FI.Read(tmpStr, 0, tmpStr.Length);
                            string tag = CompUtil.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 = CompUtil.GetTagClassRev(BitConverter.GetBytes(Info.Items[t].TagClass1), 0);
                                if (testClass == TagClassString && test[0] == tag)
                                {
                                    con = true;
                                }
                                else
                                {
                                    t += 1;
                                }
                            }while (con == false);                                    // testClass != TagClass);
                            CompUtil.SwapInt(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x00);
                            CompUtil.PutUInt(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x04, Info.Items[t].StringOffset);
                            CompUtil.PutUShort(ref TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x0C, (ushort)Info.Items[t].IndexID1);
                            CompUtil.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];
                                CompUtil.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);
                                Trace.WriteLine(tag + ".sbsp" + "   Hello I'm your bsp");
                                TagFileName tfnTAG = new TagFileName(tag + "." + tmpSTSF.Name, MapfileVersion.XHALO1);
                                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)(0x819a5800 - BSPFileSize);
                                Info.TagMagic = tmpMagic;
                                CompUtil.PutUInt(ref TagBuff, 0x08 + (sc * Size), tmpMagic);
                                //IndexBuild.XBoxMapData.XBSPVerts.Finish();
                                uint CompoundSize = (uint)IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets.Length + (uint)IndexBuild.XBoxMapData.XBSPVerts.LIndirectOffsets.Length + (uint)IndexBuild.XBoxMapData.XBSPVerts.ModelData.Length;
                                CompUtil.PutUInt(ref BspHeader, 0x00 + (sc * Size), 0x18 + CompoundSize + tmpMagic);
                                CompUtil.PutUInt(ref BspHeader, 0x04 + (sc * Size), IndexBuild.XBoxMapData.XBSPVerts.DataCount);
                                CompUtil.PutUInt(ref BspHeader, 0x08 + (sc * Size), 0x18 + tmpMagic);
                                CompUtil.PutUInt(ref BspHeader, 0x0C + (sc * Size), IndexBuild.XBoxMapData.XBSPVerts.DataCount);
                                CompUtil.PutUInt(ref BspHeader, 0x10 + (sc * Size), (uint)((IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets.Length + 0x18) + tmpMagic));
                                CompUtil.PutUInt(ref BspHeader, 0x14 + (sc * Size), 0x73627370);
                                long BSPHeaderPos = BSPFile.Position;
                                BSPFile.Write(BspHeader, 0, BspHeader.Length);

                                //IndexBuild.XBoxMapData.XBSPVerts.FixOffsets((uint)BSPFile.Position + (uint)IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets.Length + (uint)IndexBuild.XBoxMapData.XBSPVerts.LIndirectOffsets.Length,Info.TagMagic);
                                long savepos = BSPFile.Position;
                                BSPFile.Write(IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets, 0, IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets.Length);
                                BSPFile.Write(IndexBuild.XBoxMapData.XBSPVerts.LIndirectOffsets, 0, IndexBuild.XBoxMapData.XBSPVerts.LIndirectOffsets.Length);
                                CompUtil.Fix0x20Position(ref BSPFile);

                                IndexBuild.XBoxMapData.XBSPVerts.FixOffsets((uint)BSPFile.Position, Info.TagMagic);
                                BSPFile.Seek(savepos, SeekOrigin.Begin);
                                IndexBuild.XBoxMapData.XBSPVerts.VLMapOffset = (uint)BSPFile.Position + (uint)IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets.Length;
                                BSPFile.Write(IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets, 0, IndexBuild.XBoxMapData.XBSPVerts.VIndirectOffsets.Length);
                                IndexBuild.XBoxMapData.XBSPVerts.ILMapOffset = (uint)BSPFile.Position + (uint)IndexBuild.XBoxMapData.XBSPVerts.LIndirectOffsets.Length;
                                BSPFile.Write(IndexBuild.XBoxMapData.XBSPVerts.LIndirectOffsets, 0, IndexBuild.XBoxMapData.XBSPVerts.LIndirectOffsets.Length);
                                CompUtil.Fix0x20Position(ref BSPFile);

                                BSPFile.Write(IndexBuild.XBoxMapData.XBSPVerts.ModelData, 0, IndexBuild.XBoxMapData.XBSPVerts.ModelData.Length);

                                long BSPSavPos = BSPFile.Position;
                                CompUtil.PutUInt(ref BspHeader, 0x00, (uint)(BSPFile.Position + tmpMagic));
                                BSPFile.Seek(BSPHeaderPos, SeekOrigin.Begin);
                                BSPFile.Write(BspHeader, 0, BspHeader.Length);
                                BSPFile.Seek(BSPSavPos, SeekOrigin.Begin);

                                XBoxMeta BspMeta = new XBoxMeta();

                                BspMeta.DoProcessMeta(ref tmpSTSF, tbTAG.Stream, ref BSPFile, ref BSPFile, 1, IndexStrings, Info, ref XBoxMap, ref IndexBuild);
                                CompUtil.FixIntPosition2K(ref BSPFile);

                                CompUtil.PutUInt(ref TagBuff, 0x04 + (sc * Size), (uint)(CurrentPosition + BSPFile.Position));
                                //BspMetaFile.Close();
                                tbTAG         = null;
                                Info.TagMagic = SaveTagMagic;
                                int a = 0;
                            }
                        }
                        break;

                        #endregion
                    case TSFReader.TSFInternalRaw:                                                   // "internalraw":
                        #region InternalRaw
                        uint RawSize = CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size))); //Compile Mag.Map
                        if (RawSize == 0)
                        {
                            break;
                        }
                        uint RawOffset = CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + 0x0c + (sc * Size)));                                    //Tag Text
                        CompUtil.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);
                        CompUtil.FixIntPosition(ref FO);
                        tmp = null;
                        break;

                        #endregion
                    case TSFReader.TSFBitmapRaw:                             // "bitmapraw":
                        #region BitmapRaw
                        MemoryStream BMD;
                        uint         TiffSize   = 0; CompUtil.GetUInt(TagBuff, 0x1C, ref TiffSize);
                        byte[]       TiffBuffer = new byte[TiffSize];
                        FI.Read(TiffBuffer, 0, TiffBuffer.Length);
                        uint BitmapSize = CompUtil.GetUInt(TagBuff, 0x30);
                        TiffBuffer = new byte[BitmapSize];
                        FI.Read(TiffBuffer, 0, TiffBuffer.Length);
                        BMD = new MemoryStream(TiffBuffer);

                        uint   BitMapStructCount  = CompUtil.GetUInt(TagBuff, 0x60);
                        uint   BitMapStructOffset = CompUtil.GetUInt(TagBuff, 0x64);
                        byte[] tmpBMS             = new byte[BitMapStructCount * 0x30];
                        long   sv = FI.Position;
                        FI.Seek((long)BitMapStructOffset, SeekOrigin.Begin);
                        FI.Read(tmpBMS, 0, tmpBMS.Length);

                        for (int i = 0; i < BitMapStructCount; i++)
                        {
                            uint BitMapDataSize = CompUtil.GetUInt(tmpBMS, (uint)(0x1C + (i * 0x30)));
                            uint svBmPos        = (uint)BSPFile.Position + 0x800;
                            CompUtil.PutUInt(ref tmpBMS, (uint)(0x18 + (i * 0x30)), (uint)svBmPos);
                            byte[] tmpBuff = new byte[BitMapDataSize];
                            BMD.Read(tmpBuff, 0, tmpBuff.Length);
                            BSPFile.Write(tmpBuff, 0, tmpBuff.Length);
                            CompUtil.Fix0x100Position(ref BSPFile);
                            svBmPos += BitMapDataSize;
                        }
                        FI.Seek((long)BitMapStructOffset, SeekOrigin.Begin);
                        FI.Write(tmpBMS, 0, tmpBMS.Length);
                        FI.Seek(sv, SeekOrigin.Begin);
                        //BSPFile.Write(TiffBuffer,0,TiffBuffer.Length);
                        //Fix0x100Position(ref BSPFile);
                        TiffBuffer = null;
                        break;

                        #endregion
                    case TSFReader.TSFRawXModelData:                             // "XBoxModelData":
                        #region XModelData
                        uint   XTrueVerticesSize   = (CompUtil.GetUInt(TagBuff, 88 + (sc * Size))) * 32;
                        uint   XTrueIndicesSize    = (((CompUtil.GetUInt(TagBuff, 72 + (sc * Size))) / 3) + 1) * 6;
                        uint   XNewIndicesDataSize = (CompUtil.GetUInt(TagBuff, 72 + (sc * Size)) / 3) + 1;
                        uint   XTrueVerticesOffset = CompUtil.GetUInt(TagBuff, 100 + (sc * Size)) - Info.MapMagic;
                        uint   XSaveMapFilePos     = (uint)FI.Position;                          //MapFile.Position;
                        byte[] XModelHeader        = new byte[16];

                        //uint XTrueVerticesOffset = GetUInt(TagBuff,100 + (sc * Size)) - Info.MapMagic;
                        CompUtil.PutUInt(ref TagBuff, 100 + (sc * Size), XBoxMap.IndirectVerts + Info.MapMagic);
                        //uint XTrueIndicesOffset = GetUInt(TagBuff, 80+ (sc * Size)) - Info.MapMagic;
                        CompUtil.PutUInt(ref TagBuff, 80 + (sc * Size), XBoxMap.IndirectIndices + Info.MapMagic);
                        XBoxMap.IndirectVerts   += 0x0c;
                        XBoxMap.IndirectIndices += 0x0c;
                        CompUtil.PutUInt(ref TagBuff, 0x4c + (sc * Size), IndexBuild.XBoxMapData.XIndices.GetOffset());
                        byte[] RawXModelBuffer = new byte[XTrueVerticesSize];
                        FI.Read(RawXModelBuffer, 0, (int)XTrueVerticesSize);
                        byte[] XTestBuffer = new byte[6];
                        RawXModelBuffer = new byte[XTrueIndicesSize];
                        FI.Read(RawXModelBuffer, 0, RawXModelBuffer.Length);
                        FI.Read(XTestBuffer, 0, 6);
                        if (XTestBuffer[4] == 0xff)
                        {
                            XTrueIndicesSize += 6;
                        }
                        else
                        {
                            FI.Seek(FI.Position - 6, SeekOrigin.Begin);
                        }
                        break;

                        #endregion
                    case TSFReader.TSFBSPModel:                             // "bspmodel":
                        #region BspModel
                        uint UnCompressedVerts       = sr.GetOIP();
                        uint CompressedVerts         = sr.GetSOC();
                        uint UnCompressedVertsOffset = sr.GetOIP();
                        //uint VertsOffset = GetUInt(TagBuff,CompressedVerts);
                        uint TrueVertCount            = CompUtil.GetUInt(TagBuff, 180 + (sc * Size));
                        uint TrueLightMapDataCount    = CompUtil.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];
                        uint PotLuck  = IndexBuild.XBoxMapData.XBSPVerts.CurrentOffset;                         // + 0x800;
                        uint VOOffset = 0xB4;
                        uint LOOffset = 0xC8;
                        IndexBuild.XBoxMapData.XBSPVerts.VLMapOffset -= 0x0c;
                        CompUtil.PutUInt(ref TagBuff, VOOffset + 0x0c + (sc * Size), (uint)(IndexBuild.XBoxMapData.XBSPVerts.VLMapOffset + Info.TagMagic));
                        IndexBuild.XBoxMapData.XBSPVerts.ILMapOffset -= 0x0c;
                        CompUtil.PutUInt(ref TagBuff, LOOffset + 0x0c + (sc * Size), (uint)(IndexBuild.XBoxMapData.XBSPVerts.ILMapOffset + Info.TagMagic));
                        PotLuck += 0x0c;
                        IndexBuild.XBoxMapData.XBSPVerts.CurrentOffset = PotLuck;
                        CompUtil.PutUInt(ref TagBuff, 0xF8 + (sc * Size), IndexBuild.XBoxMapData.XBSPVerts.GetVOffset());
                        //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;

                        #endregion
                    case TSFReader.TSFResource:                             // "resources":
                        #region Resources
                        ushort rStringSize = CompUtil.GetUShort(TagBuff, 0x06 + (sc * Size));
                        if (rStringSize != 0x00)
                        {
                            uint   TagClassFlag    = CompUtil.GetUShort(TagBuff, 0x00 + (sc * Size));
                            uint   TagResouceIndex = CompUtil.GetUShort(TagBuff, 0x02 + (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 = CompUtil.ReadString(tmpStr, 0);
                            Trace.WriteLine(tag + "." + TagClassString + "      PRIndex" + Convert.ToString(TagResouceIndex, 10));
                            //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 = CompUtil.GetTagClass(BitConverter.GetBytes(Info.Items[t].TagClass1), 0);
                                if (testClass == TagClassString && test[0] == tag)
                                {
                                    con = true;
                                }
                                else
                                {
                                    t += 1;
                                }
                            }while (con == false);
                            CompUtil.PutUShort(ref TagBuff, (uint)(0x04 + (sc * Size)), (ushort)Info.Items[t].IndexID1);
                            CompUtil.PutUShort(ref TagBuff, (uint)(0x06 + (sc * Size)), (ushort)Info.Items[t].IndexID2);
                        }
                        break;

                        #endregion
                    case TSFReader.TSFSoundData:                             // "sounddata":
                        #region SoundData
                        uint   sRawSize   = CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)));
                        uint   sRawOffset = CompUtil.GetUInt(TagBuff, (uint)(sr.GetUName() + 4 + (sc * Size)));
                        byte[] stmp       = new byte[sRawSize];
                        uint   svSndPos   = (uint)BSPFile.Position + 0x800;
                        CompUtil.PutUInt(ref TagBuff, (uint)(sr.GetUName() + 4 + (sc * Size)), svSndPos);
                        FI.Read(stmp, 0, stmp.Length);
                        BSPFile.Write(stmp, 0, stmp.Length);
                        CompUtil.Fix0x100Position(ref BSPFile);
                        stmp = null;
                        break;

                        #endregion
                    case TSFReader.TSFEnd:                             // "end":
                        #region EndStructure
                        if (sr.GetOIP() == Name)
                        {
                            ExitStruct = true;
                        }
                        else
                        {
                            ExitStruct = false;
                        }
                        break;
                        #endregion
                    }
                }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);
        }
示例#14
0
        public static void Build()
        {
            TagFileName  scenario_tag = ProjectManager.ScenarioTagFileName;           //new TagFileName(@"levels\test\beavercreek\beavercreek.scenario",MapfileVersion.XHALO1);
            IndexBuilder IndexBuild   = new IndexBuilder();
            string       BasFolder    = Application.StartupPath + @"\Extracted Tags\";
            string       StructFolder = Application.StartupPath + @"\Tag Structures\PcHalo\";

            if (true)
            {
                //Create the index table
                Application.DoEvents();
                string[] IndexList           = IndexBuild.BuildIndex(scenario_tag.RelativePath, BasFolder, StructFolder, MapfileVersion.XHALO1);
                XBoxHaloMap.sXBoxHalo NewMap = new XBoxHaloMap.sXBoxHalo();
                NewMap.XBoxIndexHeader.Create((uint)IndexList.Length);
                NewMap.XBoxIndexHeader.IndexMagic = 0x803a6024;                 //0x40440028;
                uint StringTableSize = 0;
                //Fixing index items
                ushort gt = 0xE174;
                Application.DoEvents();

                for (int sc = 0; sc < IndexList.Length; sc++)
                {
                    TagFileName tfnTAG = new TagFileName(IndexList[sc], MapfileVersion.XHALO1);
                    TagBase     tbTAG  = new TagBase();
                    tbTAG.LoadTagBuffer(tfnTAG);

                    NewMap.XBoxIndexHeader.IndexItems[sc].Create();
                    NewMap.XBoxIndexHeader.IndexItems[sc].TagClass1  = CompUtil.SwapUInt(tbTAG.Header.TagClass0);
                    NewMap.XBoxIndexHeader.IndexItems[sc].TagClass2  = CompUtil.SwapUInt(tbTAG.Header.TagClass1);
                    NewMap.XBoxIndexHeader.IndexItems[sc].TagClass3  = CompUtil.SwapUInt(tbTAG.Header.TagClass2);
                    NewMap.XBoxIndexHeader.IndexItems[sc].IndexID1   = (ushort)sc;
                    NewMap.XBoxIndexHeader.IndexItems[sc].IndexID2   = gt;
                    NewMap.XBoxIndexHeader.IndexItems[sc].NameString = IndexList[sc];
                    if (tbTAG.Header.TagClass0 == 0x70736273 || tbTAG.Header.TagClass0 == 0x73627370)
                    {
                        NewMap.XBoxIndexHeader.IndexItems[sc].MetaSize = IndexBuild.BSPSizes[0];
                    }
                    else
                    {
                        NewMap.XBoxIndexHeader.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.XBoxIndexHeader.IndexItems[sc].String = new byte[RemoveExt[0].Length + 1];
                    HaloPCMAP.StringToByteArray(ref NewMap.XBoxIndexHeader.IndexItems[sc].String, RemoveExt[0]);
                    StringTableSize += (uint)(IndexList[sc].Length + 1);
                    tbTAG            = null;
                }
                //Creating the temp files for map building
                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);

                Application.DoEvents();

                //writing the index table the temp files
                for (int sc = 0; sc < NewMap.XBoxIndexHeader.IndexItems.Length; sc++)
                {
                    NewMap.XBoxIndexHeader.IndexItems[sc].Write(ref MetaFile);
                }
                //Rewriting index items to temp file to fix string offsets.
                Application.DoEvents();

                for (int sc = 0; sc < NewMap.XBoxIndexHeader.IndexItems.Length; sc++)
                {
                    NewMap.XBoxIndexHeader.IndexItems[sc].StringOffset = (uint)MetaFile.Position + NewMap.XBoxIndexHeader.IndexMagic;
                    MetaFile.Write(NewMap.XBoxIndexHeader.IndexItems[sc].String, 0, NewMap.XBoxIndexHeader.IndexItems[sc].String.Length);
                }
                CompUtil.FixIntPosition(ref MetaFile);
                //save MetaFile position to return for meta writing.
                long TmpPosSave = MetaFile.Position;
                Application.DoEvents();

                for (int sc = 0; sc < NewMap.XBoxIndexHeader.IndexItems.Length; sc++)
                {
                    MetaFile.Seek(NewMap.XBoxIndexHeader.IndexItems[sc].Position, SeekOrigin.Begin);
                    NewMap.XBoxIndexHeader.IndexItems[sc].Write(ref MetaFile);
                }
                //restore position for meta writing
                #region ModelData
                MetaFile.Seek(TmpPosSave, SeekOrigin.Begin);
                NewMap.XBoxIndexHeader.VertsOffset = (uint)MetaFile.Position + NewMap.XBoxIndexHeader.IndexMagic;
                NewMap.XBoxIndexHeader.ModelCount1 = (uint)IndexBuild.XBoxMapData.XVerts.ModelCount;
                NewMap.IndirectVerts = (uint)MetaFile.Position;
                IndexBuild.XBoxMapData.XVerts.FixOffsets((uint)MetaFile.Position, NewMap.XBoxIndexHeader.IndexMagic);
                MetaFile.Write(IndexBuild.XBoxMapData.XVerts.IndirectOffsets, 0, IndexBuild.XBoxMapData.XVerts.IndirectOffsets.Length);
                MetaFile.Write(IndexBuild.XBoxMapData.XVerts.Verts, 0, IndexBuild.XBoxMapData.XVerts.Verts.Length);
                NewMap.XBoxIndexHeader.ModelCount2   = (uint)IndexBuild.XBoxMapData.XIndices.ModelCount;
                NewMap.XBoxIndexHeader.IndicesOffset = (uint)MetaFile.Position + NewMap.XBoxIndexHeader.IndexMagic;
                NewMap.IndirectIndices = (uint)MetaFile.Position;
                IndexBuild.XBoxMapData.XIndices.FixOffsets((uint)MetaFile.Position, NewMap.XBoxIndexHeader.IndexMagic);
                MetaFile.Write(IndexBuild.XBoxMapData.XIndices.IndirectOffsets, 0, IndexBuild.XBoxMapData.XIndices.IndirectOffsets.Length);
                MetaFile.Write(IndexBuild.XBoxMapData.XIndices.Verts, 0, IndexBuild.XBoxMapData.XIndices.Verts.Length);
                #endregion
                //Add info to the Meta info struct
                XBoxMeta.StructInfo Info = new XBoxMeta.StructInfo();
                Info.MapMagic      = NewMap.XBoxIndexHeader.IndexMagic;
                Info.TagMagic      = NewMap.XBoxIndexHeader.IndexMagic;
                Info.StructurePath = StructFolder;
                Info.TagsPath      = BasFolder;
                Info.Items         = NewMap.XBoxIndexHeader.IndexItems;
                //Starts processing meta and writing it to the meta file
                Application.DoEvents();

                for (int sc = 0; sc < NewMap.XBoxIndexHeader.IndexItems.Length; sc++)
                {
                    if (NewMap.XBoxIndexHeader.IndexItems[sc].TagClass1 != 0x70736273)                     //   70736273)
                    {
                        XBoxMeta Meta = new XBoxMeta();
                        Trace.WriteLine("Meta Processor: " + IndexList[sc]);
                        TagFileName tfnTAG = new TagFileName(IndexList[sc], MapfileVersion.XHALO1);
                        TagBase     tbTAG  = new TagBase();
                        tbTAG.LoadTagBuffer(tfnTAG);

                        MTSFReader mr = new MTSFReader();
                        mr.MTSFRead("Core.Compiler.HALO_PC_SET.MTSF");

                        TSFReader STSF = new TSFReader();

                        STSF.TSF(ref mr, tbTAG.Header.TagClass0);

                        HaloPCMAP.FixIntPosition(ref MetaFile);
                        Info.CurrentOffset = (uint)MetaFile.Position;
                        NewMap.XBoxIndexHeader.IndexItems[sc].MetaOffset = (uint)(MetaFile.Position + NewMap.XBoxIndexHeader.IndexMagic);

                        Meta.DoProcessMeta(ref STSF, tbTAG.Stream, ref MetaFile, ref BSPFile, 1, IndexList, Info, ref NewMap, ref IndexBuild);

                        tbTAG = null;
                    }
                }
                //Create a new map header
                Application.DoEvents();

                NewMap.XBoxHeader.Create();
                string[] tmpName = scenario_tag.RelativePath.Split(new char[] { '\\' }, 256);
                tmpName = tmpName[tmpName.Length - 1].Split(new char[] { '.' }, 256);
                NewMap.XBoxHeader.MapName = tmpName[0];                //otf.FileName.Split(new char[]{'/'},256   //"Cool";
                //Rewrite indextable of meta offsets
                Application.DoEvents();

                TmpPosSave = MetaFile.Position;
                for (int sc = 0; sc < NewMap.XBoxIndexHeader.IndexItems.Length; sc++)
                {
                    MetaFile.Seek(NewMap.XBoxIndexHeader.IndexItems[sc].Position, SeekOrigin.Begin);
                    NewMap.XBoxIndexHeader.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.XBoxHeader.MapName + ".Map");
                FileStream Map;
                Map = Map_info.Open(FileMode.Create, FileAccess.ReadWrite);

                Application.DoEvents();

                //Write the header to the new map file
                NewMap.XBoxHeader.Write(ref Map);
                //Flush the tmp BSPFile to get FileSize.
                CompUtil.FixIntPosition2K(ref BSPFile);
                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 += 0x800)
                {
                    byte[] copy = new byte[0x800];
                    BSPFile.Read(copy, 0, copy.Length);
                    Map.Write(copy, 0, copy.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.XBoxIndexHeader.ScnrID = (uint)((NewMap.XBoxIndexHeader.IndexItems[0].IndexID2 << 16) + NewMap.XBoxIndexHeader.IndexItems[0].IndexID1);
                //put the Current map position in the header so we know where the index header will be
                NewMap.XBoxHeader.IndexOffset = (uint)Map.Position;
                //Now we write the Index header to the map.
                NewMap.XBoxIndexHeader.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 += 0x800)
                {
                    byte[] copy = new byte[0x800];
                    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.XBoxHeader.MapVersion = 0x05;
                NewMap.XBoxHeader.MapSize    = (uint)Map.Length;
                NewMap.XBoxHeader.MetaSize   = MetaFileSize + 0x24;
                Map.Seek(NewMap.XBoxHeader.Position, SeekOrigin.Begin);
                NewMap.XBoxHeader.Write(ref Map);

                //Now close the files and delete the temp files.
                MetaFile.Flush();
                MetaFile.Close();
                File.Delete(MetaFile.Name);
                BSPFile.Close();
                File.Delete(BSPFile.Name);
                Map.Close();
            }
        }
示例#15
0
 public string GetString()
 {
     return(CompUtil.ReadString(String, 0));
 }
        public void TagStruct(ref TSFReader sr, ref MemoryStream FI, ref MemoryStream FO, uint Count, ushort uName)
        {
            long MapPosSave;

            TabReplace += (char)TabByte;
            Name        = sr.GetUName();
            Size        = sr.GetSOC();
            TagBuff     = new byte[Size * Count];
            FI.Read(TagBuff, 0, TagBuff.Length);
            long StructPosition = FO.Position;

            FO.Write(TagBuff, 0, TagBuff.Length);
            uint StartOfStruct = sr.Position;
            uint sc            = 0;
            bool ExitStruct    = false;

            do
            {
                do
                {
                    sr.Read();
                    switch (sr.GetCMD())
                    {
                    case TSFReader.TSFStruct:                                    // 0xA0: //Struct
                        #region Structure
                        uint ChildCount = CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP()) + (sc * Size));
                        if (sr.GetUName() == 0xffff)
                        {
                            ChildCount = 0;
                            CompUtil.PutUInt(ref TagBuff, (uint)(sr.GetOIP()) + (sc * Size), 0);
                        }
                        if (ChildCount != 0)
                        {
                            Converter Child = new Converter();
                            Child.TagStruct(ref sr, ref FI, ref FO, ChildCount, sr.GetUName());
                        }
                        else
                        {
                            sr.SeekAheadTo(0xA7, sr.GetUName());
                        }
                        break;

                        #endregion
                    case TSFReader.TSFBSPTagRef:                                 // 0xA8: //BSPTagRef
                    case TSFReader.TSFTagRef:                                    // 0xA1: //TagRef
                        #region TagRef
                        int StringSize = (int)CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)) + 0x08);
                        if (StringSize != 0)
                        {
                            byte[] tmpstr = new byte[StringSize + 1];
                            FI.Read(tmpstr, 0, tmpstr.Length);
                            FO.Write(tmpstr, 0, tmpstr.Length);
                        }
                        break;

                        #endregion
                    case TSFReader.TSFInternalRaw:                               // 0xA3: //InternalRaw
                        #region InternalRaw
                        uint   RawSize = CompUtil.GetUInt(TagBuff, (uint)(sr.GetOIP() + (sc * Size)));
                        byte[] tmp     = new byte[RawSize];
                        FI.Read(tmp, 0, tmp.Length);
                        FO.Write(tmp, 0, tmp.Length);
                        tmp = null;
                        break;

                        #endregion
                    case TSFReader.TSFIntSwap:
                        #region IntSwap
                        uint is_Offset = (uint)sr.GetOIP();
                        CompUtil.SwapInt(ref TagBuff, is_Offset + (sc * Size));

                        break;

                        #endregion
                    case TSFReader.TSFIntSwapRange:
                        #region IntSwapRange
                        uint StartOffset = (uint)sr.GetOIP();
                        uint EndOffset   = (uint)sr.GetUName();
                        for (uint i = StartOffset; i < EndOffset; i += 4)
                        {
                            CompUtil.SwapInt(ref TagBuff, i + (sc * Size));
                        }
                        break;

                        #endregion
                    case TSFReader.TSFLongSwap:
                        #region ShortSwap
                        uint Offset = (uint)sr.GetOIP();
                        CompUtil.SwapShort(ref TagBuff, Offset + (sc * Size));
                        break;

                        #endregion
                    case TSFReader.TSFLongSwapRange:
                        #region ShortSwapRange
                        uint lsr_StartOffset = (uint)sr.GetOIP();
                        uint lsr_EndOffset   = (uint)sr.GetUName();
                        for (uint i = lsr_StartOffset; i < lsr_EndOffset; i += 2)
                        {
                            CompUtil.SwapShort(ref TagBuff, i + (sc * Size));
                        }
                        break;

                        #endregion
                    case TSFReader.TSFBitmapRaw:                                 // 0xA9: //Bitmapraw
                        #region BitmapRaw

                        /*
                         * uint BitMapStructCount;
                         * uint BitMapStructOffset;
                         * uint TiffSize=0;
                         * byte[] tmpBMS;
                         * long sv = 0;
                         *
                         #region grenbitmap
                         * if(Info.IndexItems[Info.CurrentIndex].RawTypeID != 0)
                         * {
                         *      //Trace.WriteLine("extern ce bitmap:  " + Prometheus.Core.Compiler.Decompiler.CurrentTagName);
                         *      CeBitmapIndex.Read(br);
                         *      //meta header for bitmaps for extern ce files is actually in the bitmaps.map file
                         *      //so we need to get the header from there.
                         *
                         *      //fix the index offset, it doesn't use magic
                         *      int bitmap_hdr_offset = (int)CeBitmapIndex.Locator[Info.IndexItems[Info.CurrentIndex].MetaOffset + Info.TagMagic].offset;
                         *      Info.BitmapsFile.Position = bitmap_hdr_offset;
                         *      TagBuff = br.ReadBytes(TagBuff.Length);
                         *      PutUInt(ref TagBuff,0x54,0);
                         *      //get bitmap header(s) offset/count
                         *      BitMapStructCount=GetUInt(TagBuff,0x60);
                         *      BitMapStructOffset=GetUInt(TagBuff,0x64);
                         *
                         *      //copy bitmap header(s) from CE shared to output tag
                         *      br.BaseStream.Position += (BitMapStructOffset-Size);
                         *      tmpBMS = new byte[BitMapStructCount * 0x30];
                         *      tmpBMS = br.ReadBytes(tmpBMS.Length);
                         *
                         *      GetUInt(TagBuff,0x1C,ref TiffSize);
                         *
                         *      bw.BaseStream.Position = 0;
                         *      bw.Write(TagBuff);
                         *      bw.BaseStream.Position +=  (BitMapStructOffset-Size);
                         *      //bw.Write(tmpBMS);
                         *      //FO.Write(tmpBMS, (int)FO.Position, tmpBMS.Length);
                         *
                         *      //skip over TIFF area in output tag
                         *      GetUInt(TagBuff,0x1C,ref TiffSize);
                         *      byte[] TiffBuffer = new byte[TiffSize];
                         *      bw.Write(TiffBuffer);
                         *      //FO.Write(TiffBuffer,0,TiffBuffer.Length);
                         *
                         *      //copy bitmap data from CE shared to output tag
                         *      uint accum = (uint)bw.BaseStream.Position;
                         *      for(int i = 0;i<BitMapStructCount;i++)
                         *      {
                         *              uint BitMapDataOffset = GetUInt(tmpBMS,(uint)(0x18 + (i * 0x30)));
                         *              uint BitMapDataSize = GetUInt(tmpBMS,(uint)(0x1C + (i * 0x30)));
                         *              uint CurrentSize = GetUInt(TagBuff,(uint)0x30);
                         *              PutUInt(ref TagBuff,0x30,CurrentSize + BitMapDataSize);
                         *              byte[] tmpBitmapData = new byte[BitMapDataSize];
                         *              tmpBitmapData = br.ReadBytes((int)BitMapDataSize);
                         *              bw.Write(tmpBitmapData);
                         *              PutUInt(ref tmpBMS,(uint)(0x18 + (i * 0x30)), accum);
                         *              accum += BitMapDataSize;
                         *      }
                         *
                         *      //go to the image header offsets
                         *      //bw.BaseStream.Position = TagBuff.Length + TiffSize +
                         *      bw.BaseStream.Position += 0x40;
                         *      bw.Write(tmpBMS);
                         *      long eof = bw.BaseStream.Position;
                         *
                         *      //fix the offsets
                         *      bw.BaseStream.Position = 0x74;
                         *      bw.Write(accum);
                         *      bw.BaseStream.Position = eof;
                         *
                         *      fuckThisShitHack = true;
                         *      //FO.Write(tmpBitmapData, (int)FO.Position, tmpBitmapData.Length);
                         * }
                         * else
                         * {
                         *      GetUInt(TagBuff,0x1C,ref TiffSize);
                         *      byte[] TiffBuffer = new byte[TiffSize];
                         *      FO.Write(TiffBuffer,0,TiffBuffer.Length);
                         *      BitMapStructCount=GetUInt(TagBuff,0x60);
                         *      BitMapStructOffset=GetUInt(TagBuff,0x64) - Info.MapMagic;
                         *      sv = fs.Position;
                         *      fs.Seek((long)BitMapStructOffset,SeekOrigin.Begin);
                         *      tmpBMS = new byte[BitMapStructCount * 0x30];
                         *      fs.Read(tmpBMS,0,tmpBMS.Length);
                         *
                         *      for(int i = 0;i<BitMapStructCount;i++)
                         *      {
                         *              uint BitMapDataOffset = GetUInt(tmpBMS,(uint)(0x18 + (i * 0x30)));
                         *              uint BitMapDataSize = GetUInt(tmpBMS,(uint)(0x1C + (i * 0x30)));
                         *              uint CurrentSize = GetUInt(TagBuff,(uint)0x30);
                         *              PutUInt(ref TagBuff,0x30,CurrentSize + BitMapDataSize);
                         *              byte[] tmpBitmapData = new byte[BitMapDataSize];
                         *              switch (Info.MapVersion)
                         *              {
                         *                      case 5:
                         *                              fs.Seek((long)BitMapDataOffset,SeekOrigin.Begin);
                         *                              fs.Read(tmpBitmapData,0,tmpBitmapData.Length);
                         *                              FO.Write(tmpBitmapData,0,tmpBitmapData.Length);
                         *                              break;
                         *                      case 7:
                         *                              Info.BitmapsFile.Seek((long)BitMapDataOffset,SeekOrigin.Begin);
                         *                              Info.BitmapsFile.Read(tmpBitmapData,0,tmpBitmapData.Length);
                         *                              FO.Write(tmpBitmapData,0,tmpBitmapData.Length);
                         *                              break;
                         *                      case 0x261:
                         *                              if (Info.IndexItems[Info.CurrentIndex].RawTypeID == 0)
                         *                              {
                         *                                      fs.Seek((long)BitMapDataOffset,SeekOrigin.Begin);
                         *                                      fs.Read(tmpBitmapData,0,tmpBitmapData.Length);
                         *                                      FO.Write(tmpBitmapData,0,tmpBitmapData.Length);
                         *                              }
                         *                              else
                         *                              {
                         *                                      //CE_Bitmap_File CEBF = new CE_Bitmap_File();
                         *                                      //CEBF.HDR.Read(ref Info.BitmapsFile);
                         *                                      //uint Current_offset = CEBF.Locator[Info.IndexItems[Info.CurrentIndex].MetaOffset].offset;
                         *                              }
                         *                              break;
                         *              }
                         *      }
                         *      fs.Seek(sv,SeekOrigin.Begin);
                         * }
                         *
                         #endregion
                         */
                        break;

                        #endregion
                    case TSFReader.TSFSoundData:                                 // 0xAA: //SoundData
                        #region SoundData

                        /*
                         * uint DataSizeOffset = sr.GetOIP();
                         * uint NormalDataOffset = sr.GetUName();
                         * uint SndDataSize = GetUInt(TagBuff,(uint)(DataSizeOffset + (sc * Size)));
                         * uint TrueOffset = GetUInt(TagBuff,(uint)(NormalDataOffset + 4 + (sc * Size)));
                         * byte[] SoundData = new byte[SndDataSize];
                         * switch (Info.MapVersion)
                         * {
                         * case 5:
                         *      long fssv = fs.Position;
                         *      fs.Seek((long)TrueOffset,SeekOrigin.Begin);
                         *      fs.Read(SoundData,0,SoundData.Length);
                         *      fs.Seek(fssv,SeekOrigin.Begin);
                         *      FO.Write(SoundData,0,SoundData.Length);
                         *      break;
                         * case 7:
                         *      Info.SoundsFile.Seek(TrueOffset,System.IO.SeekOrigin.Begin);
                         *      Info.SoundsFile.Read(SoundData,0,SoundData.Length);
                         *      FO.Write(SoundData,0,SoundData.Length);
                         *      SoundData = null;
                         *      break;
                         * }
                         */
                        break;

                        #endregion
                    case TSFReader.TSFRawXModelData:                             // 0xB0: //XModelData
                        #region XModelData

                        /*
                         * uint XTrueVerticesSize = (GetUInt(TagBuff,88 + (sc * Size))) * 32;
                         * uint XTrueIndicesSize =(((GetUInt(TagBuff,72 + (sc * Size))) / 3) + 1 ) * 6;
                         * uint XNewIndicesDataSize = (GetUInt(TagBuff,72 + (sc * Size)) / 3) + 1;
                         * uint XTrueVerticesOffset = GetUInt(TagBuff,100 + (sc * Size)) - Info.MapMagic;
                         * uint XSaveMapFilePos = (uint)fs.Position;//MapFile.Position;
                         * byte[] XModelHeader = new byte[16];
                         * fs.Seek((long)XTrueVerticesOffset,System.IO.SeekOrigin.Begin);
                         * fs.Read(XModelHeader,0,XModelHeader.Length);
                         * fs.Seek(XSaveMapFilePos,System.IO.SeekOrigin.Begin);
                         * XTrueVerticesOffset = GetUInt(XModelHeader,4) - Info.MapMagic;
                         *
                         * XSaveMapFilePos = (uint)fs.Position;
                         * byte[] RawXModelBuffer = new byte[XTrueVerticesSize];
                         * fs.Seek((long)XTrueVerticesOffset,System.IO.SeekOrigin.Begin);
                         * fs.Read(RawXModelBuffer,0,(int)XTrueVerticesSize);
                         * FO.Write(RawXModelBuffer,0,(int)XTrueVerticesSize);
                         *
                         * byte[] XTestBuffer = new byte[6];
                         * uint XTrueIndicesOffset = GetUInt(TagBuff, 80+ (sc * Size)) - Info.MapMagic;
                         * RawXModelBuffer = new byte[XTrueIndicesSize];
                         * fs.Seek((long)XTrueIndicesOffset,System.IO.SeekOrigin.Begin);
                         * fs.Read(XModelHeader,0,XModelHeader.Length);
                         * XTrueIndicesOffset = GetUInt(XModelHeader,0x04) - Info.MapMagic;
                         * fs.Seek((long)XTrueIndicesOffset,System.IO.SeekOrigin.Begin);
                         * fs.Read(RawXModelBuffer,0,RawXModelBuffer.Length);
                         * FO.Write(RawXModelBuffer,0,RawXModelBuffer.Length);
                         * fs.Read(XTestBuffer,0,6);
                         * if (XTestBuffer[4] == 0xff)
                         * {
                         *      FO.Write(XTestBuffer,0,6);
                         *      XTrueIndicesSize += 6;
                         * }
                         */
                        break;

                        #endregion
                    case TSFReader.TSFModelData:                                 // 0xAB: //Modeldata
                        #region ModelData

                        /*
                         * long SaveMapFilePos = (uint)fs.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;
                         * uint TrueVerticesOffset = GetUInt(TagBuff,(uint)(100+ (sc * Size))) + Info.VerticesOffset;  //80
                         * uint TrueIndicesOffset = GetUInt(TagBuff,(uint)(80+ (sc * Size))) +  Info.IndicesOffset;  //100
                         * //PutUInt(ref TagBuff,GetUInt(TagBuff,(uint)(88 + (i * Size))),(uint)(32 +(i * Size)));
                         * //PutUInt(ref TagBuff,NewIndicesDataSize,(uint)(56 + (i * Size)));
                         * uint CurrentStructSize = (uint)TagBuff.Length;
                         * byte[] RawModelBuffer = new byte[TrueVerticesSize];
                         * fs.Seek((long)TrueVerticesOffset,System.IO.SeekOrigin.Begin);
                         * fs.Read(RawModelBuffer,0,RawModelBuffer.Length);
                         * FO.Write(RawModelBuffer,0,RawModelBuffer.Length);
                         *
                         * RawModelBuffer = new byte[TrueIndicesSize];
                         * fs.Seek((long)TrueIndicesOffset,System.IO.SeekOrigin.Begin);
                         * fs.Read(RawModelBuffer,0,RawModelBuffer.Length);
                         * FO.Write(RawModelBuffer,0,RawModelBuffer.Length);
                         * fs.Seek(fs.Position,System.IO.SeekOrigin.Begin);
                         * byte[] TestBuffer = new byte[6];
                         * fs.Read(TestBuffer,0,6);
                         * if (TestBuffer[4] == 0xff)
                         * {
                         *      //PutUInt(StructBuffer,GetUInt(StructBuffer,56 + (StructSize * cc)) + 1,56 + (StructSize * cc));
                         *      FO.Write(TestBuffer,0,TestBuffer.Length);
                         *      TrueIndicesSize += 6;
                         * }
                         * fs.Seek(SaveMapFilePos,SeekOrigin.Begin);
                         */
                        break;

                        #endregion
                    case TSFReader.TSFBSPModel:                                                  // 0xAC: //BSPMODEL
                        #region BSPModel
                        uint VOOffset = 0xB4;
                        uint LOOffset = 0xC8;

                        uint UnCompVertsSize = CompUtil.GetUInt(TagBuff, VOOffset + (sc * Size)) * 56;
                        uint CompVertsSize   = CompUtil.GetUInt(TagBuff, VOOffset + (sc * Size)) * 32;
                        uint UnCompLMUVSize  = CompUtil.GetUInt(TagBuff, LOOffset + (sc * Size)) * 20;
                        uint CompLMUVSize    = CompUtil.GetUInt(TagBuff, LOOffset + (sc * Size)) * 8;

                        byte[] ba_UnCompVerts = new byte[UnCompVertsSize];
                        byte[] ba_CompVerts   = new byte[CompVertsSize];
                        byte[] ba_UnCompLMUV  = new byte[UnCompLMUVSize];
                        byte[] ba_CompLMUV    = new byte[CompLMUVSize];

                        FI.Read(ba_UnCompVerts, 0, ba_UnCompVerts.Length);
                        FI.Read(ba_UnCompLMUV, 0, ba_UnCompLMUV.Length);
                        FI.Read(ba_CompVerts, 0, ba_CompVerts.Length);
                        FI.Read(ba_CompLMUV, 0, ba_CompLMUV.Length);

                        FO.Write(ba_UnCompVerts, 0, ba_UnCompVerts.Length);
                        FO.Write(ba_UnCompLMUV, 0, ba_UnCompLMUV.Length);
                        FO.Write(ba_CompVerts, 0, ba_CompVerts.Length);
                        FO.Write(ba_CompLMUV, 0, ba_CompLMUV.Length);
                        break;

                        #endregion
                    case TSFReader.TSFResource:                             // 0xAD: //Resource
                        #region Resource

                        /*
                         * ushort BitmapSoundFlag = GetUShort(TagBuff,0x00 + (sc * Size));
                         * ushort Index = GetUShort(TagBuff,0x02 + (sc * Size));
                         * ushort ID1 = GetUShort(TagBuff,0x04 + (sc * Size));
                         * ushort ID2 = GetUShort(TagBuff,0x06 + (sc * Size));
                         * MapPosSave = fs.Position;
                         * uint Offset = Info.IndexItems[ID1].OffsetToString; ///  fileData.stringOffset.UInt - Info.MapMagic;
                         * fs.Seek((long)Offset,SeekOrigin.Begin);
                         * byte[] rscstr = new byte[256];
                         * fs.Read(rscstr,0,rscstr.Length);
                         * fs.Seek(MapPosSave,SeekOrigin.Begin);
                         * uint rscsize = 0;
                         * do
                         * {
                         *      rscsize +=1;
                         * }while (rscstr[rscsize] != 0);
                         * byte[] rscOutString = new byte[rscsize + 1];
                         * uint rsccount = 0;
                         * do
                         * {
                         *      rscOutString[rsccount] = rscstr[rsccount];
                         *      rsccount +=1;
                         * }while (rsccount != rscsize);
                         * PutUShort(ref TagBuff,(uint)(0x06 + (sc * Size)),(ushort)(rscOutString.Length - 1));
                         * FO.Write(rscOutString,0,rscOutString.Length);
                         */
                        break;

                        #endregion
                    case TSFReader.TSFEnd:                             // 0xA7: //End
                        #region StructEnd
                        if (sr.GetOIP() == Name)
                        {
                            ExitStruct = true;
                        }
                        else
                        {
                            ExitStruct = false;
                        }
                        break;
                        #endregion
                    }
                }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);
        }
示例#17
0
            public void Read(ref FileStream FI)
            {
                MapHeader.Read(ref FI);
                FI.Seek(MapHeader.IndexOffset, System.IO.SeekOrigin.Begin);
                IndexHeader.Read(ref FI);
                IndexItem = new sIndexItem[IndexHeader.TagCount];
                MapMagic  = IndexHeader.IndexMagic - IndexHeader.TagStartOffset;
                StringTable.OffsetsOffset     = MapHeader.StringTableListOffset;
                StringTable.OffsetsBufferSize = MapHeader.StringTableListSize;
                StringTable.StringOffset      = MapHeader.StringTableOffset;
                StringTable.StringBufferSize  = MapHeader.StringTableSize;
                StringTable.Read(ref FI);
                FI.Seek(IndexHeader.TagStartOffset, System.IO.SeekOrigin.Begin);
                //uint ScnrOffset = 0;
                for (int tc = 0; tc < IndexHeader.TagCount; tc += 1)
                {
                    IndexItem[tc].Read(ref FI);
                    //IndexItem[tc].TagOffset = IndexItem[tc].TagOffset;

                    byte[] strtemp = BitConverter.GetBytes(IndexItem[tc].TagType);
                    string tmpstr  = CompUtil.GetTagClass(strtemp, 0);
                    if (tmpstr == "<fx>")
                    {
                        tmpstr = "FXFX";
                    }

                    string MagfilePathRoot = Application.StartupPath + @"\Tag Structures\Halo2\";

                    string       ProcessTagFile = tmpstr.Trim() + ".mag";
                    StreamReader MagReader      = new StreamReader(MagfilePathRoot + ProcessTagFile);
                    string       InLine         = MagReader.ReadLine();



                    IndexItem[tc].NameString   = StringTable.TagStrings[tc] + "." + InLine;
                    StringTable.TagStrings[tc] = StringTable.TagStrings[tc] + "." + InLine;
                    MagReader = null;
                }
                MapMagic = IndexItem[0].TagOffset - MapHeader.OffsetToFirstObject;
                uint BspIndex = 0;

                for (int tc = 0; tc < IndexHeader.TagCount; tc += 1)
                {
                    byte[] strtemp = BitConverter.GetBytes(IndexItem[tc].TagType);
                    string tmpstr  = CompUtil.GetTagClass(strtemp, 0);

                    if (tmpstr == "scnr")
                    {
                        byte[] TmpScnrBuff = new byte[0x3E0];
                        long   fpSav       = FI.Position;
                        IndexItem[tc].TagOffset      = IndexItem[tc].TagOffset - MapMagic;
                        IndexItem[tc].TagMagic       = MapMagic;
                        IndexItem[tc].TagOffsetMagic = MapMagic;
                        FI.Seek(IndexItem[tc].TagOffset, System.IO.SeekOrigin.Begin);
                        FI.Read(TmpScnrBuff, 0, TmpScnrBuff.Length);
                        uint BSPCount  = BitConverter.ToUInt32(TmpScnrBuff, 0x210);                       //Struct Size 0x44
                        uint BSPOffset = BitConverter.ToUInt32(TmpScnrBuff, 0x214) - MapMagic;
                        FI.Seek((long)BSPOffset, System.IO.SeekOrigin.Begin);
                        sbspltmpref = new sScnrBsp[BSPCount];
                        for (int i = 0; i < BSPCount; i++)
                        {
                            sbspltmpref[i].Read(ref FI);
                        }
                        FI.Seek(fpSav, System.IO.SeekOrigin.Begin);
                    }
                    else if (tmpstr == "sbsp")
                    {
                        //byte[] tmp = new byte[0x10];
                        //long possave = FI.Position;
                        //FI.Seek((long)sbspltmpref[BspIndex].Offset,System.IO.SeekOrigin.Begin);
                        //FI.Read(tmp,0,tmp.Length);
                        //FI.Seek(possave,System.IO.SeekOrigin.Begin);
                        IndexItem[tc].TagOffset      = sbspltmpref[BspIndex].Offset + 0x10;
                        IndexItem[tc].TagSize        = sbspltmpref[BspIndex].Size;
                        IndexItem[tc].TagMagic       = MapMagic;
                        IndexItem[tc].TagOffsetMagic = sbspltmpref[BspIndex].Magic - (IndexItem[tc].TagOffset - 0x10);
                        BspIndex += 1;
                    }
                    else if (tmpstr == "ltmp")                       //lovers brain << My wifes atemp to program...
                    {
                        byte[] tmp     = new byte[0x10];
                        long   possave = FI.Position;
                        FI.Seek((long)sbspltmpref[BspIndex].Offset, System.IO.SeekOrigin.Begin);
                        FI.Read(tmp, 0, tmp.Length);
                        FI.Seek(possave, System.IO.SeekOrigin.Begin);
                        IndexItem[tc].TagOffset      = BitConverter.ToUInt32(tmp, 0x08) - sbspltmpref[BspIndex].Magic + sbspltmpref[BspIndex].Offset; //sbspltmpref[BspIndex].Offset;
                        IndexItem[tc].TagSize        = BitConverter.ToUInt32(tmp, 0x0);                                                               //sbspltmpref[BspIndex].Size;
                        IndexItem[tc].TagMagic       = MapMagic;
                        IndexItem[tc].TagOffsetMagic = sbspltmpref[BspIndex].Magic - sbspltmpref[BspIndex].Offset;
                    }
                    else
                    {
                        IndexItem[tc].TagOffset      = IndexItem[tc].TagOffset - MapMagic;
                        IndexItem[tc].TagMagic       = MapMagic;
                        IndexItem[tc].TagOffsetMagic = MapMagic;
                    }
                }
                FilenameTable = new Hashtable((int)IndexHeader.TagCount);
                for (int strs = 0; strs < IndexHeader.TagCount; strs += 1)
                {
                    //IndexItemStringList[strs] = StringLoader(ref FI,IndexItems[strs].OffsetToString) + GetTagLongName(IndexItems[strs].Type1);
                    FilenameTable.Add(StringTable.TagStrings[strs], strs);
                }
            }