preparation work

AssetStudio/Classes/AnimationClip.cs

@@ -772,10 +772,17 @@ namespace AssetStudio
         }
     }
 
+    public enum AnimationType
+    {
+        kLegacy = 1,
+        kGeneric = 2,
+        kHumanoid = 3
+    };
+
     public class AnimationClip
     {
         public string m_Name { get; set; }
-        public int m_AnimationType { get; set; }
+        public AnimationType m_AnimationType { get; set; }
         public bool m_Legacy { get; set; }
         public bool m_Compressed { get; set; }
         public bool m_UseHighQualityCurve { get; set; }
@@ -809,8 +816,8 @@ namespace AssetStudio
             }
             else if (version[0] >= 4)//4.0 and up
             {
-                m_AnimationType = reader.ReadInt32();
-                if (m_AnimationType == 1)
+                m_AnimationType = (AnimationType)reader.ReadInt32();
+                if (m_AnimationType == AnimationType.kLegacy)
                     m_Legacy = true;
             }
             else

AssetStudio/Classes/Avatar.cs

@@ -1,14 +1,336 @@
-using System;
+using SharpDX;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace AssetStudio
 {
-    class Avatar
+    public class Node
     {
-        public string m_Name;
-        public List<KeyValuePair<uint, string>> m_TOS;
+        public int m_ParentId { get; set; }
+        public int m_AxesId { get; set; }
+
+        public Node(EndianBinaryReader reader)
+        {
+            m_ParentId = reader.ReadInt32();
+            m_AxesId = reader.ReadInt32();
+        }
+    }
+
+    public class Limit
+    {
+        public object m_Min { get; set; }
+        public object m_Max { get; set; }
+
+        public Limit(EndianBinaryReader reader, int[] version)
+        {
+            if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
+            {
+                m_Min = reader.ReadVector3();
+                m_Max = reader.ReadVector3();
+            }
+            else
+            {
+                m_Min = reader.ReadVector4();
+                m_Max = reader.ReadVector4();
+            }
+        }
+    }
+
+    public class Axes
+    {
+        public Vector4 m_PreQ { get; set; }
+        public Vector4 m_PostQ { get; set; }
+        public object m_Sgn { get; set; }
+        public Limit m_Limit { get; set; }
+        public float m_Length { get; set; }
+        public uint m_Type { get; set; }
+
+        public Axes(EndianBinaryReader reader, int[] version)
+        {
+            m_PreQ = reader.ReadVector4();
+            m_PostQ = reader.ReadVector4();
+            if (version[0] > 5 || (version[0] == 5 && version[1] >= 4)) //5.4 and up
+            {
+                m_Sgn = reader.ReadVector3();
+            }
+            else
+            {
+                m_Sgn = reader.ReadVector4();
+            }
+            m_Limit = new Limit(reader, version);
+            m_Length = reader.ReadSingle();
+            m_Type = reader.ReadUInt32();
+        }
+    }
+
+    public class Skeleton
+    {
+        public List<Node> m_Node { get; set; }
+        public List<uint> m_ID { get; set; }
+        public List<Axes> m_AxesArray { get; set; }
+
+
+        public Skeleton(EndianBinaryReader reader, int[] version)
+        {
+            int numNodes = reader.ReadInt32();
+            m_Node = new List<Node>(numNodes);
+            for (int i = 0; i < numNodes; i++)
+            {
+                m_Node.Add(new Node(reader));
+            }
+
+            int numIDs = reader.ReadInt32();
+            m_ID = new List<uint>(numIDs);
+            for (int i = 0; i < numIDs; i++)
+            {
+                m_ID.Add(reader.ReadUInt32());
+            }
+
+            int numAxes = reader.ReadInt32();
+            m_AxesArray = new List<Axes>(numAxes);
+            for (int i = 0; i < numAxes; i++)
+            {
+                m_AxesArray.Add(new Axes(reader, version));
+            }
+        }
+    }
+
+    public class SkeletonPose
+    {
+        public List<xform> m_X { get; set; }
+
+        public SkeletonPose()
+        {
+            m_X = new List<xform>();
+        }
+
+        public SkeletonPose(EndianBinaryReader reader, int[] version)
+        {
+            int numXforms = reader.ReadInt32();
+            m_X = new List<xform>(numXforms);
+            for (int i = 0; i < numXforms; i++)
+            {
+                m_X.Add(new xform(reader, version));
+            }
+        }
+    }
+
+    public class Hand
+    {
+        public List<int> m_HandBoneIndex { get; set; }
+
+        public Hand(EndianBinaryReader reader)
+        {
+            int numIndexes = reader.ReadInt32();
+            m_HandBoneIndex = new List<int>(numIndexes);
+            for (int i = 0; i < numIndexes; i++)
+            {
+                m_HandBoneIndex.Add(reader.ReadInt32());
+            }
+        }
+    }
+
+    public class Handle
+    {
+        public xform m_X { get; set; }
+        public uint m_ParentHumanIndex { get; set; }
+        public uint m_ID { get; set; }
+
+        public Handle(EndianBinaryReader reader, int[] version)
+        {
+            m_X = new xform(reader, version);
+            m_ParentHumanIndex = reader.ReadUInt32();
+            m_ID = reader.ReadUInt32();
+        }
+    }
+
+    public class Collider
+    {
+        public xform m_X { get; set; }
+        public uint m_Type { get; set; }
+        public uint m_XMotionType { get; set; }
+        public uint m_YMotionType { get; set; }
+        public uint m_ZMotionType { get; set; }
+        public float m_MinLimitX { get; set; }
+        public float m_MaxLimitX { get; set; }
+        public float m_MaxLimitY { get; set; }
+        public float m_MaxLimitZ { get; set; }
+
+        public Collider(EndianBinaryReader reader, int[] version)
+        {
+            m_X = new xform(reader, version);
+            m_Type = reader.ReadUInt32();
+            m_XMotionType = reader.ReadUInt32();
+            m_YMotionType = reader.ReadUInt32();
+            m_ZMotionType = reader.ReadUInt32();
+            m_MinLimitX = reader.ReadSingle();
+            m_MaxLimitX = reader.ReadSingle();
+            m_MaxLimitY = reader.ReadSingle();
+            m_MaxLimitZ = reader.ReadSingle();
+        }
+    }
+
+    public class Human
+    {
+        public xform m_RootX { get; set; }
+        public Skeleton m_Skeleton { get; set; }
+        public SkeletonPose m_SkeletonPose { get; set; }
+        public Hand m_LeftHand { get; set; }
+        public Hand m_RightHand { get; set; }
+        public List<Handle> m_Handles { get; set; }
+        public List<Collider> m_ColliderArray { get; set; }
+        public List<int> m_HumanBoneIndex { get; set; }
+        public List<float> m_HumanBoneMass { get; set; }
+        public List<int> m_ColliderIndex { get; set; }
+        public float m_Scale { get; set; }
+        public float m_ArmTwist { get; set; }
+        public float m_ForeArmTwist { get; set; }
+        public float m_UpperLegTwist { get; set; }
+        public float m_LegTwist { get; set; }
+        public float m_ArmStretch { get; set; }
+        public float m_LegStretch { get; set; }
+        public float m_FeetSpacing { get; set; }
+        public bool m_HasLeftHand { get; set; }
+        public bool m_HasRightHand { get; set; }
+        public bool m_HasTDoF { get; set; }
+
+        public Human(EndianBinaryReader reader, int[] version)
+        {
+            m_RootX = new xform(reader, version);
+            m_Skeleton = new Skeleton(reader, version);
+            m_SkeletonPose = new SkeletonPose(reader, version);
+            m_LeftHand = new Hand(reader);
+            m_RightHand = new Hand(reader);
+
+            if (version[0] < 2018 || (version[0] == 2018 && version[1] < 2)) //2018.2 down
+            {
+                int numHandles = reader.ReadInt32();
+                m_Handles = new List<Handle>(numHandles);
+                for (int i = 0; i < numHandles; i++)
+                {
+                    m_Handles.Add(new Handle(reader, version));
+                }
+
+                int numColliders = reader.ReadInt32();
+                m_ColliderArray = new List<Collider>(numColliders);
+                for (int i = 0; i < numColliders; i++)
+                {
+                    m_ColliderArray.Add(new Collider(reader, version));
+                }
+            }
+
+            int numIndexes = reader.ReadInt32();
+            m_HumanBoneIndex = new List<int>(numIndexes);
+            for (int i = 0; i < numIndexes; i++)
+            {
+                m_HumanBoneIndex.Add(reader.ReadInt32());
+            }
+
+            int numMasses = reader.ReadInt32();
+            m_HumanBoneMass = new List<float>(numMasses);
+            for (int i = 0; i < numMasses; i++)
+            {
+                m_HumanBoneMass.Add(reader.ReadSingle());
+            }
+
+            if (version[0] < 2018 || (version[0] == 2018 && version[1] < 2)) //2018.2 down
+            {
+                int numColliderIndexes = reader.ReadInt32();
+                m_ColliderIndex = new List<int>(numColliderIndexes);
+                for (int i = 0; i < numColliderIndexes; i++)
+                {
+                    m_ColliderIndex.Add(reader.ReadInt32());
+                }
+            }
+
+            m_Scale = reader.ReadSingle();
+            m_ArmTwist = reader.ReadSingle();
+            m_ForeArmTwist = reader.ReadSingle();
+            m_UpperLegTwist = reader.ReadSingle();
+            m_LegTwist = reader.ReadSingle();
+            m_ArmStretch = reader.ReadSingle();
+            m_LegStretch = reader.ReadSingle();
+            m_FeetSpacing = reader.ReadSingle();
+            m_HasLeftHand = reader.ReadBoolean();
+            m_HasRightHand = reader.ReadBoolean();
+            m_HasTDoF = reader.ReadBoolean();
+            reader.AlignStream(4);
+        }
+    }
+
+    public class AvatarConstant
+    {
+        public Skeleton m_AvatarSkeleton { get; set; }
+        public SkeletonPose m_AvatarSkeletonPose { get; set; }
+        public SkeletonPose m_DefaultPose { get; set; }
+        public List<uint> m_SkeletonNameIDArray { get; set; }
+        public Human m_Human { get; set; }
+        public List<int> m_HumanSkeletonIndexArray { get; set; }
+        public List<int> m_HumanSkeletonReverseIndexArray { get; set; }
+        public int m_RootMotionBoneIndex { get; set; }
+        public xform m_RootMotionBoneX { get; set; }
+        public Skeleton m_RootMotionSkeleton { get; set; }
+        public SkeletonPose m_RootMotionSkeletonPose { get; set; }
+        public List<int> m_RootMotionSkeletonIndexArray { get; set; }
+
+        public AvatarConstant(EndianBinaryReader reader, int[] version)
+        {
+            m_AvatarSkeleton = new Skeleton(reader, version);
+            m_AvatarSkeletonPose = new SkeletonPose(reader, version);
+
+            if (version[0] > 4 || (version[0] == 4 && version[1] >= 3)) //4.3 and up
+            {
+                m_DefaultPose = new SkeletonPose(reader, version);
+                int numIDs = reader.ReadInt32();
+                m_SkeletonNameIDArray = new List<uint>(numIDs);
+                for (int i = 0; i < numIDs; i++)
+                {
+                    m_SkeletonNameIDArray.Add(reader.ReadUInt32());
+                }
+            }
+
+            m_Human = new Human(reader, version);
+
+            int numIndexes = reader.ReadInt32();
+            m_HumanSkeletonIndexArray = new List<int>(numIndexes);
+            for (int i = 0; i < numIndexes; i++)
+            {
+                m_HumanSkeletonIndexArray.Add(reader.ReadInt32());
+            }
+
+            if (version[0] > 4 || (version[0] == 4 && version[1] >= 3)) //4.3 and up
+            {
+                int numReverseIndexes = reader.ReadInt32();
+                m_HumanSkeletonReverseIndexArray = new List<int>(numReverseIndexes);
+                for (int i = 0; i < numReverseIndexes; i++)
+                {
+                    m_HumanSkeletonReverseIndexArray.Add(reader.ReadInt32());
+                }
+            }
+
+            m_RootMotionBoneIndex = reader.ReadInt32();
+            m_RootMotionBoneX = new xform(reader, version);
+
+            if (version[0] > 4 || (version[0] == 4 && version[1] >= 3)) //4.3 and up
+            {
+                m_RootMotionSkeleton = new Skeleton(reader, version);
+                m_RootMotionSkeletonPose = new SkeletonPose(reader, version);
+
+                int numMotionIndexes = reader.ReadInt32();
+                m_RootMotionSkeletonIndexArray = new List<int>(numMotionIndexes);
+                for (int i = 0; i < numMotionIndexes; i++)
+                {
+                    m_RootMotionSkeletonIndexArray.Add(reader.ReadInt32());
+                }
+            }
+        }
+    }
+
+    public class Avatar
+    {
+        public string m_Name { get; set; }
+        public uint m_AvatarSize { get; set; }
+        public AvatarConstant m_Avatar { get; set; }
+        public List<KeyValuePair<uint, string>> m_TOS { get; set; }
 
         public Avatar(AssetPreloadData preloadData)
         {
@@ -18,232 +340,9 @@ namespace AssetStudio
             reader.Position = preloadData.Offset;
 
             m_Name = reader.ReadAlignedString();
-            var m_AvatarSize = reader.ReadUInt32();
-            //AvatarConstant m_Avatar
-            //- OffsetPtr m_AvatarSkeleton
-            //-- Skeleton data
-            //--- vector m_Node
-            var numNodes = reader.ReadInt32();
-            for (int i = 0; i < numNodes; i++)
-            {
-                reader.Position += 8;
-            }
-            //--- vector m_ID
-            int numIDs = reader.ReadInt32();
-            for (int i = 0; i < numIDs; i++)
-            {
-                reader.Position += 4;
-            }
-            //--- vector m_AxesArray
-            int numAxes = reader.ReadInt32();
-            for (int i = 0; i < numAxes; i++)
-            {
-                if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                    reader.Position += 76;
-                else
-                    reader.Position += 88;
-            }
-            //- OffsetPtr m_AvatarSkeletonPose
-            //-- SkeletonPose data
-            int numXforms = reader.ReadInt32();
-            for (int i = 0; i < numXforms; i++)
-            {
-                if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                    reader.Position += 40;
-                else
-                    reader.Position += 48;
-            }
-            if (version[0] > 4 || (version[0] == 4 && version[1] >= 3))//4.3 and up
-            {
-                //- OffsetPtr m_DefaultPose
-                //-- SkeletonPose data
-                numXforms = reader.ReadInt32();
-                for (int i = 0; i < numXforms; i++)
-                {
-                    if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                        reader.Position += 40;
-                    else
-                        reader.Position += 48;
-                }
-                //- vector m_SkeletonNameIDArray
-                numIDs = reader.ReadInt32();
-                for (int i = 0; i < numIDs; i++)
-                {
-                    reader.Position += 4;
-                }
-            }
-            //- OffsetPtr m_Human
-            //-- Human data
-            //--- xform m_RootX
-            if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                reader.Position += 40;
-            else
-                reader.Position += 48;
-            //--- OffsetPtr m_Skeleton
-            //---- Skeleton data
-            numNodes = reader.ReadInt32();
-            for (int i = 0; i < numNodes; i++)
-            {
-                reader.Position += 8;
-            }
-            //--- vector m_ID
-            numIDs = reader.ReadInt32();
-            for (int i = 0; i < numIDs; i++)
-            {
-                reader.Position += 4;
-            }
-            //--- vector m_AxesArray
-            numAxes = reader.ReadInt32();
-            for (int i = 0; i < numAxes; i++)
-            {
-                if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                    reader.Position += 76;
-                else
-                    reader.Position += 88;
-            }
-            //--- OffsetPtr m_SkeletonPose
-            //---- SkeletonPose data
-            numXforms = reader.ReadInt32();
-            for (int i = 0; i < numXforms; i++)
-            {
-                if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                    reader.Position += 40;
-                else
-                    reader.Position += 48;
-            }
-            //--- OffsetPtr m_LeftHand
-            //---- Hand data
-            //----- staticvector m_HandBoneIndex
-            int numIndexes = reader.ReadInt32();
-            for (int i = 0; i < numIndexes; i++)
-            {
-                reader.Position += 4;
-            }
-            //--- OffsetPtr m_RightHand
-            numIndexes = reader.ReadInt32();
-            for (int i = 0; i < numIndexes; i++)
-            {
-                reader.Position += 4;
-            }
+            m_AvatarSize = reader.ReadUInt32();
+            m_Avatar = new AvatarConstant(reader, version);
 
-            if (version[0] < 2018 || (version[0] == 2018 && version[1] < 2)) //2018.2 down
-            {
-                //--- vector m_Handles
-                int numHandles = reader.ReadInt32();
-                for (int i = 0; i < numHandles; i++)
-                {
-                    if (version[0] > 5 || (version[0] == 5 && version[1] >= 4)) //5.4 and up
-                        reader.Position += 48;
-                    else
-                        reader.Position += 56;
-                }
-                //--- vector m_ColliderArray
-                int numColliders = reader.ReadInt32();
-                for (int i = 0; i < numColliders; i++)
-                {
-                    if (version[0] > 5 || (version[0] == 5 && version[1] >= 4)) //5.4 and up
-                        reader.Position += 72;
-                    else
-                        reader.Position += 80;
-                }
-            }
-            //--- staticvector m_HumanBoneIndex
-            numIndexes = reader.ReadInt32();
-            for (int i = 0; i < numIndexes; i++)
-            {
-                reader.Position += 4;
-            }
-            //--- staticvector m_HumanBoneMass
-            int numMasses = reader.ReadInt32();
-            for (int i = 0; i < numMasses; i++)
-            {
-                reader.Position += 4;
-            }
-            if (version[0] < 2018 || (version[0] == 2018 && version[1] < 2)) //2018.2 down
-            {
-                //--- staticvector m_ColliderIndex
-                int numColliderIndexes = reader.ReadInt32();
-                for (int i = 0; i < numColliderIndexes; i++)
-                {
-                    reader.Position += 4;
-                }
-            }
-            var m_Scale = reader.ReadSingle();
-            var m_ArmTwist = reader.ReadSingle();
-            var m_ForeArmTwist = reader.ReadSingle();
-            var m_UpperLegTwist = reader.ReadSingle();
-            var m_LegTwist = reader.ReadSingle();
-            var m_ArmStretch = reader.ReadSingle();
-            var m_LegStretch = reader.ReadSingle();
-            var m_FeetSpacing = reader.ReadSingle();
-            var m_HasLeftHand = reader.ReadBoolean();
-            var m_HasRightHand = reader.ReadBoolean();
-            var m_HasTDoF = reader.ReadBoolean();
-            reader.AlignStream(4);
-            //- vector m_HumanSkeletonIndexArray
-            numIndexes = reader.ReadInt32();
-            for (int i = 0; i < numIndexes; i++)
-            {
-                reader.Position += 4;
-            }
-            if (version[0] > 4 || (version[0] == 4 && version[1] >= 3)) //4.3 and up
-            {
-                //- vector m_HumanSkeletonReverseIndexArray
-                int numReverseIndexes = reader.ReadInt32();
-                for (int i = 0; i < numReverseIndexes; i++)
-                {
-                    reader.Position += 4;
-                }
-            }
-            var m_RootMotionBoneIndex = reader.ReadInt32();
-            //- xform m_RootMotionBoneX
-            if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                reader.Position += 40;
-            else
-                reader.Position += 48;
-            if (version[0] > 4 || (version[0] == 4 && version[1] >= 3)) //4.3 and up
-            {
-                //- OffsetPtr m_RootMotionSkeleton
-                //-- Skeleton data
-                //--- vector m_Node
-                numNodes = reader.ReadInt32();
-                for (int i = 0; i < numNodes; i++)
-                {
-                    reader.Position += 8;
-                }
-                //--- vector m_ID
-                numIDs = reader.ReadInt32();
-                for (int i = 0; i < numIDs; i++)
-                {
-                    reader.Position += 4;
-                }
-                //--- vector m_AxesArray
-                numAxes = reader.ReadInt32();
-                for (int i = 0; i < numAxes; i++)
-                {
-                    if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                        reader.Position += 76;
-                    else
-                        reader.Position += 88;
-                }
-                //- OffsetPtr m_RootMotionSkeletonPose
-                //-- SkeletonPose data
-                numXforms = reader.ReadInt32();
-                for (int i = 0; i < numXforms; i++)
-                {
-                    if (version[0] > 5 || (version[0] == 5 && version[1] >= 4))//5.4 and up
-                        reader.Position += 40;
-                    else
-                        reader.Position += 48;
-                }
-                //- vector m_RootMotionSkeletonIndexArray
-                int numMotionIndexes = reader.ReadInt32();
-                for (int i = 0; i < numMotionIndexes; i++)
-                {
-                    reader.Position += 4;
-                }
-            }
-            //map m_TOS
             int numTOS = reader.ReadInt32();
             m_TOS = new List<KeyValuePair<uint, string>>(numTOS);
             for (int i = 0; i < numTOS; i++)

AssetStudio/Classes/Mesh.cs

@@ -180,12 +180,11 @@ namespace AssetStudio
                     return 4;
                 case 1: //kChannelFormatFloat16
                     return 2;
-                //in version 4.x is kChannelFormatColor with 4 dimension 
-                case 2: //kChannelFormatByte
+                case 2: //kChannelFormatColor, in 4.x is size 4
                     return 1;
-                case 3: //kChannelFormatByte, only used in 4.x
+                case 3: //kChannelFormatByte
                     return 1;
-                case 11: //kChannelFormatInt
+                case 11: //kChannelFormatInt32
                     return 4;
                 default:
                     return 0;