Пример #1
0
        public static PMXModel LoadFromPMXFile(string pmxFile, PMXModelDescriptor modelDescriptor)
        {
            FileStream fs = new FileStream(pmxFile, FileMode.Open, FileAccess.Read, FileShare.Read);

            byte[] buffer = new byte[3];
            fs.Read(buffer, 0, 3);
            string head = Encoding.ASCII.GetString(buffer);

            fs.Seek(1, SeekOrigin.Current);

            if (head != "PMX")
            {
                throw new Exception("Not a PMX file!");
            }

            BinaryReader br = new BinaryReader(fs);

            float PMXVersion = br.ReadSingle();

            if (PMXVersion != 2.0f && PMXVersion != 2.1f)
            {
                throw new Exception("Unsupported PMX Version!");
            }

            byte flags = br.ReadByte();

            if (flags != 8)
            {
                throw new Exception("Invalid PMX bytes version!");
            }

            MMDImportSettings  settings = new MMDImportSettings(MMDImportSettings.ModelFormat.PMX);
            List <PMXBasePart> allParts = new List <PMXBasePart>();

            byte text_encoding = br.ReadByte();

            settings.TextEncoding =
                (text_encoding == 1 ? Encoding.UTF8 :
                 (text_encoding == 0 ? Encoding.Unicode : Encoding.GetEncoding(932)));

            settings.ExtendedUV      = br.ReadByte();
            settings.ClassDescriptor = modelDescriptor;

            PMXModel md = new PMXModel();

            settings.BitSettings.VertexIndexLength    = br.ReadByte();
            settings.BitSettings.TextureIndexLength   = br.ReadByte();
            settings.BitSettings.MaterialIndexLength  = br.ReadByte();
            settings.BitSettings.BoneIndexLength      = br.ReadByte();
            settings.BitSettings.MorphIndexLength     = br.ReadByte();
            settings.BitSettings.RigidBodyIndexLength = br.ReadByte();

            md.NameJP        = PMXParser.ReadString(br, settings.TextEncoding);
            md.NameEN        = PMXParser.ReadString(br, settings.TextEncoding);
            md.DescriptionJP = PMXParser.ReadString(br, settings.TextEncoding);
            md.DescriptionEN = PMXParser.ReadString(br, settings.TextEncoding);


            //Vertices
            uint vertexCount = br.ReadUInt32();

            for (int i = 0; i < vertexCount; i++)
            {
                PMXVertex v = (PMXVertex)Activator.CreateInstance(modelDescriptor.VertexType.StoredType, new object[] { md });
                v.LoadFromStream(br, settings);
                md.Vertices.Add(v);
                allParts.Add(v);
            }

            //Triangles
            uint vertexRefCount = br.ReadUInt32();

            if (vertexRefCount % 3 != 0)
            {
                throw new Exception("Invalid triangle count!");
            }

            uint triangleCount = vertexRefCount / 3;
            List <PMXTriangle> importTriangles = new List <PMXTriangle>();

            for (int i = 0; i < triangleCount; i++)
            {
                PMXTriangle t = (PMXTriangle)Activator.CreateInstance(modelDescriptor.TriangleType.StoredType, new object[] { md });
                t.LoadFromStream(br, settings);
                importTriangles.Add(t);
                allParts.Add(t);
            }

            //Textures
            uint textureCount = br.ReadUInt32();

            List <string> importTextures = new List <string>();

            for (int i = 0; i < textureCount; i++)
            {
                string tex = PMXParser.ReadString(br, settings.TextEncoding);
                importTextures.Add(tex);
            }
            string[] textures = importTextures.ToArray();

            //Materials
            uint materialCount = br.ReadUInt32();

            for (int i = 0; i < materialCount; i++)
            {
                PMXMaterial mt = (PMXMaterial)Activator.CreateInstance(modelDescriptor.MaterialType.StoredType, new object[] { md });
                mt.LoadFromStream(br, settings, textures, importTriangles);
                md.Materials.Add(mt);
                allParts.Add(mt);
            }

            if (importTriangles.Count > 0)
            {
                throw new InvalidDataException("Model materials don't cover all triangles!");
            }

            //Bones
            uint boneCount = br.ReadUInt32();

            for (int i = 0; i < boneCount; i++)
            {
                PMXBone bn = (PMXBone)Activator.CreateInstance(modelDescriptor.BoneType.StoredType, new object[] { md });
                bn.LoadFromStream(br, settings);
                md.Bones.Add(bn);
                allParts.Add(bn);
            }

            //Morphs
            uint morphCount = br.ReadUInt32();

            for (int i = 0; i < morphCount; i++)
            {
                PMXMorph mrph = (PMXMorph)Activator.CreateInstance(modelDescriptor.MorphType.StoredType, new object[] { md });
                mrph.LoadFromStream(br, settings);
                md.Morphs.Add(mrph);
                allParts.Add(mrph);
            }

            //Display frames
            md.DisplaySlots.Clear();
            uint displayCount = br.ReadUInt32();

            for (int i = 0; i < displayCount; i++)
            {
                PMXDisplaySlot ds = new PMXDisplaySlot(md);
                ds.LoadFromStream(br, settings);
                md.DisplaySlots.Add(ds);
                allParts.Add(ds);
            }

            //Rigid bodies
            uint rigidBodyCount = br.ReadUInt32();

            for (int i = 0; i < rigidBodyCount; i++)
            {
                PMXRigidBody rb = (PMXRigidBody)Activator.CreateInstance(modelDescriptor.RigidBodyType.StoredType, new object[] { md });
                rb.LoadFromStream(br, settings);
                md.RigidBodies.Add(rb);
                allParts.Add(rb);
            }

            //Joints
            uint jointsCount = br.ReadUInt32();

            for (int i = 0; i < jointsCount; i++)
            {
                PMXJoint jt = (PMXJoint)Activator.CreateInstance(modelDescriptor.JointType.StoredType, new object[] { md });
                jt.LoadFromStream(br, settings);
                md.Joints.Add(jt);
                allParts.Add(jt);
            }

            br.BaseStream.Close();

            br = null;
            fs = null;

            foreach (PMXBasePart part in allParts)
            {
                part.FinaliseAfterImport();
            }

            return(md);
        }
Пример #2
0
        /// <summary>
        /// Loads a model from a PMD file and converts it to PMX internally.
        /// </summary>
        /// <param name="pmdFile">PMD file name</param>
        /// <param name="modelDescriptor">Classes to use during import</param>
        /// <returns></returns>
        public static PMXModel LoadFromPMDFile(string pmdFile, PMXModelDescriptor modelDescriptor)
        {
            FileStream fs = new FileStream(pmdFile, FileMode.Open, FileAccess.Read, FileShare.Read);

            byte[] buffer = new byte[3];
            fs.Read(buffer, 0, 3);
            string head = Encoding.ASCII.GetString(buffer);

            if (head != "Pmd")
            {
                throw new Exception("Not a PMD file!");
            }

            BinaryReader br = new BinaryReader(fs);

            float PMDVersion = br.ReadSingle();

            if (PMDVersion != 1.0f)
            {
                throw new Exception("Unsupported PMD Version!");
            }

            MMDImportSettings  settings = new MMDImportSettings(MMDImportSettings.ModelFormat.PMD);
            List <PMXBasePart> allParts = new List <PMXBasePart>();

            settings.ClassDescriptor = modelDescriptor;
            settings.TextEncoding    = Encoding.GetEncoding(932);
            settings.ExtendedUV      = 0;

            PMXModel md = new PMXModel();

            md.NameJP        = PMDParser.ReadString(br, 20, settings.TextEncoding);
            md.DescriptionJP = PMDParser.ReadString(br, 256, settings.TextEncoding);

            //Vertices
            uint vertexCount = br.ReadUInt32();

            for (int i = 0; i < vertexCount; i++)
            {
                PMXVertex v = (PMXVertex)Activator.CreateInstance(modelDescriptor.VertexType.StoredType, new object[] { md });
                v.LoadFromStream(br, settings);
                md.Vertices.Add(v);
                allParts.Add(v);
            }

            //Triangles
            uint vertexRefCount = br.ReadUInt32();

            if (vertexRefCount % 3 != 0)
            {
                throw new Exception("Invalid triangle count!");
            }

            uint triangleCount = vertexRefCount / 3;
            List <PMXTriangle> importTriangles = new List <PMXTriangle>();

            for (int i = 0; i < triangleCount; i++)
            {
                PMXTriangle t = (PMXTriangle)Activator.CreateInstance(modelDescriptor.TriangleType.StoredType, new object[] { md });
                t.LoadFromStream(br, settings);
                importTriangles.Add(t);
                allParts.Add(t);
            }

            //Materials
            uint materialCount = br.ReadUInt32();

            for (int i = 0; i < materialCount; i++)
            {
                PMXMaterial mt = (PMXMaterial)Activator.CreateInstance(modelDescriptor.MaterialType.StoredType, new object[] { md });
                mt.LoadFromStream(br, settings, null, importTriangles);
                md.Materials.Add(mt);

                mt.NameJP = "Material" + (i + 1).ToString(); //Initialise default names
                mt.NameEN = "Material" + (i + 1).ToString(); //Initialise default names

                allParts.Add(mt);
            }

            //Bones
            uint boneCount = (uint)br.ReadUInt16();

            for (int i = 0; i < boneCount; i++)
            {
                PMXBone bn = (PMXBone)Activator.CreateInstance(modelDescriptor.BoneType.StoredType, new object[] { md });
                bn.LoadFromStream(br, settings);
                md.Bones.Add(bn);
                allParts.Add(bn);
            }

            //PMD IKs - will be handled internally
            uint ikCount = (uint)br.ReadUInt16();

            for (int i = 0; i < ikCount; i++)
            {
                int     boneId = br.ReadUInt16();
                PMXBone bn     = md.Bones[boneId];
                bn.IK = new PMXIK(md, bn);
                bn.IK.LoadFromStream(br, settings);
            }

            //Morphs
            uint mCount = (uint)br.ReadUInt16();

            for (int i = 0; i < mCount; i++)
            {
                PMXMorph mrph = (PMXMorph)Activator.CreateInstance(modelDescriptor.MorphType.StoredType, new object[] { md });
                mrph.LoadFromStream(br, settings);

                if (mrph.NameJP == "base")
                {
                    settings.BaseMorph = mrph;
                }

                md.Morphs.Add(mrph);
                allParts.Add(mrph);
            }

            //Display groups - kinda insanely set up for PMD

            //Initialising root slot manually
            md.DisplaySlots[0].References.Add(md.Bones[0]);
            allParts.Add(md.DisplaySlots[0]);

            //Exp slot is initialised differently (cause why not?)
            uint miCount = (uint)br.ReadByte();

            for (int i = 0; i < miCount; i++)
            {
                int morphId = br.ReadUInt16();
                md.DisplaySlots[1].References.Add(md.Morphs[morphId]);
            }
            allParts.Add(md.DisplaySlots[1]);

            //Display slots.. guess.. work completely different as well - first of all: Let's gather the names!
            uint nameCount = (uint)br.ReadByte();

            for (int i = 0; i < nameCount; i++)
            {
                PMXDisplaySlot ds = new PMXDisplaySlot(md);
                ds.NameJP = PMDParser.ReadString(br, 50, settings.TextEncoding);
                md.DisplaySlots.Add(ds);
                allParts.Add(ds);
            }

            //We've got the names - now let's put the bones in
            uint boneIndexCount = (uint)br.ReadUInt32();

            for (int i = 0; i < boneIndexCount; i++)
            {
                ushort bI   = br.ReadUInt16();
                byte   slot = br.ReadByte();

                md.DisplaySlots[slot + 1].References.Add(md.Bones[bI]);
            }

            //Those were the display slots!

            //Does the model have English names?
            bool hasEnglishNames = false;

            if (br.BaseStream.Position < br.BaseStream.Length) //Not EOF yet
            {
                hasEnglishNames = (br.ReadByte() == 1);
            }

            if (hasEnglishNames) //Read English names
            {
                md.NameEN        = PMDParser.ReadString(br, 20, settings.TextEncoding);
                md.DescriptionEN = PMDParser.ReadString(br, 256, settings.TextEncoding);
                foreach (PMXBone bn in md.Bones)
                {
                    bn.NameEN = PMDParser.ReadString(br, 20, settings.TextEncoding);
                }
                bool firstMorph = true;
                foreach (PMXMorph mrph in md.Morphs)
                {
                    if (firstMorph && mrph.NameJP == "base")
                    {
                        continue;
                    }
                    mrph.NameEN = PMDParser.ReadString(br, 20, settings.TextEncoding);
                    firstMorph  = false;
                }
                for (int i = 2; i < md.DisplaySlots.Count; i++)
                {
                    md.DisplaySlots[i].NameEN = PMDParser.ReadString(br, 50, settings.TextEncoding);
                }
            }
            else //At least initialise them by using JP names
            {
                md.NameEN        = md.NameJP;
                md.DescriptionEN = md.DescriptionJP;
                foreach (PMXBone bn in md.Bones)
                {
                    bn.NameEN = bn.NameJP;
                }
                foreach (PMXMorph mrph in md.Morphs)
                {
                    mrph.NameEN = mrph.NameJP;
                }
                for (int i = 2; i < md.DisplaySlots.Count; i++)
                {
                    md.DisplaySlots[i].NameEN = md.DisplaySlots[i].NameJP;
                }
            }

            //Are there special toon textures?
            string[] defaultToons = new string[]
            {
                "toon01.bmp", "toon02.bmp", "toon03.bmp", "toon04.bmp", "toon05.bmp",
                "toon06.bmp", "toon07.bmp", "toon08.bmp", "toon09.bmp", "toon10.bmp"
            };
            string[] thisModelToons = new string[10];

            if (br.BaseStream.Position < br.BaseStream.Length) //Not EOF yet
            {
                for (int i = 0; i < 10; i++)
                {
                    thisModelToons[i] = PMDParser.ReadString(br, 100, settings.TextEncoding);
                }
            }
            else
            {
                Array.Copy(defaultToons, thisModelToons, 10);
            }

            //Does the PMD file have physics?
            if (br.BaseStream.Position < br.BaseStream.Length) //Not EOF yet
            {
                //Rigid bodies
                uint rigidBodyCount = br.ReadUInt32();

                for (int i = 0; i < rigidBodyCount; i++)
                {
                    PMXRigidBody rb = (PMXRigidBody)Activator.CreateInstance(modelDescriptor.RigidBodyType.StoredType, new object[] { md });
                    rb.LoadFromStream(br, settings);
                    md.RigidBodies.Add(rb);
                    allParts.Add(rb);
                }

                //Joints
                uint jointsCount = br.ReadUInt32();

                for (int i = 0; i < jointsCount; i++)
                {
                    PMXJoint jt = (PMXJoint)Activator.CreateInstance(modelDescriptor.JointType.StoredType, new object[] { md });
                    jt.LoadFromStream(br, settings);
                    md.Joints.Add(jt);
                    allParts.Add(jt);
                }
            }

            foreach (PMXBasePart part in allParts)
            {
                part.FinaliseAfterImport();
            }

            foreach (PMXMaterial mt in md.Materials)
            {
                mt.AssignToonForPMD(defaultToons, thisModelToons);
            }

            foreach (PMXBone bn in md.Bones)
            {
                bn.ParsePMDTwist();
                bn.CreateLocalCoodinateAxisForPMD();
                bn.UpdatePMDIKs();
            }

            if (md.Morphs[0].NameJP == "base")
            {
                md.Morphs.RemoveAt(0);
            }

            br = null;
            fs.Close();
            fs = null;

            return(md);
        }