Exemple #1
0
        unsafe void TypeTreeBlobRead(List <TypeTreeNode> typeTree, ReaderLE drd)
        {
            uint numberOfNodes    = drd.ru4cp();
            int  stringBufferSize = drd.ri4cp();


            byte *pTy = drd.CurPtr();

            if (drd.isBE)
            {
            }

            uint siz = 0x18;

            if (Header.m_Version >= 19)
            {
                siz = 0x20;
            }

            drd.seek += (int)(siz * numberOfNodes);

            for (uint i = 0; i < numberOfNodes; i++)
            {
                var typeTreeNode = new TypeTreeNode();
                typeTree.Add(typeTreeNode);
                typeTreeNode.info = *(TypeInfo *)(pTy + siz * i);

                typeTreeNode.info.m_TypeStr = TypeInfoStr(typeTreeNode.info.m_TypeStr, drd);
                typeTreeNode.info.m_NameStr = TypeInfoStr(typeTreeNode.info.m_NameStr, drd);
            }

            drd.seek += stringBufferSize;
        }
Exemple #2
0
 int TypeInfoStr(int offset, ReaderLE drd)
 {
     if (offset < 0)
     {
         return(offset & 0x7fffffff);
     }
     else
     {
         return(Dics.PutUserStr(drd.rStrp(offset)));
     }
 }
Exemple #3
0
        unsafe SerializedType TypeParse(ReaderLE drd)
        {
            var type = new SerializedType();

            type.classID = (ClassIDType)drd.ri4cp();

            if (Header.m_Version >= 16)
            {
                type.m_IsStrippedType = (drd.r1p() == 1);
            }

            if (Header.m_Version >= 17)
            {
                type.m_ScriptTypeIndex = drd.ri2cp();
            }

            if (Header.m_Version >= 13)
            {
                if ((Header.m_Version < 16 && type.classID < 0) || (Header.m_Version >= 16 && type.classID == ClassIDType.MonoBehaviour))
                {
                    type.m_ScriptID = *(yGUID *)drd.ReadTcp(16);               //Hash128
                }
                type.m_OldTypeHash = *(yGUID *)drd.ReadTcp(16);                //Hash128
            }

            if (m_EnableTypeTree)
            {
                var typeTree = new List <TypeTreeNode>();
                if (Header.m_Version >= 12 || Header.m_Version == 10)
                {
                    TypeTreeBlobRead(typeTree, drd);
                }
                else
                {
                    //ReadTypeTree(typeTree);
                }

                if (Header.m_Version >= 21)
                {
                    type.m_TypeDependencies = drd.ReadNArraycp <int>(4);
                }

                type.m_Nodes = typeTree;
            }

            return(type);
        }
Exemple #4
0
        //static bswap bswapy;
        unsafe void MetaParse(Stream reader, bool isBE)
        {
            int cur = 5;

            byte[] buf = reader.ReadBytes(cur);

            ReaderLE drd;

            if (isBE)
            {
                drd = new ReaderBE(buf);
            }
            else
            {
                drd = new ReaderLE(buf);
            }

            if (Header.m_Version >= 8)
            {
                cur -= 4;
                m_TargetPlatform = (BuildTarget)drd.ri4c();
            }
            if (Header.m_Version >= 13)
            {
                cur -= 1;
                m_EnableTypeTree = (buf[4] > 0);
            }

            if (cur != 0)
            {
                reader.Position -= cur;
            }

            cur = 0;
            buf = reader.ReadBytes((int)(Header.m_MetadataSize + rStart[0] - reader.Position));

            fixed(byte *srcbb = &buf[0])
            {
                drd.Reload(srcbb);

                int typCount = drd.ri4cp();

                m_Types = new SerializedType[typCount];
                for (int i = 0; i < typCount; i++)
                {
                    m_Types[i] = TypeParse(drd);
                }


                int bigIDEnabled = 0;

                if (Header.m_Version >= 7 && Header.m_Version < 14)
                {
                    bigIDEnabled = drd.ri4cp();
                }

                int objectCount = drd.ri4cp();

                rStart[1]  = (int)(reader.Position - buf.Length - rStart[0] + drd.seek);
                cur        = Extensionnyaa.mod4less(rStart[1]);
                drd.seek  += cur;
                rStart[1] += cur;                 // rstart[0]+rstart[1] = abs offset to metas

                long vprs = Header.m_DataOffset;

                if (isAB != null)
                {
                    vprs += isAB.ABHsize;
                }

                int syz = 0x14;

                cur = 0;
                if (Header.m_Version >= 22)
                {
                    syz = 0x18;
                    cur = 2;                     //u20
                }
                else if (Header.m_Version < 16)
                {
                    cur = 1;                     //u4
                }

                byte *du = drd.ReadTcp(0);

                if (cur == 0)
                {
                    for (int i = 0; i < objectCount; i++)
                    {
                        uMetaStruct ynfo = *(uMetaStruct *)du;

                        var meta = GetNewuMeta(ynfo.PathID);

                        meta.Offset  = ynfo.Offset + vprs;
                        meta.Size    = ynfo.Size;
                        meta.MB_type = m_Types[ynfo.TypeID];
                        meta.ClassID = meta.MB_type.classID;

                        du += syz;
                    }
                }
                else
                {
                    for (int i = 0; i < objectCount; i++)
                    {
                        uMetaStruct ynfo = *(uMetaStruct *)du;


                        if (cur == 1)
                        {
                            var meta = GetNewuMeta((long)ynfo.PathID_u4);


                            meta.Offset = ynfo.Offset_u4 + vprs;
                            meta.Size   = ynfo.Size_u4;
                            //meta.MB_type = m_Types[ynfo.TypeID];
                            meta.ClassID = (ClassIDType)ynfo.ClassID_u4;
                        }
                        else if (cur == 2)
                        {
                            var meta = GetNewuMeta(ynfo.PathID);
                            meta.Offset  = ynfo.Offset_u20 + vprs;
                            meta.Size    = ynfo.Size_u20;
                            meta.MB_type = m_Types[ynfo.TypeID_u20];
                            meta.ClassID = meta.MB_type.classID;
                        }


                        du += syz;
                    }
                }

                drd.seek += syz * objectCount;

                if (Header.m_Version >= 11)
                {
                    syz           = 0xc;
                    objectCount   = drd.ri4cp();
                    m_ScriptTypes = new LocalSerializedObjectIdentifierStruct[objectCount];
                    for (int i = 0; i < objectCount; i++)
                    {
                        m_ScriptTypes[i] = *(LocalSerializedObjectIdentifierStruct *)drd.ReadTcp(syz);
                    }

                    drd.seek += syz * objectCount;
                }

                objectCount = drd.ri4cp();

                Dependency = new SerializedFile[objectCount];

                for (int i = 0; i < objectCount; i++)
                {
                    string         nzstr = drd.rStrp();
                    yGUID          yg    = *(yGUID *)drd.ReadTcp(16);
                    int            tpp   = drd.ri4cp();
                    SerializedFile dp    = MakeDependency(drd.rStrp());

                    dp.setLinked(nzstr, tpp, yg);

                    Dependency[i] = dp;
                }
            }
        }