示例#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);
            }
示例#2
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);
        }
示例#3
0
 public string GetString()
 {
     return(CompUtil.ReadString(String, 0));
 }