示例#1
0
        public GameObject(AssetPreloadData preloadData)
        {
            if (preloadData == null)
            {
                AssetsFile   sourceFile = preloadData.sourceFile;
                EndianStream stream     = preloadData.sourceFile.a_Stream;
                stream.Position = preloadData.Offset;
                this.uniqueID   = preloadData.uniqueID;
                if (sourceFile.platform == -2)
                {
                    uint num3 = stream.ReadUInt32();
                    PPtr ptr  = sourceFile.ReadPPtr();
                    PPtr ptr2 = sourceFile.ReadPPtr();
                }
                int num = stream.ReadInt32();
                for (int i = 0; i < num; i++)
                {
                    switch (stream.ReadInt32())
                    {
                    case 4:
                        this.m_Transform = sourceFile.ReadPPtr();
                        break;

                    case 0x17:
                        this.m_Renderer = sourceFile.ReadPPtr();
                        break;

                    case 0x21:
                        this.m_MeshFilter = sourceFile.ReadPPtr();
                        break;

                    case 0x89:
                        this.m_SkinnedMeshRenderer = sourceFile.ReadPPtr();
                        break;

                    default:
                    {
                        PPtr ptr3 = sourceFile.ReadPPtr();
                        break;
                    }
                    }
                }
                this.m_Layer = stream.ReadInt32();
                int length = stream.ReadInt32();
                this.m_Name = stream.ReadAlignedString(length);
                if (this.m_Name == "")
                {
                    this.m_Name = "GameObject #" + this.uniqueID;
                }
                this.m_Tag      = stream.ReadUInt16();
                this.m_IsActive = stream.ReadBoolean();
                this.Text       = this.m_Name;
                this.Name       = this.uniqueID;
            }
        }
示例#2
0
        public TextAsset(AssetPreloadData preloadData, bool readSwitch)
        {
            AssetsFile   sourceFile = preloadData.sourceFile;
            EndianStream stream     = preloadData.sourceFile.a_Stream;

            stream.Position       = preloadData.Offset;
            preloadData.extension = ".txt";
            if (sourceFile.platform == -2)
            {
                uint num2 = stream.ReadUInt32();
                PPtr ptr  = sourceFile.ReadPPtr();
                PPtr ptr2 = sourceFile.ReadPPtr();
            }
            this.m_Name = stream.ReadAlignedString(stream.ReadInt32());
            if (this.m_Name != "")
            {
                preloadData.Name = this.m_Name;
            }
            else
            {
                preloadData.Name = preloadData.TypeString + " #" + preloadData.uniqueID;
            }
            int count = stream.ReadInt32();

            if (readSwitch)
            {
                this.m_Script = new byte[count];
                stream.Read(this.m_Script, 0, count);
                if (this.m_Script[0] == 0x5d)
                {
                    this.m_Script = SevenZipHelper.Decompress(this.m_Script);
                }
                if ((this.m_Script[0] == 60) || ((((this.m_Script[0] == 0xef) && (this.m_Script[1] == 0xbb)) && (this.m_Script[2] == 0xbf)) && (this.m_Script[3] == 60)))
                {
                    preloadData.extension = ".xml";
                }
            }
            else
            {
                if (stream.ReadByte() == 0x5d)
                {
                    stream.Position       += 4L;
                    preloadData.exportSize = stream.ReadInt32();
                    stream.Position       -= 8L;
                }
                else
                {
                    preloadData.exportSize = count;
                }
                stream.Position += count - 1;
            }
            stream.AlignStream(4);
            this.m_PathName = stream.ReadAlignedString(stream.ReadInt32());
        }
示例#3
0
        public Texture2D(AssetPreloadData preloadData, bool readSwitch)
        {
            AssetsFile   sourceFile = preloadData.sourceFile;
            EndianStream stream     = preloadData.sourceFile.a_Stream;

            stream.Position = preloadData.Offset;
            if (sourceFile.platform == -2)
            {
                uint num  = stream.ReadUInt32();
                PPtr ptr  = sourceFile.ReadPPtr();
                PPtr ptr2 = sourceFile.ReadPPtr();
            }
            this.m_Name              = stream.ReadAlignedString(stream.ReadInt32());
            this.m_Width             = stream.ReadInt32();
            this.m_Height            = stream.ReadInt32();
            this.m_CompleteImageSize = stream.ReadInt32();
            this.m_TextureFormat     = stream.ReadInt32();
            this.getExtension(preloadData, this.m_TextureFormat);
            if (this.m_Name != "")
            {
                preloadData.Name = this.m_Name;
            }
            else
            {
                preloadData.Name = preloadData.TypeString + " #" + preloadData.uniqueID;
            }
            if ((sourceFile.version[0] < 5) || ((sourceFile.version[0] == 5) && (sourceFile.version[1] < 2)))
            {
                this.m_MipMap = stream.ReadBoolean();
            }
            else
            {
                this.dwFlags      += 0x20000;
                this.dwMipMapCount = stream.ReadInt32();
                this.dwCaps       += 0x400008;
            }
            this.m_IsReadable  = stream.ReadBoolean();
            this.m_ReadAllowed = stream.ReadBoolean();
            stream.AlignStream(4);
            this.m_ImageCount       = stream.ReadInt32();
            this.m_TextureDimension = stream.ReadInt32();
            this.m_FilterMode       = stream.ReadInt32();
            this.m_Aniso            = stream.ReadInt32();
            this.m_MipBias          = stream.ReadSingle();
            this.m_WrapMode         = stream.ReadInt32();
            if (sourceFile.version[0] >= 3)
            {
                this.m_LightmapFormat = stream.ReadInt32();
                if ((sourceFile.version[0] >= 4) || (sourceFile.version[1] >= 5))
                {
                    this.m_ColorSpace = stream.ReadInt32();
                }
            }
            this.image_data_size = stream.ReadInt32();
            if (this.m_MipMap)
            {
                this.dwFlags      += 0x20000;
                this.dwMipMapCount = Convert.ToInt32((double)(Math.Log((double)Math.Max(this.m_Width, this.m_Height)) / Math.Log(2.0)));
                this.dwCaps       += 0x400008;
            }
            if (!readSwitch)
            {
                string[] textArray1 = new string[] { "Width: ", this.m_Width.ToString(), "\nHeight: ", this.m_Height.ToString(), "\nFormat: " };
                preloadData.InfoText   = string.Concat(textArray1);
                preloadData.exportSize = this.image_data_size;
                switch (this.m_TextureFormat)
                {
                case 1:
                    preloadData.InfoText    = preloadData.InfoText + "Alpha8";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 2:
                    preloadData.InfoText    = preloadData.InfoText + "ARGB 4.4.4.4";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 3:
                    preloadData.InfoText    = preloadData.InfoText + "BGR 8.8.8";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 4:
                    preloadData.InfoText    = preloadData.InfoText + "GRAB 8.8.8.8";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 5:
                    preloadData.InfoText    = preloadData.InfoText + "BGRA 8.8.8.8";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 7:
                    preloadData.InfoText    = preloadData.InfoText + "RGB 5.6.5";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 10:
                    preloadData.InfoText    = preloadData.InfoText + "DXT1";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 12:
                    preloadData.InfoText    = preloadData.InfoText + "DXT5";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 13:
                    preloadData.InfoText    = preloadData.InfoText + "RGBA 4.4.4.4";
                    preloadData.extension   = ".dds";
                    preloadData.exportSize += 0x80;
                    goto Label_0E7B;

                case 0x1c:
                    preloadData.InfoText  = preloadData.InfoText + "DXT1 Crunched";
                    preloadData.extension = ".crn";
                    goto Label_0E7B;

                case 0x1d:
                    preloadData.InfoText  = preloadData.InfoText + "DXT5 Crunched";
                    preloadData.extension = ".crn";
                    goto Label_0E7B;

                case 30:
                    preloadData.InfoText    = preloadData.InfoText + "PVRTC_RGB2";
                    preloadData.extension   = ".pvr";
                    preloadData.exportSize += 0x34;
                    goto Label_0E7B;

                case 0x1f:
                    preloadData.InfoText    = preloadData.InfoText + "PVRTC_RGBA2";
                    preloadData.extension   = ".pvr";
                    preloadData.exportSize += 0x34;
                    goto Label_0E7B;

                case 0x20:
                    preloadData.InfoText    = preloadData.InfoText + "PVRTC_RGB4";
                    preloadData.extension   = ".pvr";
                    preloadData.exportSize += 0x34;
                    goto Label_0E7B;

                case 0x21:
                    preloadData.InfoText    = preloadData.InfoText + "PVRTC_RGBA4";
                    preloadData.extension   = ".pvr";
                    preloadData.exportSize += 0x34;
                    goto Label_0E7B;

                case 0x22:
                    preloadData.InfoText    = preloadData.InfoText + "ETC_RGB4";
                    preloadData.extension   = ".pvr";
                    preloadData.exportSize += 0x34;
                    goto Label_0E7B;
                }
                preloadData.InfoText  = preloadData.InfoText + "unknown";
                preloadData.extension = ".tex";
            }
            else
            {
                this.image_data = new byte[this.image_data_size];
                stream.Read(this.image_data, 0, this.image_data_size);
                switch (this.m_TextureFormat)
                {
                case 1:
                    this.dwFlags2      = 2;
                    this.dwRGBBitCount = 8;
                    this.dwRBitMask    = 0;
                    this.dwGBitMask    = 0;
                    this.dwBBitMask    = 0;
                    this.dwABitMask    = 0xff;
                    return;

                case 2:
                    if (sourceFile.platform != 11)
                    {
                        if (sourceFile.platform == 13)
                        {
                            for (int j = 0; j < (this.image_data_size / 2); j++)
                            {
                                byte[] buffer1 = new byte[] { this.image_data[j * 2], this.image_data[(j * 2) + 1], this.image_data[j * 2], this.image_data[(j * 2) + 1] };
                                byte[] bytes   = BitConverter.GetBytes((int)(BitConverter.ToInt32(buffer1, 0) >> 4));
                                this.image_data[j * 2]       = bytes[0];
                                this.image_data[(j * 2) + 1] = bytes[1];
                            }
                        }
                        break;
                    }
                    for (int i = 0; i < (this.image_data_size / 2); i++)
                    {
                        byte num4 = this.image_data[i * 2];
                        this.image_data[i * 2]       = this.image_data[(i * 2) + 1];
                        this.image_data[(i * 2) + 1] = num4;
                    }
                    break;

                case 3:
                    for (int k = 0; k < (this.image_data_size / 3); k++)
                    {
                        byte num7 = this.image_data[k * 3];
                        this.image_data[k * 3]       = this.image_data[(k * 3) + 2];
                        this.image_data[(k * 3) + 2] = num7;
                    }
                    this.dwFlags2      = 0x40;
                    this.dwRGBBitCount = 0x18;
                    this.dwRBitMask    = 0xff0000;
                    this.dwGBitMask    = 0xff00;
                    this.dwBBitMask    = 0xff;
                    this.dwABitMask    = 0;
                    return;

                case 4:
                    for (int m = 0; m < (this.image_data_size / 4); m++)
                    {
                        byte num9 = this.image_data[m * 4];
                        this.image_data[m * 4]       = this.image_data[(m * 4) + 2];
                        this.image_data[(m * 4) + 2] = num9;
                    }
                    this.dwFlags2      = 0x41;
                    this.dwRGBBitCount = 0x20;
                    this.dwRBitMask    = 0xff0000;
                    this.dwGBitMask    = 0xff00;
                    this.dwBBitMask    = 0xff;
                    this.dwABitMask    = -16777216;
                    return;

                case 5:
                    for (int n = 0; n < (this.image_data_size / 4); n++)
                    {
                        byte num11 = this.image_data[n * 4];
                        byte num12 = this.image_data[(n * 4) + 1];
                        this.image_data[n * 4]       = this.image_data[(n * 4) + 3];
                        this.image_data[(n * 4) + 1] = this.image_data[(n * 4) + 2];
                        this.image_data[(n * 4) + 2] = num12;
                        this.image_data[(n * 4) + 3] = num11;
                    }
                    this.dwFlags2      = 0x41;
                    this.dwRGBBitCount = 0x20;
                    this.dwRBitMask    = 0xff0000;
                    this.dwGBitMask    = 0xff00;
                    this.dwBBitMask    = 0xff;
                    this.dwABitMask    = -16777216;
                    return;

                case 6:
                case 8:
                case 9:
                case 11:
                case 0x1c:
                case 0x1d:
                    return;

                case 7:
                    if (sourceFile.platform == 11)
                    {
                        for (int num13 = 0; num13 < (this.image_data_size / 2); num13++)
                        {
                            byte num14 = this.image_data[num13 * 2];
                            this.image_data[num13 * 2]       = this.image_data[(num13 * 2) + 1];
                            this.image_data[(num13 * 2) + 1] = num14;
                        }
                    }
                    this.dwFlags2      = 0x40;
                    this.dwRGBBitCount = 0x10;
                    this.dwRBitMask    = 0xf800;
                    this.dwGBitMask    = 0x7e0;
                    this.dwBBitMask    = 0x1f;
                    this.dwABitMask    = 0;
                    return;

                case 10:
                    if (sourceFile.platform == 11)
                    {
                        for (int num15 = 0; num15 < (this.image_data_size / 2); num15++)
                        {
                            byte num16 = this.image_data[num15 * 2];
                            this.image_data[num15 * 2]       = this.image_data[(num15 * 2) + 1];
                            this.image_data[(num15 * 2) + 1] = num16;
                        }
                    }
                    if (this.m_MipMap)
                    {
                        this.dwPitchOrLinearSize = (this.m_Height * this.m_Width) / 2;
                    }
                    this.dwFlags2      = 4;
                    this.dwFourCC      = 0x31545844;
                    this.dwRGBBitCount = 0;
                    this.dwRBitMask    = 0;
                    this.dwGBitMask    = 0;
                    this.dwBBitMask    = 0;
                    this.dwABitMask    = 0;
                    return;

                case 12:
                    if (sourceFile.platform == 11)
                    {
                        for (int num17 = 0; num17 < (this.image_data_size / 2); num17++)
                        {
                            byte num18 = this.image_data[num17 * 2];
                            this.image_data[num17 * 2]       = this.image_data[(num17 * 2) + 1];
                            this.image_data[(num17 * 2) + 1] = num18;
                        }
                    }
                    if (this.m_MipMap)
                    {
                        this.dwPitchOrLinearSize = (this.m_Height * this.m_Width) / 2;
                    }
                    this.dwFlags2      = 4;
                    this.dwFourCC      = 0x35545844;
                    this.dwRGBBitCount = 0;
                    this.dwRBitMask    = 0;
                    this.dwGBitMask    = 0;
                    this.dwBBitMask    = 0;
                    this.dwABitMask    = 0;
                    return;

                case 13:
                    for (int num19 = 0; num19 < (this.image_data_size / 2); num19++)
                    {
                        byte[] buffer3 = new byte[] { this.image_data[num19 * 2], this.image_data[(num19 * 2) + 1], this.image_data[num19 * 2], this.image_data[(num19 * 2) + 1] };
                        byte[] buffer2 = BitConverter.GetBytes((int)(BitConverter.ToInt32(buffer3, 0) >> 4));
                        this.image_data[num19 * 2]       = buffer2[0];
                        this.image_data[(num19 * 2) + 1] = buffer2[1];
                    }
                    this.dwFlags2      = 0x41;
                    this.dwRGBBitCount = 0x10;
                    this.dwRBitMask    = 0xf00;
                    this.dwGBitMask    = 240;
                    this.dwBBitMask    = 15;
                    this.dwABitMask    = 0xf000;
                    return;

                case 30:
                    this.pvrPixelFormat = 0L;
                    return;

                case 0x1f:
                    this.pvrPixelFormat = 1L;
                    return;

                case 0x20:
                    this.pvrPixelFormat = 2L;
                    return;

                case 0x21:
                    this.pvrPixelFormat = 3L;
                    return;

                case 0x22:
                    this.pvrPixelFormat = 0x16L;
                    return;

                default:
                    return;
                }
                this.dwFlags2      = 0x41;
                this.dwRGBBitCount = 0x10;
                this.dwRBitMask    = 0xf00;
                this.dwGBitMask    = 240;
                this.dwBBitMask    = 15;
                this.dwABitMask    = 0xf000;
                return;
            }
Label_0E7B:
            switch (this.m_FilterMode)
            {
            case 0:
                preloadData.InfoText = preloadData.InfoText + "\nFilter Mode: Point ";
                break;

            case 1:
                preloadData.InfoText = preloadData.InfoText + "\nFilter Mode: Bilinear ";
                break;

            case 2:
                preloadData.InfoText = preloadData.InfoText + "\nFilter Mode: Trilinear ";
                break;
            }
            AssetPreloadData data = preloadData;

            string[] textArray2 = new string[] { data.InfoText, "\nAnisotropic level: ", this.m_Aniso.ToString(), "\nMip map bias: ", this.m_MipBias.ToString() };
            data.InfoText = string.Concat(textArray2);
            switch (this.m_WrapMode)
            {
            case 0:
                preloadData.InfoText = preloadData.InfoText + "\nWrap mode: Repeat";
                break;

            case 1:
                preloadData.InfoText = preloadData.InfoText + "\nWrap mode: Clamp";
                break;
            }
        }
示例#4
0
        public Mesh(AssetPreloadData MeshPD)
        {
            //Stream = new EndianStream(File.OpenRead(sourceFile.filePath), sourceFile.endianType);
            //Stream.endian = sourceFile.endianType;
            var version = MeshPD.sourceFile.version;
            a_Stream = MeshPD.sourceFile.a_Stream;
            a_Stream.Position = MeshPD.Offset;

            bool m_Use16BitIndices = true; //3.5.0 and newer always uses 16bit indices
            uint m_MeshCompression = 0;

            if (MeshPD.sourceFile.platform == -2)
            {
                uint m_ObjectHideFlags = a_Stream.ReadUInt32();
                PPtr m_PrefabParentObject = MeshPD.sourceFile.ReadPPtr();
                PPtr m_PrefabInternal = MeshPD.sourceFile.ReadPPtr();
            }

            m_Name = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
            if (version[0] < 3 || (version[0] == 3 && version[1] < 5))
            {
                m_Use16BitIndices = a_Stream.ReadBoolean();
                a_Stream.Position += 3;
            }

            #region Index Buffer for 2.5.1 and earlier
            if (version[0] == 2 && version[1] <= 5)
            {
                int m_IndexBuffer_size = a_Stream.ReadInt32();

                if (m_Use16BitIndices)
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 2];
                    for (int i = 0; i < m_IndexBuffer_size / 2; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt16(); }
                    a_Stream.AlignStream(4);
                }
                else
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 4];
                    for (int i = 0; i < m_IndexBuffer_size / 4; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt32(); }
                }
            }
            #endregion

            int m_SubMeshes_size = a_Stream.ReadInt32();
            for (int s = 0; s < m_SubMeshes_size; s++)
            {
                m_SubMeshes.Add(new SubMesh());
                m_SubMeshes[s].firstByte = a_Stream.ReadUInt32();
                m_SubMeshes[s].indexCount = a_Stream.ReadUInt32(); //what is this in case of triangle strips?
                m_SubMeshes[s].topology = a_Stream.ReadInt32(); //isTriStrip
                if (version[0] < 4)
                {
                    m_SubMeshes[s].triangleCount = a_Stream.ReadUInt32();
                }
                if (version[0] >= 3)
                {
                    m_SubMeshes[s].firstVertex = a_Stream.ReadUInt32();
                    m_SubMeshes[s].vertexCount = a_Stream.ReadUInt32();
                    a_Stream.Position += 24; //Axis-Aligned Bounding Box
                }
            }

            #region m_Shapes for 4.1.0 and later, excluding 4.1.0 alpha
            if (version [0] >= 5 || (version[0] == 4 && (version[1] > 1 || (version[1] == 1 && MeshPD.sourceFile.buildType[0] != "a"))))
            {
                if (version[0] == 4 && version[1] <= 2) //4.1.0f4 - 4.2.2f1
                {
                    int m_Shapes_size = a_Stream.ReadInt32();
                    if (m_Shapes_size > 0)
                    {
                        bool stop = true;
                    }
                    for (int s = 0; s < m_Shapes_size; s++) //untested
                    {
                        string shape_name = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
                        a_Stream.Position += 36; //uint firstVertex, vertexCount; Vector3f aabbMinDelta, aabbMaxDelta; bool hasNormals, hasTangents
                    }

                    int m_ShapeVertices_size = a_Stream.ReadInt32();
                    a_Stream.Position += m_ShapeVertices_size * 40; //vertex positions, normals, tangents & uint index
                }
                else //4.3.0 and later
                {
                    int m_ShapeVertices_size = a_Stream.ReadInt32();
                    a_Stream.Position += m_ShapeVertices_size * 40; //vertex positions, normals, tangents & uint index

                    int shapes_size = a_Stream.ReadInt32();
                    a_Stream.Position += shapes_size * 12; //uint firstVertex, vertexCount; bool hasNormals, hasTangents

                    int channels_size = a_Stream.ReadInt32();
                    for (int c = 0; c < channels_size; c++)
                    {
                        string channel_name = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
                        a_Stream.Position += 12; //uint nameHash; int frameIndex, frameCount
                    }

                    int fullWeights_size = a_Stream.ReadInt32();
                    a_Stream.Position += fullWeights_size * 4; //floats

                    int m_BindPose_size = a_Stream.ReadInt32();
                    a_Stream.Position += m_BindPose_size * 16 * 4; //matrix 4x4

                    int m_BoneNameHashes_size = a_Stream.ReadInt32();
                    a_Stream.Position += m_BoneNameHashes_size * 4; //uints

                    uint m_RootBoneNameHash = a_Stream.ReadUInt32();
                }
            }
            #endregion

            #region Index Buffer for 2.6.0 and later
            if (version[0] >= 3 || (version[0] == 2 && version[1] >= 6))
            {
                m_MeshCompression = a_Stream.ReadByte();
                if (version[0] >= 4)
                {
                    if (version[0] < 5) { uint m_StreamCompression = a_Stream.ReadByte(); }
                    bool m_IsReadable = a_Stream.ReadBoolean();
                    bool m_KeepVertices = a_Stream.ReadBoolean();
                    bool m_KeepIndices = a_Stream.ReadBoolean();
                }
                a_Stream.AlignStream(4);

                int m_IndexBuffer_size = a_Stream.ReadInt32();

                if (m_Use16BitIndices)
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 2];
                    for (int i = 0; i < m_IndexBuffer_size / 2; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt16(); }
                    a_Stream.AlignStream(4);
                }
                else
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 4];
                    for (int i = 0; i < m_IndexBuffer_size / 4; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt32(); }
                    //align??
                }
            }
            #endregion

            #region Vertex Buffer for 3.4.2 and earlier
            if (version[0] < 3 || (version[0] == 3 && version[1] < 5))
            {
                m_VertexCount = a_Stream.ReadUInt32();
                m_Vertices = new float[m_VertexCount * 3];
                for (int v = 0; v < m_VertexCount * 3; v++) { m_Vertices[v] = a_Stream.ReadSingle(); }

                int m_Skin_size = a_Stream.ReadInt32();
                a_Stream.Position += m_Skin_size * 32; //4x float weights & 4x int boneIndices

                int m_BindPose_size = a_Stream.ReadInt32();
                a_Stream.Position += m_BindPose_size * 16 * 4; //matrix 4x4

                int m_UV1_size = a_Stream.ReadInt32();
                m_UV1 = new float[m_UV1_size * 2];
                for (int v = 0; v < m_UV1_size * 2; v++) { m_UV1[v] = a_Stream.ReadSingle(); }

                int m_UV2_size = a_Stream.ReadInt32();
                m_UV2 = new float[m_UV2_size * 2];
                for (int v = 0; v < m_UV2_size * 2; v++) { m_UV2[v] = a_Stream.ReadSingle(); }

                if (version[0] == 2 && version[1] <= 5)
                {
                    int m_TangentSpace_size = a_Stream.ReadInt32();
                    m_Normals = new float[m_TangentSpace_size * 3];
                    for (int v = 0; v < m_TangentSpace_size; v++)
                    {
                        m_Normals[v * 3] = a_Stream.ReadSingle();
                        m_Normals[v * 3 + 1] = a_Stream.ReadSingle();
                        m_Normals[v * 3 + 2] = a_Stream.ReadSingle();
                        a_Stream.Position += 16; //Vector3f tangent & float handedness
                    }
                }
                else //2.6.0 and later
                {
                    int m_Tangents_size = a_Stream.ReadInt32();
                    a_Stream.Position += m_Tangents_size * 16; //Vector4f

                    int m_Normals_size = a_Stream.ReadInt32();
                    m_Normals = new float[m_Normals_size * 3];
                    for (int v = 0; v < m_Normals_size * 3; v++) { m_Normals[v] = a_Stream.ReadSingle(); }
                }
            }
            #endregion
            #region Vertex Buffer for 3.5.0 and later
            else
            {
                #region read vertex stream
                int m_Skin_size = a_Stream.ReadInt32();
                a_Stream.Position += m_Skin_size * 32; //4x float weights & 4x int boneIndices

                if (version[0] <= 3 || (version[0] == 4 && version[1] <= 2))
                {
                    int m_BindPose_size = a_Stream.ReadInt32();
                    a_Stream.Position += m_BindPose_size * 16 * 4; //matrix 4x4
                }

                int m_CurrentChannels = a_Stream.ReadInt32();//defined as uint in Unity
                m_VertexCount = a_Stream.ReadUInt32();

                #region 3.5.0 - 3.5.7
                if (version[0] < 4)
                {
                    if (m_MeshCompression != 0 && version[2] == 0) //special case not just on platform 9
                    {
                        a_Stream.Position += 12;
                    }
                    else
                    {
                        m_Streams = new StreamInfo[4];
                        for (int s = 0; s < 4; s++)
                        {
                            m_Streams[s] = new StreamInfo();
                            m_Streams[s].channelMask = new BitArray(new int[1] { a_Stream.ReadInt32() });
                            m_Streams[s].offset = a_Stream.ReadInt32();
                            m_Streams[s].stride = a_Stream.ReadInt32();
                            m_Streams[s].align = a_Stream.ReadUInt32();
                        }
                    }
                }
                #endregion
                #region 4.0.0 and later
                else
                {
                    int singleStreamStride = 0;//used tor unity 5

                    m_Channels = new ChannelInfo[a_Stream.ReadInt32()];
                    for (int c = 0; c < m_Channels.Length; c++)
                    {
                        m_Channels[c] = new ChannelInfo();
                        m_Channels[c].stream = a_Stream.ReadByte();
                        m_Channels[c].offset = a_Stream.ReadByte();
                        m_Channels[c].format = a_Stream.ReadByte();
                        m_Channels[c].dimension = a_Stream.ReadByte();

                        //calculate stride for Unity 5
                        singleStreamStride += m_Channels[c].dimension * (m_Channels[c].format % 2 == 0 ? 4 : 2);//fingers crossed!
                    }

                    if (version[0] < 5)
                    {
                        m_Streams = new StreamInfo[a_Stream.ReadInt32()];
                        for (int s = 0; s < m_Streams.Length; s++)
                        {
                            m_Streams[s] = new StreamInfo();
                            m_Streams[s].channelMask = new BitArray(new int[1] { a_Stream.ReadInt32() });
                            m_Streams[s].offset = a_Stream.ReadInt32();
                            m_Streams[s].stride = a_Stream.ReadByte();
                            m_Streams[s].dividerOp = a_Stream.ReadByte();
                            m_Streams[s].frequency = a_Stream.ReadUInt16();
                        }
                    }
                    else //it's just easier to create my own stream here
                    {
                        m_Streams = new StreamInfo[1];
                        m_Streams[0] = new StreamInfo();
                        m_Streams[0].channelMask = new BitArray(new int[1] { m_CurrentChannels });
                        m_Streams[0].offset = 0;
                        m_Streams[0].stride = singleStreamStride;
                    }
                }
                #endregion

                //actual Vertex Buffer
                byte[] m_DataSize = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_DataSize, 0, m_DataSize.Length);
                #endregion

                #region compute FvF
                byte valueBufferSize = 0;
                byte[] valueBuffer;
                float[] dstArray;

                if (m_Channels != null)
                {
                    //it is better to loop channels instead of streams
                    //because channels are likely to be sorted by vertex property
                    #region 4.0.0 and later
                    foreach (var m_Channel in m_Channels)
                    {
                        if (m_Channel.dimension > 0)
                        {
                            var m_Stream = m_Streams[m_Channel.stream];

                            for (int b = 0; b < 6; b++)
                            {
                                if (m_Stream.channelMask.Get(b))
                                {
                                    switch (m_Channel.format)
                                    {
                                        case 0: //32bit
                                            valueBufferSize = 4;
                                            break;
                                        case 1: //16bit
                                            valueBufferSize = 2;
                                            break;
                                        case 2: //8bit
                                            valueBufferSize = 1;
                                            m_Channel.dimension = 4;//these are actually groups of 4 components
                                            break;
                                    }

                                    valueBuffer = new byte[valueBufferSize];
                                    dstArray = new float[m_VertexCount * m_Channel.dimension];

                                    for (int v = 0; v < m_VertexCount; v++)
                                    {
                                        for (int d = 0; d < m_Channel.dimension; d++)
                                        {
                                            int m_DataSizeOffset = m_Stream.offset + m_Channel.offset + m_Stream.stride * v + valueBufferSize * d;
                                            Buffer.BlockCopy(m_DataSize, m_DataSizeOffset, valueBuffer, 0, valueBufferSize);
                                            dstArray[v * m_Channel.dimension + d] = bytesToFloat(valueBuffer);
                                        }
                                    }

                                    switch (b)
                                    {
                                        case 0://1
                                            m_Vertices = dstArray;
                                            break;
                                        case 1://2
                                            m_Normals = dstArray;
                                            break;
                                        case 2://4
                                            m_Colors = dstArray;
                                            break;
                                        case 3://8
                                            m_UV1 = dstArray;
                                            break;
                                        case 4://16
                                            m_UV2 = dstArray;
                                            break;
                                        case 5://32
                                            m_Tangents = dstArray;
                                            break;
                                    }

                                    m_Stream.channelMask.Set(b, false); //is this needed?
                                    valueBuffer = null;
                                    dstArray = null;
                                    break; //go to next channel
                                }
                            }
                        }
                    }
                }
                #endregion
                #region 3.5.0 - 3.5.7
                else if (m_Streams != null)
                {
                    foreach (var m_Stream in m_Streams)
                    {
                        //a stream may have multiple vertex components but without channels there are no offsets, so I assume all vertex properties are in order
                        //Unity 3.5.x only uses floats, and that's probably why channels were introduced in Unity 4

                        ChannelInfo m_Channel = new ChannelInfo();//create my own channel so I can use the same methods
                        m_Channel.offset = 0;

                        for (int b = 0; b < 6; b++)
                        {
                            if (m_Stream.channelMask.Get(b))
                            {
                                switch (b)
                                {
                                    case 0:
                                    case 1:
                                        valueBufferSize = 4;
                                        m_Channel.dimension = 3;
                                        break;
                                    case 2:
                                        valueBufferSize = 1;
                                        m_Channel.dimension = 4;
                                        break;
                                    case 3:
                                    case 4:
                                        valueBufferSize = 4;
                                        m_Channel.dimension = 2;
                                        break;
                                    case 5:
                                        valueBufferSize = 4;
                                        m_Channel.dimension = 4;
                                        break;
                                }

                                valueBuffer = new byte[valueBufferSize];
                                dstArray = new float[m_VertexCount * m_Channel.dimension];

                                for (int v = 0; v < m_VertexCount; v++)
                                {
                                    for (int d = 0; d < m_Channel.dimension; d++)
                                    {
                                        int m_DataSizeOffset = m_Stream.offset + m_Channel.offset + m_Stream.stride * v + valueBufferSize * d;
                                        Buffer.BlockCopy(m_DataSize, m_DataSizeOffset, valueBuffer, 0, valueBufferSize);
                                        dstArray[v * m_Channel.dimension + d] = bytesToFloat(valueBuffer);
                                    }
                                }

                                switch (b)
                                {
                                    case 0:
                                        m_Vertices = dstArray;
                                        break;
                                    case 1:
                                        m_Normals = dstArray;
                                        break;
                                    case 2:
                                        m_Colors = dstArray;
                                        break;
                                    case 3:
                                        m_UV1 = dstArray;
                                        break;
                                    case 4:
                                        m_UV2 = dstArray;
                                        break;
                                    case 5:
                                        m_Tangents = dstArray;
                                        break;
                                }

                                m_Channel.offset += (byte)(m_Channel.dimension * valueBufferSize); //strides larger than 255 are unlikely
                                m_Stream.channelMask.Set(b, false); //is this needed?
                                valueBuffer = null;
                                dstArray = null;
                            }
                        }
                    }
                }
                #endregion
                #endregion
            }
            #endregion

            #region Compressed Mesh data for 2.6.0 and later - 160 bytes
            if (version[0] >= 3 || (version[0] == 2 && version[1] >= 6))
            {
                //remember there can be combinations of packed and regular vertex properties
                PackedBitVector m_Vertices_Packed = new PackedBitVector();
                m_Vertices_Packed.m_NumItems = a_Stream.ReadUInt32();
                m_Vertices_Packed.m_Range = a_Stream.ReadSingle();
                m_Vertices_Packed.m_Start = a_Stream.ReadSingle();
                m_Vertices_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Vertices_Packed.m_Data, 0, m_Vertices_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Vertices_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_Vertices_Packed.m_NumItems > 0)
                {
                    m_VertexCount = m_Vertices_Packed.m_NumItems / 3;
                    uint[] m_Vertices_Unpacked = UnpackBitVector(m_Vertices_Packed);
                    int bitmax = 0;//used to convert int value to float
                    for (int b = 0; b < m_Vertices_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                    m_Vertices = new float[m_Vertices_Packed.m_NumItems];
                    for (int v = 0; v < m_Vertices_Packed.m_NumItems; v++)
                    {
                        m_Vertices[v] = (float)m_Vertices_Unpacked[v] / bitmax * m_Vertices_Packed.m_Range + m_Vertices_Packed.m_Start;
                    }
                }

                PackedBitVector m_UV_Packed = new PackedBitVector(); //contains both channels
                m_UV_Packed.m_NumItems = a_Stream.ReadUInt32();
                m_UV_Packed.m_Range = a_Stream.ReadSingle();
                m_UV_Packed.m_Start = a_Stream.ReadSingle();
                m_UV_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_UV_Packed.m_Data, 0, m_UV_Packed.m_Data.Length);
                m_UV_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_UV_Packed.m_NumItems > 0)
                {
                    uint[] m_UV_Unpacked = UnpackBitVector(m_UV_Packed);
                    int bitmax = 0;
                    for (int b = 0; b < m_Vertices_Packed.m_BitSize; b++) { bitmax |= (1 << b); }

                    m_UV1 = new float[m_VertexCount * 2];

                    for (int v = 0; v < m_VertexCount * 2; v++)
                    {
                        m_UV1[v] = (float)m_UV_Unpacked[v] / bitmax * m_UV_Packed.m_Range + m_UV_Packed.m_Start;
                    }

                    if (m_UV_Packed.m_NumItems == m_VertexCount * 4)
                    {
                        m_UV2 = new float[m_VertexCount * 2];
                        for (uint v = 0; v < m_VertexCount * 2; v++)
                        {
                            m_UV2[v] = (float)m_UV_Unpacked[v + m_VertexCount * 2] / bitmax * m_UV_Packed.m_Range + m_UV_Packed.m_Start;
                        }
                    }
                }

                if (version[0] < 5)
                {
                    PackedBitVector m_BindPoses_Packed = new PackedBitVector();
                    m_BindPoses_Packed.m_NumItems = a_Stream.ReadUInt32();
                    m_BindPoses_Packed.m_Range = a_Stream.ReadSingle();
                    m_BindPoses_Packed.m_Start = a_Stream.ReadSingle();
                    m_BindPoses_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                    a_Stream.Read(m_BindPoses_Packed.m_Data, 0, m_BindPoses_Packed.m_Data.Length);
                    a_Stream.AlignStream(4);
                    m_BindPoses_Packed.m_BitSize = a_Stream.ReadByte();
                    a_Stream.Position += 3; //4 byte alignment
                }

                PackedBitVector m_Normals_Packed = new PackedBitVector();
                m_Normals_Packed.m_NumItems = a_Stream.ReadUInt32();
                m_Normals_Packed.m_Range = a_Stream.ReadSingle();
                m_Normals_Packed.m_Start = a_Stream.ReadSingle();
                m_Normals_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Normals_Packed.m_Data, 0, m_Normals_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Normals_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                PackedBitVector m_Tangents_Packed = new PackedBitVector();
                m_Tangents_Packed.m_NumItems = a_Stream.ReadUInt32();
                m_Tangents_Packed.m_Range = a_Stream.ReadSingle();
                m_Tangents_Packed.m_Start = a_Stream.ReadSingle();
                m_Tangents_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Tangents_Packed.m_Data, 0, m_Tangents_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Tangents_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                PackedBitVector m_Weights_Packed = new PackedBitVector();
                m_Weights_Packed.m_NumItems = a_Stream.ReadUInt32();
                m_Weights_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Weights_Packed.m_Data, 0, m_Weights_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Weights_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                PackedBitVector m_NormalSigns_packed = new PackedBitVector();
                m_NormalSigns_packed.m_NumItems = a_Stream.ReadUInt32();
                m_NormalSigns_packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_NormalSigns_packed.m_Data, 0, m_NormalSigns_packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_NormalSigns_packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_Normals_Packed.m_NumItems > 0)
                {
                    uint[] m_Normals_Unpacked = UnpackBitVector(m_Normals_Packed);
                    uint[] m_NormalSigns = UnpackBitVector(m_NormalSigns_packed);
                    int bitmax = 0;
                    for (int b = 0; b < m_Normals_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                    m_Normals = new float[m_Normals_Packed.m_NumItems / 2 * 3];
                    for (int v = 0; v < m_Normals_Packed.m_NumItems / 2; v++)
                    {
                        m_Normals[v * 3] = (float)((double)m_Normals_Unpacked[v * 2] / bitmax) * m_Normals_Packed.m_Range + m_Normals_Packed.m_Start;
                        m_Normals[v * 3 + 1] = (float)((double)m_Normals_Unpacked[v * 2 + 1] / bitmax) * m_Normals_Packed.m_Range + m_Normals_Packed.m_Start;
                        m_Normals[v * 3 + 2] = (float)Math.Sqrt(1 - m_Normals[v * 3] * m_Normals[v * 3] - m_Normals[v * 3 + 1] * m_Normals[v * 3 + 1]);
                        if (m_NormalSigns[v] == 0) { m_Normals[v * 3 + 2] *= -1; }
                    }
                }

                PackedBitVector m_TangentSigns = new PackedBitVector();
                m_TangentSigns.m_NumItems = a_Stream.ReadUInt32();
                m_TangentSigns.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_TangentSigns.m_Data, 0, m_TangentSigns.m_Data.Length);
                a_Stream.AlignStream(4);
                m_TangentSigns.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (version[0] >= 5)
                {
                    PackedBitVector m_FloatColors = new PackedBitVector();
                    m_FloatColors.m_NumItems = a_Stream.ReadUInt32();
                    m_FloatColors.m_Range = a_Stream.ReadSingle();
                    m_FloatColors.m_Start = a_Stream.ReadSingle();
                    m_FloatColors.m_Data = new byte[a_Stream.ReadInt32()];
                    a_Stream.Read(m_FloatColors.m_Data, 0, m_FloatColors.m_Data.Length);
                    a_Stream.AlignStream(4);
                    m_FloatColors.m_BitSize = a_Stream.ReadByte();
                    a_Stream.Position += 3; //4 byte alignment

                    if (m_FloatColors.m_NumItems > 0)
                    {
                        uint[] m_FloatColors_Unpacked = UnpackBitVector(m_FloatColors);
                        int bitmax = 0;
                        for (int b = 0; b < m_Vertices_Packed.m_BitSize; b++) { bitmax |= (1 << b); }

                        m_Colors = new float[m_FloatColors.m_NumItems];

                        for (int v = 0; v < m_FloatColors.m_NumItems; v++)
                        {
                            m_Colors[v] = (float)m_FloatColors_Unpacked[v] / bitmax * m_FloatColors.m_Range + m_FloatColors.m_Start;
                        }
                    }
                }

                PackedBitVector m_BoneIndices = new PackedBitVector();
                m_BoneIndices.m_NumItems = a_Stream.ReadUInt32();
                m_BoneIndices.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_BoneIndices.m_Data, 0, m_BoneIndices.m_Data.Length);
                a_Stream.AlignStream(4);
                m_BoneIndices.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                PackedBitVector m_Triangles = new PackedBitVector();
                m_Triangles.m_NumItems = a_Stream.ReadUInt32();
                m_Triangles.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Triangles.m_Data, 0, m_Triangles.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Triangles.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_Triangles.m_NumItems > 0) { m_IndexBuffer = UnpackBitVector(m_Triangles); }
            }
            #endregion

            #region Colors & Collision triangles for 3.4.2 and earlier
            if (version[0] <= 2 || (version[0] == 3 && version[1] <= 4)) //
            {
                a_Stream.Position += 24; //Axis-Aligned Bounding Box
                int m_Colors_size = a_Stream.ReadInt32();
                m_Colors = new float[m_Colors_size * 4];
                for (int v = 0; v < m_Colors_size * 4; v++) { m_Colors[v] = (float)(a_Stream.ReadByte()) / 0xFF; }

                int m_CollisionTriangles_size = a_Stream.ReadInt32();
                a_Stream.Position += m_CollisionTriangles_size * 4; //UInt32 indices
                int m_CollisionVertexCount = a_Stream.ReadInt32();
            }
            #endregion
            #region Compressed colors & Local AABB for 3.5.0 to 4.x.x
            else //vertex colors are either in streams or packed bits
            {
                if (version[0] < 5)
                {
                    PackedBitVector m_Colors_Packed = new PackedBitVector();
                    m_Colors_Packed.m_NumItems = a_Stream.ReadUInt32();
                    m_Colors_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                    a_Stream.Read(m_Colors_Packed.m_Data, 0, m_Colors_Packed.m_Data.Length);
                    a_Stream.AlignStream(4);
                    m_Colors_Packed.m_BitSize = a_Stream.ReadByte();
                    a_Stream.Position += 3; //4 byte alignment

                    if (m_Colors_Packed.m_NumItems > 0)
                    {
                        if (m_Colors_Packed.m_BitSize == 32)
                        {
                            //4 x 8bit color channels
                            m_Colors = new float[m_Colors_Packed.m_Data.Length];
                            for (int v = 0; v < m_Colors_Packed.m_Data.Length; v++)
                            {
                                m_Colors[v] = (float)m_Colors_Packed.m_Data[v] / 0xFF;
                            }
                        }
                        else //not tested
                        {
                            uint[] m_Colors_Unpacked = UnpackBitVector(m_Colors_Packed);
                            int bitmax = 0;//used to convert int value to float
                            for (int b = 0; b < m_Colors_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                            m_Colors = new float[m_Colors_Packed.m_NumItems];
                            for (int v = 0; v < m_Colors_Packed.m_NumItems; v++)
                            {
                                m_Colors[v] = (float)m_Colors_Unpacked[v] / bitmax;
                            }
                        }
                    }
                }

                a_Stream.Position += 24; //Axis-Aligned Bounding Box
            }
            #endregion

            int m_MeshUsageFlags = a_Stream.ReadInt32();

            if (version[0] >= 5)
            {
                //int m_BakedConvexCollisionMesh = a_Stream.ReadInt32();
                //a_Stream.Position += m_BakedConvexCollisionMesh;
                //int m_BakedTriangleCollisionMesh = a_Stream.ReadInt32();
                //a_Stream.Position += m_BakedConvexCollisionMesh;
            }

            #region Build face indices
            for (int s = 0; s < m_SubMeshes_size; s++)
            {
                uint firstIndex = m_SubMeshes[s].firstByte / 2;
                if (!m_Use16BitIndices) { firstIndex /= 2; }

                if (m_SubMeshes[s].topology == 0)
                {
                    for (int i = 0; i < m_SubMeshes[s].indexCount / 3; i++)
                    {
                        m_Indices.Add(m_IndexBuffer[firstIndex + i * 3]);
                        m_Indices.Add(m_IndexBuffer[firstIndex + i * 3 + 1]);
                        m_Indices.Add(m_IndexBuffer[firstIndex + i * 3 + 2]);
                        m_materialIDs.Add(s);
                    }
                }
                else
                {
                    for (int i = 0; i < m_SubMeshes[s].indexCount - 2; i++)
                    {
                        uint fa = m_IndexBuffer[firstIndex + i];
                        uint fb = m_IndexBuffer[firstIndex + i + 1];
                        uint fc = m_IndexBuffer[firstIndex + i + 2];

                        if ((fa!=fb) && (fa!=fc) && (fc!=fb))
                        {
                            m_Indices.Add(fa);
                            if ((i % 2) == 0)
                            {
                                m_Indices.Add(fb);
                                m_Indices.Add(fc);
                            }
                            else
                            {
                                m_Indices.Add(fc);
                                m_Indices.Add(fb);
                            }
                            m_materialIDs.Add(s);
                        }
                    }
                }
            }
            #endregion
        }
示例#5
0
        public AssetsFile(string fullName, EndianStream fileStream)
        {
            //if (memFile != null) { Stream = new EndianStream(memFile, endianType); }
            //else { Stream = new EndianStream(File.OpenRead(fileName), endianType); }
            a_Stream = fileStream;

            filePath = fullName;
            fileName = Path.GetFileName(fullName);
            int tableSize = a_Stream.ReadInt32();
            int dataEnd   = a_Stream.ReadInt32();

            fileGen = a_Stream.ReadInt32();
            uint dataOffset = a_Stream.ReadUInt32();

            sharedAssetsList[0].fileName = Path.GetFileName(fullName); //reference itself because sharedFileIDs start from 1

            switch (fileGen)
            {
            case 6:    //2.5.0 - 2.6.1
            {
                a_Stream.Position  = (dataEnd - tableSize);
                a_Stream.Position += 1;
                break;
            }

            case 7:    //3.0.0 beta
            {
                a_Stream.Position  = (dataEnd - tableSize);
                a_Stream.Position += 1;
                m_Version          = a_Stream.ReadStringToNull();
                break;
            }

            case 8:    //3.0.0 - 3.4.2
            {
                a_Stream.Position  = (dataEnd - tableSize);
                a_Stream.Position += 1;
                m_Version          = a_Stream.ReadStringToNull();
                platform           = a_Stream.ReadInt32();
                break;
            }

            case 9:                     //3.5.0 - 4.6.x
            {
                a_Stream.Position += 4; //azero
                m_Version          = a_Stream.ReadStringToNull();
                platform           = a_Stream.ReadInt32();
                break;
            }

            case 14:                    //5.0.0 beta and final
            case 15:                    //5.0.1 - 5.4
            case 16:                    //??.. no sure
            case 17:                    //5.5.0 and up
            {
                a_Stream.Position += 4; //azero
                m_Version          = a_Stream.ReadStringToNull();
                platform           = a_Stream.ReadInt32();
                baseDefinitions    = a_Stream.ReadBoolean();
                break;
            }

            default:
            {
                //MessageBox.Show("Unsupported Unity version!" + fileGen, "Unity Studio Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            }

            if (platform > 255 || platform < 0)
            {
                byte[] b32 = BitConverter.GetBytes(platform);
                Array.Reverse(b32);
                platform = BitConverter.ToInt32(b32, 0);
                //endianType = EndianType.LittleEndian;
                a_Stream.endian = EndianType.LittleEndian;
            }

            switch (platform)
            {
            case -2: platformStr = "Unity Package"; break;

            case 4: platformStr = "OSX"; break;

            case 5: platformStr = "PC"; break;

            case 6: platformStr = "Web"; break;

            case 7: platformStr = "Web streamed"; break;

            case 9: platformStr = "iOS"; break;

            case 10: platformStr = "PS3"; break;

            case 11: platformStr = "Xbox 360"; break;

            case 13: platformStr = "Android"; break;

            case 16: platformStr = "Google NaCl"; break;

            case 21: platformStr = "WP8"; break;

            case 25: platformStr = "Linux"; break;

            case 29: platformStr = "Wii U"; break;

            default: platformStr = "Unknown Platform"; break;
            }

            int baseCount = a_Stream.ReadInt32();

            for (int i = 0; i < baseCount; i++)
            {
                if (fileGen < 14)
                {
                    int    classID  = a_Stream.ReadInt32();
                    string baseType = a_Stream.ReadStringToNull();
                    string baseName = a_Stream.ReadStringToNull();
                    a_Stream.Position += 20;
                    int memberCount = a_Stream.ReadInt32();

                    var cb = new List <ClassMember>();
                    for (int m = 0; m < memberCount; m++)
                    {
                        readBase(cb, 1);
                    }

                    var aClass = new ClassStruct()
                    {
                        ID = classID, Text = (baseType + " " + baseName), members = cb
                    };
                    aClass.SubItems.Add(classID.ToString());
                    ClassStructures.Add(classID, aClass);
                }
                else
                {
                    readBase5();
                }
            }

            if (fileGen >= 7 && fileGen < 14)
            {
                a_Stream.Position += 4;
            }                                                            //azero

            int assetCount = a_Stream.ReadInt32();

            #region asset preload table
            string assetIDfmt = "D" + assetCount.ToString().Length; //format for unique ID

            for (int i = 0; i < assetCount; i++)
            {
                //each table entry is aligned individually, not the whole table
                if (fileGen >= 14)
                {
                    a_Stream.AlignStream(4);
                }

                AssetPreloadData asset = new AssetPreloadData();
                if (fileGen < 14)
                {
                    asset.m_PathID = a_Stream.ReadInt32();
                }
                else
                {
                    asset.m_PathID = a_Stream.ReadInt64();
                }
                asset.Offset  = a_Stream.ReadUInt32();
                asset.Offset += dataOffset;
                asset.Size    = a_Stream.ReadInt32();
                if (fileGen > 15)
                {
                    int index = a_Stream.ReadInt32();
                    asset.Type1 = classIDs[index][0];
                    asset.Type2 = (ushort)classIDs[index][1];
                }
                else
                {
                    asset.Type1        = a_Stream.ReadInt32();
                    asset.Type2        = a_Stream.ReadUInt16();
                    a_Stream.Position += 2;
                }
                if (fileGen == 15)
                {
                    byte unknownByte = a_Stream.ReadByte();
                    //this is a single byte, not an int32
                    //the next entry is aligned after this
                    //but not the last!
                    if (unknownByte != 0)
                    {
                        //bool investigate = true;
                    }
                }

                string typeString;
                if (ClassIDReference.Names.TryGetValue(asset.Type2, out typeString))
                {
                    asset.TypeString = typeString;
                }
                else
                {
                    asset.TypeString = "Unknown Type " + asset.Type2;
                }

                asset.uniqueID = i.ToString(assetIDfmt);

                asset.sourceFile = this;

                preloadTable.Add(asset.m_PathID, asset);

                #region read BuildSettings to get version for unity 2.x files
                if (asset.Type2 == 141 && fileGen == 6)
                {
                    long nextAsset = a_Stream.Position;

                    BuildSettings BSettings = new BuildSettings(asset);
                    m_Version = BSettings.m_Version;

                    a_Stream.Position = nextAsset;
                }
                #endregion
            }
            #endregion

            buildType = m_Version.Split(buildTypeSplit, StringSplitOptions.RemoveEmptyEntries);
            var strver = m_Version.Split(strverSplit, StringSplitOptions.RemoveEmptyEntries);
            version = Array.ConvertAll(strver, int.Parse);

            if (fileGen >= 14)
            {
                //this looks like a list of assets that need to be preloaded in memory before anytihng else
                int someCount = a_Stream.ReadInt32();
                for (int i = 0; i < someCount; i++)
                {
                    int num1 = a_Stream.ReadInt32();
                    a_Stream.AlignStream(4);
                    long m_PathID = a_Stream.ReadInt64();
                }
            }

            int sharedFileCount = a_Stream.ReadInt32();
            for (int i = 0; i < sharedFileCount; i++)
            {
                UnityShared shared = new UnityShared();
                shared.aName       = a_Stream.ReadStringToNull();
                a_Stream.Position += 20;
                string sharedFileName = a_Stream.ReadStringToNull(); //relative path
                shared.fileName = sharedFileName.Replace("/", "\\");
                sharedAssetsList.Add(shared);
            }
        }
示例#6
0
    public static void Write(byte[] data, string file)
    {
        Unity_Studio.EndianStream stream = new Unity_Studio.EndianStream(new System.IO.MemoryStream(data), Unity_Studio.EndianType.LittleEndian);

        // Because constructor is broken
        stream.endian = Unity_Studio.EndianType.LittleEndian;

        string magic = stream.ReadASCII(4);

        if (!magic.Equals("FSB5"))
        {
            return;
        }

        uint version           = stream.ReadUInt32();
        uint numSamples        = stream.ReadUInt32();
        uint sampleHeadersSize = stream.ReadUInt32();
        uint nameTableSize     = stream.ReadUInt32();
        uint dataSize          = stream.ReadUInt32();
        uint mode = stream.ReadUInt32();

        string zero  = stream.ReadASCII(8);
        string hash  = stream.ReadASCII(16);
        string dummy = stream.ReadASCII(8);

        long nameOffset = stream.Position + sampleHeadersSize;
        long baseOffset = nameOffset + nameTableSize;

        // Only support Vorbis
        if (mode != (int)FSBAudioFormat.FMOD_SOUND_FORMAT_VORBIS)
        {
            return;
        }

        for (int i = 0; i < numSamples; i++)
        {
            Ogg  ogg          = new Ogg();
            uint offset       = stream.ReadUInt32();
            bool extraHeaders = (offset & 0x01) != 0;
            uint type         = offset & ((1 << 7) - 1);
            offset        = (offset >> 7) * 0x20;
            ogg.channels  = (type >> 5) + 1;
            ogg.frequency = 44100;
            switch ((type >> 1) & ((1 << 4) - 1))
            {
            case 0: ogg.frequency = 4000; break;

            case 1: ogg.frequency = 8000; break;

            case 2: ogg.frequency = 11000; break;

            case 3: ogg.frequency = 12000; break;

            case 4: ogg.frequency = 16000; break;

            case 5: ogg.frequency = 22050; break;

            case 6: ogg.frequency = 24000; break;

            case 7: ogg.frequency = 32000; break;

            case 8: ogg.frequency = 44100; break;

            case 9: ogg.frequency = 48000; break;

            case 10: ogg.frequency = 96000; break;

            default: ogg.frequency = 44100; break;
            }

            uint unknown = stream.ReadUInt32() >> 2;

            while (extraHeaders)
            {
                byte dataByte = stream.ReadByte();
                extraHeaders = (dataByte & 0x01) != 0;
                long extraLen = dataByte >> 1;
                extraLen += stream.ReadByte() << 7;
                extraLen += stream.ReadByte() << 15;
                dataByte  = stream.ReadByte();
                if (dataByte == 0x02)
                {
                    ogg.channels = stream.ReadByte();
                    extraLen    -= 1;
                }
                if (dataByte == 0x04)
                {
                    ogg.frequency = stream.ReadUInt32();
                    extraLen     -= 4;
                }
                if (dataByte == 0x06)
                {
                    ogg.loopStart = stream.ReadUInt32();
                    ogg.loopEnd   = stream.ReadUInt32();
                    extraLen     -= 8;
                }
                if (dataByte == 0x16)
                {
                    ogg.crc32 = stream.ReadUInt32();
                    extraLen -= 4;
                }
                stream.Position += extraLen;
            }

            long nextFilePos = stream.Position;

            long size = stream.ReadUInt32();
            if (size == 0)
            {
                size = dataSize + baseOffset;
            }
            else
            {
                size = ((size >> 7) * 0x20) + baseOffset;
            }
            if (size < 0 || size > data.Length)
            {
                size = data.Length;
            }
            long fileOffset = baseOffset + offset;
            size -= fileOffset;

            if (i == 0)
            {
                WriteFile(stream, file, (int)fileOffset, (int)size, ogg);
            }
            else
            {
                WriteFile(stream, file + i, (int)fileOffset, (int)size, ogg);
            }

            stream.Position = nextFilePos;
        }
        stream.Dispose(true);
    }
示例#7
0
        public Mesh(AssetPreloadData MeshPD)
        {
            //Stream = new EndianStream(File.OpenRead(sourceFile.filePath), sourceFile.endianType);
            //Stream.endian = sourceFile.endianType;
            var version = MeshPD.sourceFile.version;
            a_Stream = MeshPD.sourceFile.a_Stream;
            a_Stream.Position = MeshPD.Offset;

            bool m_Use16BitIndices = true; //3.5.0 and newer always uses 16bit indices
            uint m_MeshCompression = 0;

            if (MeshPD.sourceFile.platform == -2)
            {
                uint m_ObjectHideFlags = a_Stream.ReadUInt32();
                PPtr m_PrefabParentObject = MeshPD.sourceFile.ReadPPtr();
                PPtr m_PrefabInternal = MeshPD.sourceFile.ReadPPtr();
            }

            m_Name = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
            
            if (version[0] < 3 || (version[0] == 3 && version[1] < 5))
            {
                m_Use16BitIndices = a_Stream.ReadBoolean();
                a_Stream.Position += 3;
            }

            #region Index Buffer for 2.5.1 and earlier
            if (version[0] == 2 && version[1] <= 5)
            {
                int m_IndexBuffer_size = a_Stream.ReadInt32();

                if (m_Use16BitIndices)
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 2];
                    for (int i = 0; i < m_IndexBuffer_size / 2; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt16(); }
                    a_Stream.AlignStream(4);
                }
                else
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 4];
                    for (int i = 0; i < m_IndexBuffer_size / 4; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt32(); }
                }
            }
            #endregion

            #region subMeshes
            int m_SubMeshes_size = a_Stream.ReadInt32();
            for (int s = 0; s < m_SubMeshes_size; s++)
            {
                m_SubMeshes.Add(new SubMesh());
                m_SubMeshes[s].firstByte = a_Stream.ReadUInt32();
                m_SubMeshes[s].indexCount = a_Stream.ReadUInt32(); //what is this in case of triangle strips?
                m_SubMeshes[s].topology = a_Stream.ReadInt32(); //isTriStrip
                if (version[0] < 4)
                {
                    m_SubMeshes[s].triangleCount = a_Stream.ReadUInt32();
                }
                if (version[0] >= 3)
                {
                    m_SubMeshes[s].firstVertex = a_Stream.ReadUInt32();
                    m_SubMeshes[s].vertexCount = a_Stream.ReadUInt32();
                    a_Stream.Position += 24; //Axis-Aligned Bounding Box
                }
            }
            #endregion
            
            #region BlendShapeData for 4.1.0 to 4.2.x, excluding 4.1.0 alpha
            if (version[0] == 4 && ((version[1] == 1 && MeshPD.sourceFile.buildType[0] != "a") || 
                                    (version[1] > 1 && version[1] <= 2)))
            {
                int m_Shapes_size = a_Stream.ReadInt32();
                if (m_Shapes_size > 0)
                {
                    bool stop = true;
                }
                for (int s = 0; s < m_Shapes_size; s++) //untested
                {
                    string shape_name = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
                    a_Stream.Position += 36; //uint firstVertex, vertexCount; Vector3f aabbMinDelta, aabbMaxDelta; bool hasNormals, hasTangents
                }

                int m_ShapeVertices_size = a_Stream.ReadInt32();
                a_Stream.Position += m_ShapeVertices_size * 40; //vertex positions, normals, tangents & uint index
            }
            #endregion
            #region BlendShapeData and BindPose for 4.3.0 and later
            else if (version[0] >= 5 || (version[0] == 4 && version[1] >= 3))
            {
                int m_ShapeVertices_size = a_Stream.ReadInt32();
                if (m_ShapeVertices_size > 0)
                {
                    bool stop = true;
                }
                a_Stream.Position += m_ShapeVertices_size * 40; //vertex positions, normals, tangents & uint index

                int shapes_size = a_Stream.ReadInt32();
                a_Stream.Position += shapes_size * 12; //uint firstVertex, vertexCount; bool hasNormals, hasTangents

                int channels_size = a_Stream.ReadInt32();
                for (int c = 0; c < channels_size; c++)
                {
                    string channel_name = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
                    a_Stream.Position += 12; //uint nameHash; int frameIndex, frameCount
                }

                int fullWeights_size = a_Stream.ReadInt32();
                a_Stream.Position += fullWeights_size * 4; //floats

                m_BindPose = new float[a_Stream.ReadInt32()][,];
                for (int i = 0; i < m_BindPose.Length; i++)
                {
                    m_BindPose[i] = new float[4,4] {
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() } };
                }

                int m_BoneNameHashes_size = a_Stream.ReadInt32();
                a_Stream.Position += m_BoneNameHashes_size * 4; //uints

                uint m_RootBoneNameHash = a_Stream.ReadUInt32();
            }
            #endregion

            #region Index Buffer for 2.6.0 and later
            if (version[0] >= 3 || (version[0] == 2 && version[1] >= 6))
            {
                m_MeshCompression = a_Stream.ReadByte();
                if (version[0] >= 4)
                {
                    if (version[0] < 5) { uint m_StreamCompression = a_Stream.ReadByte(); }
                    bool m_IsReadable = a_Stream.ReadBoolean();
                    bool m_KeepVertices = a_Stream.ReadBoolean();
                    bool m_KeepIndices = a_Stream.ReadBoolean();
                }
                a_Stream.AlignStream(4);

                int m_IndexBuffer_size = a_Stream.ReadInt32();

                if (m_Use16BitIndices)
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 2];
                    for (int i = 0; i < m_IndexBuffer_size / 2; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt16(); }
                    a_Stream.AlignStream(4);
                }
                else
                {
                    m_IndexBuffer = new uint[m_IndexBuffer_size / 4];
                    for (int i = 0; i < m_IndexBuffer_size / 4; i++) { m_IndexBuffer[i] = a_Stream.ReadUInt32(); }
                    a_Stream.AlignStream(4);//untested
                }
            }
            #endregion

            #region Vertex Buffer for 3.4.2 and earlier
            if (version[0] < 3 || (version[0] == 3 && version[1] < 5))
            {
                m_VertexCount = a_Stream.ReadInt32();
                m_Vertices = new float[m_VertexCount * 3];
                for (int v = 0; v < m_VertexCount * 3; v++) { m_Vertices[v] = a_Stream.ReadSingle(); }

                m_Skin = new List<BoneInfluence>[a_Stream.ReadInt32()];
                //m_Skin = new Dictionary<int, float>[a_Stream.ReadInt32()];
                for (int s = 0; s < m_Skin.Length; s++)
                {
                    m_Skin[s] = new List<BoneInfluence>();
                    for (int i = 0; i < 4; i++) { m_Skin[s].Add(new BoneInfluence() { weight = a_Stream.ReadSingle() }); }
                    for (int i = 0; i < 4; i++) { m_Skin[s][i].boneIndex = a_Stream.ReadInt32(); }

                    /*m_Skin[s] = new Dictionary<int, float>();
                    float[] weights = new float[4] { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() };
                    for (int i = 0; i < 4; i++)
                    {
                        int boneIndex = a_Stream.ReadInt32();
                        m_Skin[s][boneIndex] = weights[i];
                    }*/
                }

                m_BindPose = new float[a_Stream.ReadInt32()][,];
                for (int i = 0; i < m_BindPose.Length; i++)
                {
                    m_BindPose[i] = new float[4, 4] {
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() } };
                }

                int m_UV1_size = a_Stream.ReadInt32();
                m_UV1 = new float[m_UV1_size * 2];
                for (int v = 0; v < m_UV1_size * 2; v++) { m_UV1[v] = a_Stream.ReadSingle(); }

                int m_UV2_size = a_Stream.ReadInt32();
                m_UV2 = new float[m_UV2_size * 2];
                for (int v = 0; v < m_UV2_size * 2; v++) { m_UV2[v] = a_Stream.ReadSingle(); }

                if (version[0] == 2 && version[1] <= 5)
                {
                    int m_TangentSpace_size = a_Stream.ReadInt32();
                    m_Normals = new float[m_TangentSpace_size * 3];
                    for (int v = 0; v < m_TangentSpace_size; v++)
                    {
                        m_Normals[v * 3] = a_Stream.ReadSingle();
                        m_Normals[v * 3 + 1] = a_Stream.ReadSingle();
                        m_Normals[v * 3 + 2] = a_Stream.ReadSingle();
                        a_Stream.Position += 16; //Vector3f tangent & float handedness 
                    }
                }
                else //2.6.0 and later
                {
                    int m_Tangents_size = a_Stream.ReadInt32();
                    a_Stream.Position += m_Tangents_size * 16; //Vector4f

                    int m_Normals_size = a_Stream.ReadInt32();
                    m_Normals = new float[m_Normals_size * 3];
                    for (int v = 0; v < m_Normals_size * 3; v++) { m_Normals[v] = a_Stream.ReadSingle(); }
                }
            }
            #endregion
            #region Vertex Buffer for 3.5.0 and later
            else
            {
                #region read vertex stream
                m_Skin = new List<BoneInfluence>[a_Stream.ReadInt32()];
                //m_Skin = new Dictionary<int, float>[a_Stream.ReadInt32()];
                for (int s = 0; s < m_Skin.Length; s++)
                {
                    m_Skin[s] = new List<BoneInfluence>();
                    for (int i = 0; i < 4; i++) { m_Skin[s].Add(new BoneInfluence() { weight = a_Stream.ReadSingle() }); }
                    for (int i = 0; i < 4; i++) { m_Skin[s][i].boneIndex = a_Stream.ReadInt32(); }

                    /*m_Skin[s] = new Dictionary<int, float>();
                    float[] weights = new float[4] { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() };
                    for (int i = 0; i < 4; i++)
                    {
                        int boneIndex = a_Stream.ReadInt32();
                        m_Skin[s][boneIndex] = weights[i];
                    }*/
                }


                if (version[0] == 3 || (version[0] == 4 && version[1] <= 2))
                {
                    m_BindPose = new float[a_Stream.ReadInt32()][,];
                    for (int i = 0; i < m_BindPose.Length; i++)
                    {
                        m_BindPose[i] = new float[4, 4] {
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() },
                        { a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle(), a_Stream.ReadSingle() } };
                    }
                }

                BitArray m_CurrentChannels = new BitArray(new int[1] { a_Stream.ReadInt32() });
                m_VertexCount = a_Stream.ReadInt32();
                //int singleStreamStride = 0;//used tor unity 5
                int streamCount = 0;

                #region streams for 3.5.0 - 3.5.7
                if (version[0] < 4)
                {
                    if (m_MeshCompression != 0 && version[2] == 0) //special case not just on platform 9
                    {
                        a_Stream.Position += 12;
                    }
                    else
                    {
                        m_Streams = new StreamInfo[4];
                        for (int s = 0; s < 4; s++)
                        {
                            m_Streams[s] = new StreamInfo();
                            m_Streams[s].channelMask = new BitArray(new int[1] { a_Stream.ReadInt32() });
                            m_Streams[s].offset = a_Stream.ReadInt32();
                            m_Streams[s].stride = a_Stream.ReadInt32();
                            m_Streams[s].align = a_Stream.ReadUInt32();
                        }
                    }
                }
                #endregion
                #region channels and streams for 4.0.0 and later
                else
                {
                    m_Channels = new ChannelInfo[a_Stream.ReadInt32()];
                    for (int c = 0; c < m_Channels.Length; c++)
                    {
                        m_Channels[c] = new ChannelInfo();
                        m_Channels[c].stream = a_Stream.ReadByte();
                        m_Channels[c].offset = a_Stream.ReadByte();
                        m_Channels[c].format = a_Stream.ReadByte();
                        m_Channels[c].dimension = a_Stream.ReadByte();

                        //calculate stride for Unity 5
                        //singleStreamStride += m_Channels[c].dimension * (4 / (int)Math.Pow(2, m_Channels[c].format));

                        if (m_Channels[c].stream >= streamCount) { streamCount = m_Channels[c].stream + 1; }
                    }

                    if (version[0] < 5)
                    {
                        m_Streams = new StreamInfo[a_Stream.ReadInt32()];
                        for (int s = 0; s < m_Streams.Length; s++)
                        {
                            m_Streams[s] = new StreamInfo();
                            m_Streams[s].channelMask = new BitArray(new int[1] { a_Stream.ReadInt32() });
                            m_Streams[s].offset = a_Stream.ReadInt32();
                            m_Streams[s].stride = a_Stream.ReadByte();
                            m_Streams[s].dividerOp = a_Stream.ReadByte();
                            m_Streams[s].frequency = a_Stream.ReadUInt16();
                        }
                    }
                }
                #endregion

                //actual Vertex Buffer
                byte[] m_DataSize = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_DataSize, 0, m_DataSize.Length);

                if (version[0] >= 5) //create streams
                {
                    m_Streams = new StreamInfo[streamCount];
                    for (int s = 0; s < streamCount; s++)
                    {
                        m_Streams[s] = new StreamInfo();
                        m_Streams[s].channelMask = new BitArray(new int[1] { 0 });
                        m_Streams[s].offset = 0;
                        m_Streams[s].stride = 0;

                        foreach (var m_Channel in m_Channels)
                        {
                            if (m_Channel.stream == s) { m_Streams[s].stride += m_Channel.dimension * (4 / (int)Math.Pow(2, m_Channel.format)); }
                        }

                        if (s > 0)
                        {
                            m_Streams[s].offset = m_Streams[s - 1].offset + m_Streams[s - 1].stride * m_VertexCount;
                            //sometimes there are 8 bytes between streams
                            //this is NOT an alignment, even if sometimes it may seem so

                            if (streamCount == 2) { m_Streams[s].offset = m_DataSize.Length - m_Streams[s].stride * m_VertexCount; }
                            else
                            {
                                m_VertexCount = 0;
                                return;
                            }

                            /*var absoluteOffset = a_Stream.Position + 4 + m_Streams[s].offset;
                            if ((absoluteOffset % m_Streams[s].stride) != 0)
                            {
                                m_Streams[s].offset += m_Streams[s].stride - (int)(absoluteOffset % m_Streams[s].stride);
                            }*/
                        }
                    }
                }
                #endregion

                #region compute FvF
                int componentByteSize = 0;
                byte[] componentBytes;
                float[] componentsArray;

                #region 4.0.0 and later
                if (m_Channels != null)
                {
                    //it is better to loop channels instead of streams
                    //because channels are likely to be sorted by vertex property
                    foreach (var m_Channel in m_Channels)
                    {
                        if (m_Channel.dimension > 0)
                        {
                            var m_Stream = m_Streams[m_Channel.stream];

                            for (int b = 0; b < 8; b++)
                            {
                                //in the future, try to use only m_CurrentChannels
                                if ((version[0] < 5 && m_Stream.channelMask.Get(b)) || (version[0] >= 5 && m_CurrentChannels.Get(b)))
                                {
                                    // in Unity 4.x the colors channel has 1 dimension, as in 1 color with 4 components
                                    if (b == 2 && m_Channel.format == 2) { m_Channel.dimension = 4; }

                                    componentByteSize = 4 / (int)Math.Pow(2, m_Channel.format);

                                    /*switch (m_Channel.format)
                                    {
                                        case 0: //32bit
                                            valueBufferSize = 4;
                                            break;
                                        case 1: //16bit
                                            valueBufferSize = 2;
                                            break;
                                        case 2: //8bit
                                            valueBufferSize = 1;
                                            m_Channel.dimension = 4;//in older versions this is 1, as in 1 color with 4 components
                                            break;
                                    }*/

                                    componentBytes = new byte[componentByteSize];
                                    componentsArray = new float[m_VertexCount * m_Channel.dimension];

                                    for (int v = 0; v < m_VertexCount; v++)
                                    {
                                        int vertexOffset = m_Stream.offset + m_Channel.offset + m_Stream.stride * v;
                                        for (int d = 0; d < m_Channel.dimension; d++)
                                        {
                                            int componentOffset = vertexOffset + componentByteSize * d;
                                            Buffer.BlockCopy(m_DataSize, componentOffset, componentBytes, 0, componentByteSize);
                                            componentsArray[v * m_Channel.dimension + d] = bytesToFloat(componentBytes);
                                        }
                                    }

                                    switch (b)
                                    {
                                        case 0: m_Vertices = componentsArray; break;
                                        case 1: m_Normals = componentsArray; break;
                                        case 2: m_Colors = componentsArray; break;
                                        case 3: m_UV1 = componentsArray; break;
                                        case 4: m_UV2 = componentsArray; break;
                                        case 5:
                                            if (version[0] == 5) { m_UV3 = componentsArray; }
                                            else { m_Tangents = componentsArray; }
                                            break;
                                        case 6: m_UV4 = componentsArray; break;
                                        case 7: m_Tangents = componentsArray; break;
                                    }

                                    m_Stream.channelMask.Set(b, false);
                                    m_CurrentChannels.Set(b, false);
                                    componentBytes = null;
                                    componentsArray = null;
                                    break; //go to next channel
                                }
                            }
                        }
                    }
                }
                #endregion
                #region 3.5.0 - 3.5.7
                else if (m_Streams != null)
                {
                    foreach (var m_Stream in m_Streams)
                    {
                        //a stream may have multiple vertex components but without channels there are no offsets, so I assume all vertex properties are in order
                        //Unity 3.5.x only uses floats, and that's probably why channels were introduced in Unity 4

                        ChannelInfo m_Channel = new ChannelInfo();//create my own channel so I can use the same methods
                        m_Channel.offset = 0;

                        for (int b = 0; b < 6; b++)
                        {
                            if (m_Stream.channelMask.Get(b))
                            {
                                switch (b)
                                {
                                    case 0:
                                    case 1:
                                        componentByteSize = 4;
                                        m_Channel.dimension = 3;
                                        break;
                                    case 2:
                                        componentByteSize = 1;
                                        m_Channel.dimension = 4;
                                        break;
                                    case 3:
                                    case 4:
                                        componentByteSize = 4;
                                        m_Channel.dimension = 2;
                                        break;
                                    case 5:
                                        componentByteSize = 4;
                                        m_Channel.dimension = 4;
                                        break;
                                }

                                componentBytes = new byte[componentByteSize];
                                componentsArray = new float[m_VertexCount * m_Channel.dimension];

                                for (int v = 0; v < m_VertexCount; v++)
                                {
                                    int vertexOffset = m_Stream.offset + m_Channel.offset + m_Stream.stride * v;
                                    for (int d = 0; d < m_Channel.dimension; d++)
                                    {
                                        int m_DataSizeOffset = vertexOffset + componentByteSize * d;
                                        Buffer.BlockCopy(m_DataSize, m_DataSizeOffset, componentBytes, 0, componentByteSize);
                                        componentsArray[v * m_Channel.dimension + d] = bytesToFloat(componentBytes);
                                    }
                                }

                                switch (b)
                                {
                                    case 0: m_Vertices = componentsArray; break;
                                    case 1: m_Normals = componentsArray; break;
                                    case 2: m_Colors = componentsArray; break;
                                    case 3: m_UV1 = componentsArray; break;
                                    case 4: m_UV2 = componentsArray; break;
                                    case 5: m_Tangents = componentsArray; break;
                                }

                                m_Channel.offset += (byte)(m_Channel.dimension * componentByteSize); //safe to cast as byte because strides larger than 255 are unlikely
                                m_Stream.channelMask.Set(b, false);
                                componentBytes = null;
                                componentsArray = null;
                            }
                        }
                    }
                }
                #endregion
                #endregion
            }
            #endregion

            #region Compressed Mesh data for 2.6.0 and later - 160 bytes
            if (version[0] >= 3 || (version[0] == 2 && version[1] >= 6))
            {
                //remember there can be combinations of packed and regular vertex properties

                #region m_Vertices
                PackedBitVector m_Vertices_Packed = new PackedBitVector();
                m_Vertices_Packed.m_NumItems = a_Stream.ReadInt32();
                m_Vertices_Packed.m_Range = a_Stream.ReadSingle();
                m_Vertices_Packed.m_Start = a_Stream.ReadSingle();
                m_Vertices_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Vertices_Packed.m_Data, 0, m_Vertices_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Vertices_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_Vertices_Packed.m_NumItems > 0)
                {
                    m_VertexCount = m_Vertices_Packed.m_NumItems / 3;
                    uint[] m_Vertices_Unpacked = UnpackBitVector(m_Vertices_Packed);
                    int bitmax = 0;//used to convert int value to float
                    for (int b = 0; b < m_Vertices_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                    m_Vertices = new float[m_Vertices_Packed.m_NumItems];
                    for (int v = 0; v < m_Vertices_Packed.m_NumItems; v++)
                    {
                        m_Vertices[v] = (float)((double)m_Vertices_Unpacked[v] / bitmax) * m_Vertices_Packed.m_Range + m_Vertices_Packed.m_Start;
                    }
                }
                #endregion

                #region m_UV
                PackedBitVector m_UV_Packed = new PackedBitVector(); //contains all channels
                m_UV_Packed.m_NumItems = a_Stream.ReadInt32();
                m_UV_Packed.m_Range = a_Stream.ReadSingle();
                m_UV_Packed.m_Start = a_Stream.ReadSingle();
                m_UV_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_UV_Packed.m_Data, 0, m_UV_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_UV_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_UV_Packed.m_NumItems > 0 && (bool)Properties.Settings.Default["exportUVs"])
                {
                    uint[] m_UV_Unpacked = UnpackBitVector(m_UV_Packed);
                    int bitmax = 0;
                    for (int b = 0; b < m_UV_Packed.m_BitSize; b++) { bitmax |= (1 << b); }

                    m_UV1 = new float[m_VertexCount * 2];
                    
                    for (int v = 0; v < m_VertexCount * 2; v++)
                    {
                        m_UV1[v] = (float)((double)m_UV_Unpacked[v] / bitmax) * m_UV_Packed.m_Range + m_UV_Packed.m_Start;
                    }

                    if (m_UV_Packed.m_NumItems >= m_VertexCount * 4)
                    {
                        m_UV2 = new float[m_VertexCount * 2];
                        for (uint v = 0; v < m_VertexCount * 2; v++)
                        {
                            m_UV2[v] = (float)((double)m_UV_Unpacked[v + m_VertexCount * 2] / bitmax) * m_UV_Packed.m_Range + m_UV_Packed.m_Start;
                        }

                        if (m_UV_Packed.m_NumItems >= m_VertexCount * 6)
                        {
                            m_UV3 = new float[m_VertexCount * 2];
                            for (uint v = 0; v < m_VertexCount * 2; v++)
                            {
                                m_UV3[v] = (float)((double)m_UV_Unpacked[v + m_VertexCount * 4] / bitmax) * m_UV_Packed.m_Range + m_UV_Packed.m_Start;
                            }

                            if (m_UV_Packed.m_NumItems == m_VertexCount * 8)
                            {
                                m_UV4 = new float[m_VertexCount * 2];
                                for (uint v = 0; v < m_VertexCount * 2; v++)
                                {
                                    m_UV4[v] = (float)((double)m_UV_Unpacked[v + m_VertexCount * 6] / bitmax) * m_UV_Packed.m_Range + m_UV_Packed.m_Start;
                                }
                            }
                        }
                    }
                }
                #endregion

                #region m_BindPose
                if (version[0] < 5)
                {
                    PackedBitVector m_BindPoses_Packed = new PackedBitVector();
                    m_BindPoses_Packed.m_NumItems = a_Stream.ReadInt32();
                    m_BindPoses_Packed.m_Range = a_Stream.ReadSingle();
                    m_BindPoses_Packed.m_Start = a_Stream.ReadSingle();
                    m_BindPoses_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                    a_Stream.Read(m_BindPoses_Packed.m_Data, 0, m_BindPoses_Packed.m_Data.Length);
                    a_Stream.AlignStream(4);
                    m_BindPoses_Packed.m_BitSize = a_Stream.ReadByte();
                    a_Stream.Position += 3; //4 byte alignment

                    if (m_BindPoses_Packed.m_NumItems > 0 && (bool)Properties.Settings.Default["exportDeformers"])
                    {
                        uint[] m_BindPoses_Unpacked = UnpackBitVector(m_BindPoses_Packed);
                        int bitmax = 0;//used to convert int value to float
                        for (int b = 0; b < m_BindPoses_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                        
                        m_BindPose = new float[m_BindPoses_Packed.m_NumItems / 16][,];

                        for (int i = 0; i < m_BindPose.Length; i++)
                        {
                            m_BindPose[i] = new float[4, 4];
                            for (int j = 0; j < 4; j++)
                            {
                                for (int k = 0; k < 4; k++)
                                {
                                    m_BindPose[i][j,k] = (float)((double)m_BindPoses_Unpacked[i * 16 + j * 4 + k] / bitmax) * m_BindPoses_Packed.m_Range + m_BindPoses_Packed.m_Start;
                                }
                            }
                        }
                    }
                }
                #endregion

                PackedBitVector m_Normals_Packed = new PackedBitVector();
                m_Normals_Packed.m_NumItems = a_Stream.ReadInt32();
                m_Normals_Packed.m_Range = a_Stream.ReadSingle();
                m_Normals_Packed.m_Start = a_Stream.ReadSingle();
                m_Normals_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Normals_Packed.m_Data, 0, m_Normals_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Normals_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                PackedBitVector m_Tangents_Packed = new PackedBitVector();
                m_Tangents_Packed.m_NumItems = a_Stream.ReadInt32();
                m_Tangents_Packed.m_Range = a_Stream.ReadSingle();
                m_Tangents_Packed.m_Start = a_Stream.ReadSingle();
                m_Tangents_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Tangents_Packed.m_Data, 0, m_Tangents_Packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Tangents_Packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                PackedBitVector m_Weights = new PackedBitVector();
                m_Weights.m_NumItems = a_Stream.ReadInt32();
                m_Weights.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Weights.m_Data, 0, m_Weights.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Weights.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                #region m_Normals
                PackedBitVector m_NormalSigns_packed = new PackedBitVector();
                m_NormalSigns_packed.m_NumItems = a_Stream.ReadInt32();
                m_NormalSigns_packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_NormalSigns_packed.m_Data, 0, m_NormalSigns_packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_NormalSigns_packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_Normals_Packed.m_NumItems > 0 && (bool)Properties.Settings.Default["exportNormals"])
                {
                    uint[] m_Normals_Unpacked = UnpackBitVector(m_Normals_Packed);
                    uint[] m_NormalSigns = UnpackBitVector(m_NormalSigns_packed);
                    int bitmax = 0;
                    for (int b = 0; b < m_Normals_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                    m_Normals = new float[m_Normals_Packed.m_NumItems / 2 * 3];
                    for (int v = 0; v < m_Normals_Packed.m_NumItems / 2; v++)
                    {
                        m_Normals[v * 3] = (float)((double)m_Normals_Unpacked[v * 2] / bitmax) * m_Normals_Packed.m_Range + m_Normals_Packed.m_Start;
                        m_Normals[v * 3 + 1] = (float)((double)m_Normals_Unpacked[v * 2 + 1] / bitmax) * m_Normals_Packed.m_Range + m_Normals_Packed.m_Start;
                        m_Normals[v * 3 + 2] = (float)Math.Sqrt(1 - m_Normals[v * 3] * m_Normals[v * 3] - m_Normals[v * 3 + 1] * m_Normals[v * 3 + 1]);
                        if (m_NormalSigns[v] == 0) { m_Normals[v * 3 + 2] *= -1; }
                    }
                }
                #endregion

                #region m_Tangents
                PackedBitVector m_TangentSigns_packed = new PackedBitVector();
                m_TangentSigns_packed.m_NumItems = a_Stream.ReadInt32();
                m_TangentSigns_packed.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_TangentSigns_packed.m_Data, 0, m_TangentSigns_packed.m_Data.Length);
                a_Stream.AlignStream(4);
                m_TangentSigns_packed.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment
                
                if (m_Tangents_Packed.m_NumItems > 0 && (bool)Properties.Settings.Default["exportTangents"])
                {
                    uint[] m_Tangents_Unpacked = UnpackBitVector(m_Tangents_Packed);
                    uint[] m_TangentSigns = UnpackBitVector(m_TangentSigns_packed);
                    int bitmax = 0;
                    for (int b = 0; b < m_Tangents_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                    m_Tangents = new float[m_Tangents_Packed.m_NumItems / 2 * 3];
                    for (int v = 0; v < m_Tangents_Packed.m_NumItems / 2; v++)
                    {
                        m_Tangents[v * 3] = (float)((double)m_Tangents_Unpacked[v * 2] / bitmax) * m_Tangents_Packed.m_Range + m_Tangents_Packed.m_Start;
                        m_Tangents[v * 3 + 1] = (float)((double)m_Tangents_Unpacked[v * 2 + 1] / bitmax) * m_Tangents_Packed.m_Range + m_Tangents_Packed.m_Start;
                        m_Tangents[v * 3 + 2] = (float)Math.Sqrt(1 - m_Tangents[v * 3] * m_Tangents[v * 3] - m_Tangents[v * 3 + 1] * m_Tangents[v * 3 + 1]);
                        if (m_TangentSigns[v] == 0) { m_Tangents[v * 3 + 2] *= -1; }
                    }
                }
                #endregion

                #region m_FloatColors
                if (version[0] >= 5)
                {
                    PackedBitVector m_FloatColors = new PackedBitVector();
                    m_FloatColors.m_NumItems = a_Stream.ReadInt32();
                    m_FloatColors.m_Range = a_Stream.ReadSingle();
                    m_FloatColors.m_Start = a_Stream.ReadSingle();
                    m_FloatColors.m_Data = new byte[a_Stream.ReadInt32()];
                    a_Stream.Read(m_FloatColors.m_Data, 0, m_FloatColors.m_Data.Length);
                    a_Stream.AlignStream(4);
                    m_FloatColors.m_BitSize = a_Stream.ReadByte();
                    a_Stream.Position += 3; //4 byte alignment

                    if (m_FloatColors.m_NumItems > 0 && (bool)Properties.Settings.Default["exportColors"])
                    {
                        uint[] m_FloatColors_Unpacked = UnpackBitVector(m_FloatColors);
                        int bitmax = 0;
                        for (int b = 0; b < m_FloatColors.m_BitSize; b++) { bitmax |= (1 << b); }

                        m_Colors = new float[m_FloatColors.m_NumItems];

                        for (int v = 0; v < m_FloatColors.m_NumItems; v++)
                        {
                            m_Colors[v] = (float)m_FloatColors_Unpacked[v] / bitmax * m_FloatColors.m_Range + m_FloatColors.m_Start;
                        }
                    }
                }
                #endregion

                #region m_Skin
                PackedBitVector m_BoneIndices = new PackedBitVector();
                m_BoneIndices.m_NumItems = a_Stream.ReadInt32();
                m_BoneIndices.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_BoneIndices.m_Data, 0, m_BoneIndices.m_Data.Length);
                a_Stream.AlignStream(4);
                m_BoneIndices.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                //how the hell does this work??
                if (m_BoneIndices.m_NumItems > 0 && m_BoneIndices.m_NumItems == m_Weights.m_NumItems && (bool)Properties.Settings.Default["exportDeformers"])
                {
                    uint[] m_Weights_Unpacked = UnpackBitVector(m_Weights);
                    int bitmax = 0;
                    for (int b = 0; b < m_Weights.m_BitSize; b++) { bitmax |= (1 << b); }

                    uint[] m_BoneIndices_Unpacked = UnpackBitVector(m_BoneIndices);

                    m_Skin = new List<BoneInfluence>[m_BoneIndices.m_NumItems / 4];
                    for (int s = 0; s < m_Skin.Length; s++)
                    {
                        m_Skin[s] = new List<BoneInfluence>();
                        for (int i = 0; i < 4; i++)
                        {
                            m_Skin[s].Add(new BoneInfluence() { weight = (float)((double)m_Weights_Unpacked[s * 4 + i] / bitmax),
                                                                boneIndex = (int)m_BoneIndices_Unpacked[s * 4 + i] });
                        }
                    }
                }
                #endregion

                PackedBitVector m_Triangles = new PackedBitVector();
                m_Triangles.m_NumItems = a_Stream.ReadInt32();
                m_Triangles.m_Data = new byte[a_Stream.ReadInt32()];
                a_Stream.Read(m_Triangles.m_Data, 0, m_Triangles.m_Data.Length);
                a_Stream.AlignStream(4);
                m_Triangles.m_BitSize = a_Stream.ReadByte();
                a_Stream.Position += 3; //4 byte alignment

                if (m_Triangles.m_NumItems > 0) { m_IndexBuffer = UnpackBitVector(m_Triangles); }
            }
            #endregion

            #region Colors & Collision triangles for 3.4.2 and earlier
            if (version[0] <= 2 || (version[0] == 3 && version[1] <= 4)) //
            {
                a_Stream.Position += 24; //Axis-Aligned Bounding Box
                int m_Colors_size = a_Stream.ReadInt32();
                m_Colors = new float[m_Colors_size * 4];
                for (int v = 0; v < m_Colors_size * 4; v++) { m_Colors[v] = (float)(a_Stream.ReadByte()) / 0xFF; }

                int m_CollisionTriangles_size = a_Stream.ReadInt32();
                a_Stream.Position += m_CollisionTriangles_size * 4; //UInt32 indices
                int m_CollisionVertexCount = a_Stream.ReadInt32();
            }
            #endregion
            #region Compressed colors & Local AABB for 3.5.0 to 4.x.x
            else //vertex colors are either in streams or packed bits
            {
                if (version[0] < 5)
                {
                    PackedBitVector m_Colors_Packed = new PackedBitVector();
                    m_Colors_Packed.m_NumItems = a_Stream.ReadInt32();
                    m_Colors_Packed.m_Data = new byte[a_Stream.ReadInt32()];
                    a_Stream.Read(m_Colors_Packed.m_Data, 0, m_Colors_Packed.m_Data.Length);
                    a_Stream.AlignStream(4);
                    m_Colors_Packed.m_BitSize = a_Stream.ReadByte();
                    a_Stream.Position += 3; //4 byte alignment

                    if (m_Colors_Packed.m_NumItems > 0)
                    {
                        if (m_Colors_Packed.m_BitSize == 32)
                        {
                            //4 x 8bit color channels
                            m_Colors = new float[m_Colors_Packed.m_Data.Length];
                            for (int v = 0; v < m_Colors_Packed.m_Data.Length; v++)
                            {
                                m_Colors[v] = (float)m_Colors_Packed.m_Data[v] / 0xFF;
                            }
                        }
                        else //not tested
                        {
                            uint[] m_Colors_Unpacked = UnpackBitVector(m_Colors_Packed);
                            int bitmax = 0;//used to convert int value to float
                            for (int b = 0; b < m_Colors_Packed.m_BitSize; b++) { bitmax |= (1 << b); }
                            m_Colors = new float[m_Colors_Packed.m_NumItems];
                            for (int v = 0; v < m_Colors_Packed.m_NumItems; v++)
                            {
                                m_Colors[v] = (float)m_Colors_Unpacked[v] / bitmax;
                            }
                        }
                    }
                }
                else { uint m_UVInfo = a_Stream.ReadUInt32(); }

                a_Stream.Position += 24; //Axis-Aligned Bounding Box
            }
            #endregion

            int m_MeshUsageFlags = a_Stream.ReadInt32();

            if (version[0] >= 5)
            {
                //int m_BakedConvexCollisionMesh = a_Stream.ReadInt32();
                //a_Stream.Position += m_BakedConvexCollisionMesh;
                //int m_BakedTriangleCollisionMesh = a_Stream.ReadInt32();
                //a_Stream.Position += m_BakedConvexCollisionMesh;
            }

            #region Build face indices
            for (int s = 0; s < m_SubMeshes_size; s++)
            {
                uint firstIndex = m_SubMeshes[s].firstByte / 2;
                if (!m_Use16BitIndices) { firstIndex /= 2; }

                if (m_SubMeshes[s].topology == 0)
                {
                    for (int i = 0; i < m_SubMeshes[s].indexCount / 3; i++)
                    {
                        m_Indices.Add(m_IndexBuffer[firstIndex + i * 3]);
                        m_Indices.Add(m_IndexBuffer[firstIndex + i * 3 + 1]);
                        m_Indices.Add(m_IndexBuffer[firstIndex + i * 3 + 2]);
                        m_materialIDs.Add(s);
                    }
                }
                else
                {
                    for (int i = 0; i < m_SubMeshes[s].indexCount - 2; i++)
                    {
                        uint fa = m_IndexBuffer[firstIndex + i];
                        uint fb = m_IndexBuffer[firstIndex + i + 1];
                        uint fc = m_IndexBuffer[firstIndex + i + 2];

                        if ((fa!=fb) && (fa!=fc) && (fc!=fb))
                        {
                            m_Indices.Add(fa);
                            if ((i % 2) == 0)
                            {
                                m_Indices.Add(fb);
                                m_Indices.Add(fc);
                            }
                            else
                            {
                                m_Indices.Add(fc);
                                m_Indices.Add(fb);
                            }
                            m_materialIDs.Add(s);
                        }
                    }
                }
            }
            #endregion
        }
示例#8
0
 private static void Read(StringBuilder sb, List <ClassMember> members, EndianStream a_Stream)
 {
     for (int i = 0; i < members.Count; i++)
     {
         var    member     = members[i];
         var    level      = member.Level;
         var    varTypeStr = member.Type;
         var    varNameStr = member.Name;
         object value      = null;
         var    align      = (member.Flag & 0x4000) != 0;
         var    append     = true;
         if (varTypeStr == "SInt8")//sbyte
         {
             value = a_Stream.ReadSByte();
         }
         else if (varTypeStr == "UInt8")//byte
         {
             value = a_Stream.ReadByte();
         }
         else if (varTypeStr == "short" || varTypeStr == "SInt16")//Int16
         {
             value = a_Stream.ReadInt16();
         }
         else if (varTypeStr == "UInt16" || varTypeStr == "unsigned short")//UInt16
         {
             value = a_Stream.ReadUInt16();
         }
         else if (varTypeStr == "int" || varTypeStr == "SInt32")//Int32
         {
             value = a_Stream.ReadInt32();
         }
         else if (varTypeStr == "UInt32" || varTypeStr == "unsigned int")//UInt32
         {
             value = a_Stream.ReadUInt32();
         }
         else if (varTypeStr == "long long" || varTypeStr == "SInt64")//Int64
         {
             value = a_Stream.ReadInt64();
         }
         else if (varTypeStr == "UInt64" || varTypeStr == "unsigned long long")//UInt64
         {
             value = a_Stream.ReadUInt64();
         }
         else if (varTypeStr == "float")//float
         {
             value = a_Stream.ReadSingle();
         }
         else if (varTypeStr == "double")//double
         {
             value = a_Stream.ReadDouble();
         }
         else if (varTypeStr == "bool")//bool
         {
             value = a_Stream.ReadBoolean();
         }
         else if (varTypeStr == "string")//string
         {
             append = false;
             var str = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
             sb.AppendFormat("{0}{1} {2} = \"{3}\"\r\n", (new string('\t', level)), varTypeStr, varNameStr, str);
             i += 3;                     //skip
         }
         else if (varTypeStr == "Array") //Array
         {
             append = false;
             if ((members[i - 1].Flag & 0x4000) != 0)
             {
                 align = true;
             }
             sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
             var size = a_Stream.ReadInt32();
             sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
             var array = ReadArray(members, level, i);
             for (int j = 0; j < size; j++)
             {
                 sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 1)), j);
                 Read(sb, array, a_Stream);
             }
             i += array.Count + 1;//skip
         }
         else
         {
             append = false;
             align  = false;
             sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
         }
         if (append)
         {
             sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), varTypeStr, varNameStr, value);
         }
         if (align)
         {
             a_Stream.AlignStream(4);
         }
     }
 }