Provides the ability to create, open and save ZMS files used for models.
Inheritance: FileLoader
Example #1
0
    public static void ImportCharMesh(string meshPath, string zmsPath)
    {
        if (!File.Exists(zmsPath)) {
            Debug.LogWarning("Failed to find referenced ZMS.");
            return;
        }

        var mesh = new Mesh();

        var zms = new Revise.Files.ZMS.ModelFile();
        zms.Load(zmsPath);

        var verts = new Vector3[zms.Vertices.Count];
        var uvs = new Vector2[zms.Vertices.Count];
        var bones = new BoneWeight[zms.Vertices.Count];

        for (int k = 0; k < zms.Vertices.Count; ++k) {
            var v = zms.Vertices[k];
            v.TextureCoordinates[0].y = 1 - v.TextureCoordinates[0].y;

            verts[k] = rtuPosition(v.Position);
            uvs[k] = v.TextureCoordinates[0];

            bones[k] = new BoneWeight();
            bones[k].boneIndex0 = zms.BoneTable[v.BoneIndices.X];
            bones[k].boneIndex1 = zms.BoneTable[v.BoneIndices.Y];
            bones[k].boneIndex2 = zms.BoneTable[v.BoneIndices.Z];
            bones[k].boneIndex3 = zms.BoneTable[v.BoneIndices.W];
            bones[k].weight0 = v.BoneWeights.x;
            bones[k].weight1 = v.BoneWeights.y;
            bones[k].weight2 = v.BoneWeights.z;
            bones[k].weight3 = v.BoneWeights.w;
        }
        mesh.vertices = verts;
        mesh.uv = uvs;
        mesh.boneWeights = bones;

        int[] indices = new int[zms.Indices.Count * 3];
        for (int k = 0; k < zms.Indices.Count; ++k) {
            indices[k * 3 + 0] = zms.Indices[k].X;
            indices[k * 3 + 2] = zms.Indices[k].Y;
            indices[k * 3 + 1] = zms.Indices[k].Z;
        }
        mesh.triangles = indices;

        mesh.RecalculateNormals();

        AssetDatabase.CreateAsset(mesh, meshPath);
    }
Example #2
0
        public void ImportModels()
        {
            _meshLookup = new Mesh[_f.ModelFiles.Count];
            for (int i = 0; i < _f.ModelFiles.Count; ++i)
            {
                var zmsPath = rootPath + _f.ModelFiles[i];
                if (!File.Exists(zmsPath))
                {
                    Debug.LogWarning("Failed to find referenced ZMS.");
                    continue;
                }

                var mesh = new Mesh();

                var zms = new Revise.Files.ZMS.ModelFile();
                zms.Load(zmsPath);

                var verts = new Vector3[zms.Vertices.Count];
                var uvs = new Vector2[zms.Vertices.Count];
                for (int k = 0; k < zms.Vertices.Count; ++k)
                {
                    var v = zms.Vertices[k];
                    v.TextureCoordinates[0].y = 1 - v.TextureCoordinates[0].y;

                    verts[k] =  rtuPosition(v.Position);
                    uvs[k] = v.TextureCoordinates[0];
                }
                mesh.vertices = verts;
                mesh.uv = uvs;

                int[] indices = new int[zms.Indices.Count * 3];
                for (int k = 0; k < zms.Indices.Count; ++k)
                {
                    indices[k * 3 + 0] = zms.Indices[k].X;
                    indices[k * 3 + 2] = zms.Indices[k].Y;
                    indices[k * 3 + 1] = zms.Indices[k].Z;
                }
                mesh.triangles = indices;

                mesh.RecalculateNormals();
                Unwrapping.GenerateSecondaryUVSet(mesh);

                var meshPath = _basePath + "Mesh_" + i.ToString() + ".asset";
                AssetDatabase.CreateAsset(mesh, meshPath);
                _meshLookup[i] = mesh;
            }

            _matLookup = new Material[_f.TextureFiles.Count];
            for (int i = 0; i < _f.TextureFiles.Count; ++i)
            {
                var tex = _f.TextureFiles[i];

                var texPath = _basePath + "Tex_" + texLookup[i].ToString() + ".DDS";
                if (!File.Exists(texPath))
                {
                    continue;
                }

                var tex2d = AssetDatabase.LoadAssetAtPath(texPath, typeof(Texture2D)) as Texture2D;

                Shader shader = null;
                if (tex.TwoSided) {
                    if (tex.AlphaTestEnabled)
                        shader = Shader.Find("Transparent/Cutout/DoubleSided");
                    else if (tex.AlphaEnabled)
                        shader = Shader.Find("Transparent/DoubleSided");
                    else {
                        Debug.LogWarning("Two-sided non-alpha material encountered.");
                    }
                } else if (tex.AlphaTestEnabled)
                    shader = Shader.Find("Transparent/Cutout/Diffuse");
                else if (tex.AlphaEnabled)
                    shader = Shader.Find("Transparent/Diffuse");
                else
                    shader = Shader.Find("Diffuse");

                if (!shader)
                {
                    Debug.LogWarning("Failed to find appropriate shader for material.");
                    continue;
                }

                var mat = new Material(shader);
                if (tex.AlphaTestEnabled)
                    mat.SetFloat("_Cutoff", (float)tex.AlphaReference / 256);
                mat.mainTexture = tex2d;

                var matPath = _basePath + "Mat_" + i.ToString() + ".mat";
                AssetDatabase.CreateAsset(mat, matPath);

                _matLookup[i] = mat;
            }

            for (int i = 0; i < _f.Objects.Count; ++i)
            {
                var obj = _f.Objects[i];
                var mdl = ScriptableObject.CreateInstance<RoseMapObjectData>();

                for (int j = 0; j < obj.Parts.Count; ++j)
                {
                    var part = obj.Parts[j];
                    var subObj = new RoseMapObjectData.SubObject();

                    subObj.mesh = _meshLookup[part.Model];
                    subObj.material = _matLookup[part.Texture];
                    subObj.animation = null;
                    subObj.parent = part.Parent;
                    subObj.position = rtuPosition(part.Position) / 100;
                    subObj.rotation = rtuRotation(part.Rotation);
                    subObj.scale = rtuScale(part.Scale);
                    if (part.Collision == Revise.Files.ZSC.CollisionType.None) {
                        subObj.colMode = 0;
                    } else {
                        subObj.colMode = 1;
                    }

                    if (part.AnimationFilePath != "") {
                        var animPath = _basePath + "Anim_" + i.ToString() + "_" + j.ToString() + ".asset";
                        var clip = ImportNodeAnimation(animPath, part.AnimationFilePath);
                        subObj.animation = clip;
                    }

                    mdl.subObjects.Add(subObj);
                }

                var mdlPath = _basePath + "Model_" + i.ToString() + ".asset";
                AssetDatabase.CreateAsset(mdl, mdlPath);
                EditorUtility.SetDirty(mdl);
            }
        }
Example #3
0
        /// <summary>
        /// Tests the load method.
        /// </summary>
        private void TestLoadMethod(string filePath)
        {
            Stream stream = File.OpenRead(filePath);

            stream.Seek(0, SeekOrigin.End);
            long fileSize = stream.Position;
            stream.Seek(0, SeekOrigin.Begin);

            ModelFile modelFile = new ModelFile();
            modelFile.Load(stream);

            long streamPosition = stream.Position;
            stream.Close();

            Assert.AreEqual(fileSize, streamPosition, "Not all of the file was read");
        }
Example #4
0
        /// <summary>
        /// Tests the save method.
        /// </summary>
        private void TestSaveMethod(string filePath)
        {
            ModelFile modelFile = new ModelFile();
            modelFile.Load(filePath);

            MemoryStream savedStream = new MemoryStream();
            modelFile.Save(savedStream);

            savedStream.Seek(0, SeekOrigin.Begin);

            ModelFile savedModelFile = new ModelFile();
            savedModelFile.Load(savedStream);

            savedStream.Close();

            Assert.AreEqual(modelFile.Pool, savedModelFile.Pool, "Pool values do not match");
            Assert.AreEqual(modelFile.BoneTable.Count, savedModelFile.BoneTable.Count, "Bone table counts do not match");

            for (int i = 0; i < modelFile.BoneTable.Count; i++) {
                Assert.AreEqual(modelFile.BoneTable[i], savedModelFile.BoneTable[i], "Bone table values do not match");
            }

            Assert.AreEqual(modelFile.Vertices.Count, savedModelFile.Vertices.Count, "Vertex counts do not match");

            for (int i = 0; i < modelFile.Vertices.Count; i++) {
                Assert.AreEqual(modelFile.Vertices[i].Position, savedModelFile.Vertices[i].Position, "Vertex position values do not match");
                Assert.AreEqual(modelFile.Vertices[i].Normal, savedModelFile.Vertices[i].Normal, "Vertex normal values do not match");
                Assert.AreEqual(modelFile.Vertices[i].Colour, savedModelFile.Vertices[i].Colour, "Vertex colour values do not match");
                Assert.AreEqual(modelFile.Vertices[i].BoneWeights, savedModelFile.Vertices[i].BoneWeights, "Vertex bone weight values do not match");
                Assert.AreEqual(modelFile.Vertices[i].BoneIndices, savedModelFile.Vertices[i].BoneIndices, "Vertex bone index values do not match");
                Assert.AreEqual(modelFile.Vertices[i].TextureCoordinates[0], savedModelFile.Vertices[i].TextureCoordinates[0], "Vertex texture coordinate values do not match");
                Assert.AreEqual(modelFile.Vertices[i].TextureCoordinates[1], savedModelFile.Vertices[i].TextureCoordinates[1], "Vertex texture coordinate values do not match");
                Assert.AreEqual(modelFile.Vertices[i].TextureCoordinates[2], savedModelFile.Vertices[i].TextureCoordinates[2], "Vertex texture coordinate values do not match");
                Assert.AreEqual(modelFile.Vertices[i].TextureCoordinates[3], savedModelFile.Vertices[i].TextureCoordinates[3], "Vertex texture coordinate values do not match");
                Assert.AreEqual(modelFile.Vertices[i].Tangent, savedModelFile.Vertices[i].Tangent, "Vertex tangent values do not match");
            }

            Assert.AreEqual(modelFile.Indices.Count, savedModelFile.Indices.Count, "Index counts do not match");

            for (int i = 0; i < modelFile.Indices.Count; i++) {
                Assert.AreEqual(modelFile.Indices[i], savedModelFile.Indices[i], "Index values do not match");
            }

            Assert.AreEqual(modelFile.Materials.Count, savedModelFile.Materials.Count, "Material counts do not match");

            for (int i = 0; i < modelFile.Materials.Count; i++) {
                Assert.AreEqual(modelFile.Materials[i], savedModelFile.Materials[i], "Material values do not match");
            }

            Assert.AreEqual(modelFile.Strips.Count, savedModelFile.Strips.Count, "Strip counts do not match");

            for (int i = 0; i < modelFile.Strips.Count; i++) {
                Assert.AreEqual(modelFile.Strips[i], savedModelFile.Strips[i], "Strip values do not match");
            }
        }