Exemplo n.º 1
0
        // <MeshSystem asset_name="dude.fbx" asset_info="null" mesh_system_version="1" mesh_system_asset_version="0">
        /// <summary>
        ///
        /// </summary>
        /// <param name="xElement"></param>
        /// <returns></returns>
        public static EZMMeshSystem Parse(System.Xml.Linq.XElement xElement)
        {
            EZMMeshSystem result = null;

            if (xElement.Name == "MeshSystem")
            {
                result = new EZMMeshSystem();
                {
                    var attr = xElement.Attribute("asset_name");
                    if (attr != null)
                    {
                        result.AssetName = attr.Value;
                    }
                }
                {
                    var attr = xElement.Attribute("asset_info");
                    if (attr != null)
                    {
                        result.AssetInfo = attr.Value;
                    }
                }
                {
                    var attr = xElement.Attribute("mesh_system_version");
                    if (attr != null)
                    {
                        result.Version = attr.Value;
                    }
                }
                {
                    var attr = xElement.Attribute("mesh_system_asset_version");
                    if (attr != null)
                    {
                        result.AssetVersion = attr.Value;
                    }
                }
                {
                    var skeletionRoot = xElement.Element("Skeletons");
                    if (skeletionRoot != null)
                    {
                        var xSkeletons = skeletionRoot.Elements("Skeleton");
                        var skeletons  = new EZMSkeleton[xSkeletons.Count()];
                        int index      = 0;
                        foreach (var xSkeleton in xSkeletons)
                        {
                            skeletons[index++] = EZMSkeleton.Parse(xSkeleton);
                        }
                        result.Skeletons = skeletons;
                    }
                }
                {
                    var animationRoot = xElement.Element("Animations");
                    if (animationRoot != null)
                    {
                        var xAnimations = animationRoot.Elements("Animation");
                        var animations  = new EZMAnimation[xAnimations.Count()];
                        int index       = 0;
                        foreach (var xAnimation in xAnimations)
                        {
                            var animation = EZMAnimation.Parse(xAnimation);
                            foreach (var animTrack in animation.AnimTracks)
                            {
                                string name = animTrack.BoneName;
                                if (name != null)
                                {
                                    foreach (var skeleton in result.Skeletons)
                                    {
                                        EZMBone bone = null;
                                        if (skeleton.nameBoneDict.TryGetValue(name, out bone))
                                        {
                                            if (animTrack.Bone != null)
                                            {
                                                throw new Exception("More than 1 bone for the animTrack!");
                                            }

                                            animTrack.Bone = bone;
                                            //break;
                                        }
                                    }
                                }
                            }
                            animations[index++] = animation;
                        }
                        result.Animations = animations;
                    }
                }

                var nameMaterialDict = new Dictionary <string, EZMMaterial>();
                {
                    var materialsRoot = xElement.Element("Materials");
                    if (materialsRoot != null)
                    {
                        var xMaterials = materialsRoot.Elements("Material");
                        var materials  = new EZMMaterial[xMaterials.Count()];
                        int index      = 0;
                        foreach (var xMaterial in xMaterials)
                        {
                            var material = EZMMaterial.Parse(xMaterial);
                            nameMaterialDict.Add(material.Name, material);
                            materials[index++] = material;
                        }
                        result.Materials = materials;
                    }
                }
                {
                    var meshesRoot = xElement.Element("Meshes");
                    if (meshesRoot != null)
                    {
                        var xMeshes = meshesRoot.Elements("Mesh");
                        var meshes  = new EZMMesh[xMeshes.Count()];
                        int index   = 0;
                        foreach (var xMesh in xMeshes)
                        {
                            EZMMesh mesh = EZMMesh.Parse(xMesh);
                            foreach (var meshSection in mesh.MeshSections)
                            {
                                string      name     = meshSection.MaterialName;
                                EZMMaterial material = null;
                                if (nameMaterialDict.TryGetValue(name, out material))
                                {
                                    meshSection.Material = material;
                                }
                            }
                            EZMSkeleton[] skeletons = result.Skeletons;
                            if (skeletons.Length > 0)
                            {
                                if (string.IsNullOrEmpty(mesh.SkeletonName) ||
                                    mesh.SkeletonName == "null")
                                {
                                    mesh.Skeleton = skeletons[0];
                                }
                                else
                                {
                                    foreach (var skeleton in skeletons)
                                    {
                                        if (mesh.SkeletonName == skeleton.Name)
                                        {
                                            mesh.Skeleton = skeleton;
                                            break;
                                        }
                                    }
                                }
                            }
                            meshes[index++] = mesh;
                        }
                        result.Meshes = meshes;
                    }
                }
            }

            return(result);
        }
Exemplo n.º 2
0
        // <Skeleton name="skeleton" count="60">
        /// <summary>
        /// A collection of <see cref="EZMBone"/>s.
        /// </summary>
        /// <param name="xSkeletion"></param>
        /// <returns></returns>
        public static EZMSkeleton Parse(System.Xml.Linq.XElement xElement)
        {
            EZMSkeleton result = null;

            if (xElement.Name == "Skeleton")
            {
                result = new EZMSkeleton();
                {
                    var attr = xElement.Attribute("name");
                    if (attr != null)
                    {
                        result.Name = attr.Value;
                    }
                }
                {
                    var xBones = xElement.Elements("Bone");
                    {
                        var bones = new EZMBone[xBones.Count()];
                        var dict  = new Dictionary <string, EZMBone>();
                        {
                            int index = 0;
                            foreach (var xBone in xBones)
                            {
                                var bone = EZMBone.Parse(xBone);
                                dict.Add(bone.Name, bone);
                                bones[index++] = bone;
                            }
                        }
                        result.nameBoneDict = dict;
                        result.Bones        = bones;
                    }
                    {
                        // form a tree.
                        List <EZMBone> rootBones = new List <EZMBone>();
                        foreach (var item in result.Bones)
                        {
                            string  parentName = item.ParentName;
                            EZMBone parent;
                            if ((parentName != null) && result.nameBoneDict.TryGetValue(parentName, out parent))
                            {
                                item.Parent = parent;
                                parent.children.Add(item);
                            }
                            else
                            {
                                rootBones.Add(item);
                            }
                        }

                        var orderedBones = new EZMBone[xBones.Count()];
                        {
                            // make sure bones are in 'parent - child' order.
                            int index = 0;
                            foreach (var item in rootBones)
                            {
                                Traverse(item, orderedBones, ref index);
                            }
                        }
                        // update absolute bone matrix.
                        EZMBone rootBone = orderedBones[0];
                        mat4    inverse  = glm.inverse(rootBone.OriginalState.matrix);
                        for (int i = 0; i < orderedBones.Length; i++)
                        {
                            EZMBone bone = orderedBones[i];
                            //bone.State.UpdateCache();
                            EZMBone parent = bone.Parent;
                            if (parent == null)
                            {
                                bone.combinedMat = bone.state.matrix;
                            }
                            else
                            {
                                bone.combinedMat = parent.combinedMat * bone.state.matrix;
                            }

                            bone.offsetMat = glm.inverse(bone.combinedMat);
                        }
                        result.OrderedBones = orderedBones;
                    }
                }
            }

            return(result);
        }
Exemplo n.º 3
0
        public static AiScene Parse(this EZMFile ezmFile)
        {
            if (ezmFile == null)
            {
                throw new ArgumentNullException();
            }

            var aiScene = new AiScene();

            aiScene.Fullname = ezmFile.Fullname;
            // root node.
            {
                EZMSkeleton skeleton = ezmFile.MeshSystem.Skeletons[0];
                EZMBone[]   bones    = skeleton.Bones;
                aiScene.RootNode = Parse(bones[0]);
                Match(aiScene.RootNode, bones[0]);
            }
            // meshes.
            {
                EZMMesh[] ezmMeshes = ezmFile.MeshSystem.Meshes;
                var       lstAiMesh = new List <AiMesh>();
                for (int i = 0; i < ezmMeshes.Length; i++)
                {
                    AiMesh[] aiMeshes = Parse(ezmMeshes[i]);
                    lstAiMesh.AddRange(aiMeshes);
                }
                aiScene.Meshes = lstAiMesh.ToArray();
            }
            // materials.
            {
                EZMMaterial[] ezmMaterials = ezmFile.MeshSystem.Materials;
                var           aiMaterials  = new AiMaterial[ezmMaterials.Length];
                for (int i = 0; i < aiMaterials.Length; i++)
                {
                    aiMaterials[i] = Parse(ezmMaterials[i]);
                }
                aiScene.Materials = aiMaterials;
            }
            // animations.
            {
                EZMAnimation[] ezmAnimations = ezmFile.MeshSystem.Animations;
                var            aiAnimations  = new AiAnimation[ezmAnimations.Length];
                for (int i = 0; i < ezmAnimations.Length; i++)
                {
                    aiAnimations[i] = Parse(ezmAnimations[i]);
                }
                aiScene.Animations = aiAnimations;
            }
            {
                // init material indexes in mesh.
                foreach (AiMesh aiMesh in aiScene.Meshes)
                {
                    string name = aiMesh.materialName;
                    for (int i = 0; i < aiScene.Materials.Length; i++)
                    {
                        if (aiScene.Materials[i].Name == name)
                        {
                            aiMesh.MaterialIndex = i;
                            break;
                        }
                    }
                }
            }
            {
                // bones.
                EZMSkeleton skeleton = ezmFile.MeshSystem.Skeletons[0];
                EZMBone[]   bones    = skeleton.Bones;
                var         aiBones  = new AiBone[bones.Length];
                for (int i = 0; i < bones.Length; i++)
                {
                    var aiBone = new AiBone();
                    var bone   = bones[i];
                    //bone.
                    aiBones[i] = aiBone;
                }
                aiScene.RootNode = Parse(bones[0]);
                Match(aiScene.RootNode, bones[0]);
            }
            return(aiScene);
        }