XNA4 加载模型文件 适用于WP7 Silverlight5

SKLReader

using System;
using System.Collections.Generic;
using System.Linq;using
System.Text;using System.IO;
namespace SknImporter
{
    class SklReader
    {
        public struct SklHeader
        {
public byte[] version;
            public int numObjects;
            public int skeletonHash;
            public int numElements;
        }
        public struct SklBone
        {
            //length :32           
            public int index;
            public string name;
            public int parent;
            public float scale;
            public float[,] matrix;
        }

        public List<SklBone> Bones = new List<SklBone>();
        public SklReader(string file)
        {
            SklHeader header = new SklHeader(); FileStream fs = File.Open(file, FileMode.Open); BinaryReader reader = new BinaryReader(fs);
            header.version = reader.ReadBytes(8); header.numObjects = reader.ReadInt32(); header.skeletonHash = reader.ReadInt32(); header.numElements = reader.ReadInt32();
            for (int b = 0; b < header.numElements; b++)
            {
                SklBone bone = new SklBone(); bone.index = b; bone.name = Encoding.ASCII.GetString(reader.ReadBytes(32)).Replace("\0", ""); bone.parent = reader.ReadInt32(); bone.scale = reader.ReadSingle(); bone.matrix = new float[3, 4]; for (int y = 0; y < 3; y++) { for (int x = 0; x < 4; x++) { bone.matrix[y, x] = reader.ReadSingle(); } }
                Bones.Add(bone);
            } fs.Close();
        }
    }
}

 

SknImporter


using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content.Pipeline;
using Microsoft.Xna.Framework.Content.Pipeline.Graphics;
using Microsoft.Xna.Framework.Content.Pipeline.Processors;
using System.IO;


// TODO: 将这些项替换为处理器输入和输出类型。


namespace SknImporter
{
    /// <summary>
    /// 此类将由 XNA Framework 内容管道实例化，
    /// 以便将自定义处理应用于内容数据，将对象转换用于类型 TInput 到
    /// 类型 TOnput 的改变。如果处理器希望改变数据但不更改其类型，
    /// 输入和输出类型可以相同。
    ///
    /// 这应当属于内容管道扩展库项目的一部分。
    ///
    /// TODO: 更改 ContentProcessor 属性以为此处理器指定
    /// 正确的显示名称。
    /// </summary>
   [ContentImporter(".skn", CacheImportedData = true, DefaultProcessor = "SKN Processor")]
    public class SknImporter : ContentImporter<NodeContent>
    {
       ContentImporterContext importerContext;


       // The root NodeContent of our model
       private NodeContent rootNode;


       // All vertex data in the file
       private List<Vector3> positions;
       private List<Vector2> texCoords;
       private List<Vector3> normals;




       // The current mesh being constructed
       private MeshBuilder meshBuilder;


       private int textureCoordinateDataIndex;
       private int normalDataIndex;


       private int[] positionMap;
       public override NodeContent Import(string filename, ContentImporterContext context)
       {

           //这句话需要被注释掉，实际使用的话
           System.Diagnostics.Debugger.Launch();
           importerContext = context;


           string sklPath = Path.GetDirectoryName(filename) + "\\" + Path.GetFileNameWithoutExtension(filename) + ".skl";
           importerContext.AddDependency(sklPath);








           rootNode = new NodeContent();
           rootNode.Identity = new ContentIdentity(filename);


           SklReader sklReader = new SklReader(sklPath);
           SknReader sknReader = new SknReader(filename);
           positions = new List<Vector3>();
           texCoords = new List<Vector2>();
           normals = new List<Vector3>();


           importerContext.Logger.LogWarning(null, rootNode.Identity, sklReader.Bones.Count.ToString("X2"));


           foreach (var item in sknReader.materialList)
           {
               for (int i = item.startVertex; i < item.numVertices; i++)
               {
                   SkinModelVertex vertex = sknReader.modelData.verteces;


                   positions.Add(new Vector3(sknReader.modelData.verteces.position[0],
                                            sknReader.modelData.verteces.position[1],
                                            sknReader.modelData.verteces.position[2]));


                   texCoords.Add(new Vector2(sknReader.modelData.verteces.texcoords[0],
                                            sknReader.modelData.verteces.texcoords[1]));


                   normals.Add(new Vector3(sknReader.modelData.verteces.normal[0],
                                           sknReader.modelData.verteces.normal[1],
                                           sknReader.modelData.verteces.normal[2]));
               }


               StartMesh(item.name);
               BuildIndex(sknReader);
               MeshContent mc = FinishMesh();
               positions.Clear();
               texCoords.Clear();
               normals.Clear();
               mc.Children.Add(BuildBone(sklReader));
               rootNode.Children.Add(mc);
           }


           #region Testing Build Mesh with Bones
           //foreach (var item in sknReader.materialList)
           //{
           //    for (int i = item.startVertex; i < item.numVertices; i++)
           //    {
           //        SkinModelVertex vertex = sknReader.modelData.verteces;


           //        texCoords.Add(new Vector2(vertex.texcoords[0],
           //                                 vertex.texcoords[1]));


           //        normals.Add(new Vector3(vertex.normal[0],
           //                                vertex.normal[1],
           //                                vertex.normal[2]));
           //    }
           //}




           //foreach (var bone in sklReader.Bones)
           //{
           //    List<SkinModelVertex> exsitVexter = new List<SkinModelVertex>();
           //    List<int> addedVertex = new List<int>();
           //    foreach (var vertex in sknReader.modelData.verteces)
           //    {
           //        for (int i = 0; i < 4; i++)
           //        {
           //            if(vertex.boneIndex == bone.index)
           //            {
           //                exsitVexter.Add(vertex);
           //                positions.Add(new Vector3(
           //                                    vertex.position[0],
           //                                    vertex.position[1],
           //                                    vertex.position[2]));
           //            }
           //        }
           //    }
           //    StartMesh(bone.name);
           //    BuildIndexByBone(sknReader,exsitVexter);
           //    MeshContent mc = FinishMesh();
           //    rootNode.Children.Add(mc);
           //    positions.Clear();
           //}
           #endregion


           return rootNode;
       }
       private BoneContent BuildBone(SklReader sklReader)
       {
           List<BoneContent> bone = new List<BoneContent>();
           foreach (var item in sklReader.Bones)
           {
               BoneContent bc = new BoneContent();
               bc.Transform = new Matrix(
                    item.matrix[0, 0], item.matrix[0, 1], item.matrix[0, 2], item.matrix[0, 3],
                    item.matrix[1, 0], item.matrix[1, 1], item.matrix[1, 2], item.matrix[1, 3],
                    item.matrix[2, 0], item.matrix[2, 1], item.matrix[2, 2], item.matrix[2, 3],
                    0f, 0f, 0f, 0f);
               bc.Name = item.name;
               bone.Add(bc);
           }
           BoneContent rootBone = new BoneContent();
           BoneContent tmpBone;
           int max = bone.Count - 1;


           while (max > 0)
           {
               if (sklReader.Bones[max].parent >= 0)
                   tmpBone = bone[sklReader.Bones[max].parent];
               else
                   tmpBone = rootBone;
               tmpBone.Children.Add(bone[max]);
               bone.RemoveAt(max);
               max--;
           }


           return rootBone;
       }
       private void AddTriangleVertex(int index)
       {
           Vector2 texCoord = Vector2.Zero;
           texCoord = texCoords[index];
           meshBuilder.SetVertexChannelData(textureCoordinateDataIndex,
               texCoord);


           Vector3 normal = Vector3.Zero;
           normal = normals[index];
           meshBuilder.SetVertexChannelData(normalDataIndex,
               normal);


           meshBuilder.AddTriangleVertex(index);
       }
       private void BuildIndex(SknReader sknReader)
       {
           for (int i = 0; i < sknReader.modelData.numIndices / 3; i++)
           {
               int a = sknReader.modelData.indices[i * 3];
               int b = sknReader.modelData.indices[i * 3 + 1];
               int c = sknReader.modelData.indices[i * 3 + 2];
               AddTriangleVertex(a);
               AddTriangleVertex(b);
               AddTriangleVertex(c);
           }
       }
       private void BuildIndexByBone(SknReader sknReader,List<SkinModelVertex> vertes)
       {
           int i = 0;
           foreach (var item in vertes)
           {
               Vector2 texCoord = Vector2.Zero;
               texCoord = texCoords[item.index];
               meshBuilder.SetVertexChannelData(textureCoordinateDataIndex,
                   texCoord);


               Vector3 normal = Vector3.Zero;
               normal = normals[item.index];
               meshBuilder.SetVertexChannelData(normalDataIndex,
                   normal);


               meshBuilder.AddTriangleVertex(positionMap);
               i++;
           }
       }
       private void StartMesh(string name)
       {
           meshBuilder = MeshBuilder.StartMesh(name);


           // Obj files need their winding orders swapped
           meshBuilder.SwapWindingOrder = true;


           meshBuilder.MergeDuplicatePositions = true;


           // Add additional vertex channels for texture coordinates and normals
           textureCoordinateDataIndex = meshBuilder.CreateVertexChannel<Vector2>(
               VertexChannelNames.TextureCoordinate(0));
           normalDataIndex =
               meshBuilder.CreateVertexChannel<Vector3>(VertexChannelNames.Normal());


           // Add each position to this mesh with CreatePosition
           positionMap = new int[positions.Count];
           for (int i = 0; i < positions.Count; i++)
           {
               // positionsMap redirects from the original positions in the order
               // they were read from file to indices returned from CreatePosition
               positionMap = meshBuilder.CreatePosition(positions);
           }
       }


       private MeshContent FinishMesh()
       {
           MeshContent meshContent = meshBuilder.FinishMesh();


           Groups without any geometry are just for transform
           //if (meshContent.Geometry.Count > 0)
           //{
           //    // Add the mesh to the model
           //   // rootNode.Children.Add(meshContent);
           //}
           else
           {
               // Convert to a general NodeContent
               NodeContent nodeContent = new NodeContent();
               nodeContent.Name = meshContent.Name;


               // Add the transform-only node to the model
               rootNode.Children.Add(nodeContent);
           }


           meshBuilder = null;


           return meshContent;
       }


    }
}


SknReader


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.InteropServices;


namespace SknImporter
{
    [StructLayout(LayoutKind.Sequential)]
    public struct SkinModelHeader
    {
        //Structure for the Header in skn files
        public int magic;
        public short numMaterials;
        public short numObjects;
    };
    [StructLayout(LayoutKind.Sequential)]
    public struct SkinModelMaterial
    {
        //Structure for a material block in skn files
        public int matIndex;


        public string name;
        public int startVertex;
        public int numVertices;
        public int startIndex;
        public int numIndices;
    };
    [StructLayout(LayoutKind.Sequential)]
    public struct SkinModelVertex
    {
        //Vertex block in skn files
        public float[] position;
        public char[] boneIndex;
        public float[] weights;
        public float[] normal;
        public float[] texcoords;
        public int index;
    };


    public struct SkinModelData
    {
        //data block in skn files
        public int numIndices;
        public int numVertices;
        public List<short> indices;
        public List<SkinModelVertex> verteces;
    };


    class SknReader
    {
        public SkinModelData modelData = new SkinModelData();
        public List<SkinModelMaterial> materialList = new List<SkinModelMaterial>();
        FileStream fileStream;
        string fpath;
        public SknReader(string path)
        {
            fpath = path;
            fileStream = System.IO.File.Open(path, FileMode.Open);


            BinaryReader reader = new BinaryReader(fileStream);


            int headerSize = Marshal.SizeOf(typeof(SkinModelHeader));
            //SkinModelHeader header =(SkinModelHeader)BytesToStruct(reader.ReadBytes(headerSize),typeof(SkinModelHeader));
            SkinModelHeader header = new SkinModelHeader();
            header.magic = reader.ReadInt32();
            header.numObjects = reader.ReadInt16();
            header.numMaterials = reader.ReadInt16();


            if (header.numMaterials == 1)
            {
                int matCount = reader.ReadInt32();
                if (matCount > 0)
                {
                    SkinModelMaterial mat = new SkinModelMaterial();
                    for (int mc = 0; mc < matCount; mc++)
                    {
                        mat.matIndex = mc;
                        mat.name = ASCIIEncoding.ASCII.GetString(reader.ReadBytes(64)).Replace("\0", "");
                        mat.startVertex = reader.ReadInt32();
                        mat.numVertices = reader.ReadInt32();
                        mat.startIndex = reader.ReadInt32();
                        mat.numIndices = reader.ReadInt32();
                        materialList.Add(mat);
                    }
                }
            }


            modelData.numIndices = reader.ReadInt32();
            modelData.numVertices = reader.ReadInt32();
            modelData.indices = new List<short>();
            modelData.verteces = new List<SkinModelVertex>();
            for (int i = 0; i < modelData.numIndices; i++)
            {
                short idx = 0;
                idx = reader.ReadInt16();
                modelData.indices.Add(idx);
            }


            for (int i = 0; i < modelData.numVertices; i++)
            {
                SkinModelVertex vertex = new SkinModelVertex();
                vertex.index = i;
                vertex.position = new float[3];
                vertex.boneIndex = new char[4];
                vertex.weights = new float[4];
                vertex.normal = new float[3];
                vertex.texcoords = new float[2];


                vertex.position[0] = reader.ReadSingle();
                vertex.position[1] = reader.ReadSingle();
                vertex.position[2] = reader.ReadSingle();


                // vertex.boneIndex = reader.ReadInt32();


                vertex.boneIndex[0] = reader.ReadChar();
                vertex.boneIndex[1] = reader.ReadChar();
                vertex.boneIndex[2] = reader.ReadChar();
                vertex.boneIndex[3] = reader.ReadChar();


                vertex.weights[0] = reader.ReadSingle();
                vertex.weights[1] = reader.ReadSingle();
                vertex.weights[2] = reader.ReadSingle();
                vertex.weights[3] = reader.ReadSingle();


                vertex.normal[0] = reader.ReadSingle();
                vertex.normal[1] = reader.ReadSingle();
                vertex.normal[2] = reader.ReadSingle();


                vertex.texcoords[0] = reader.ReadSingle();
                vertex.texcoords[1] = reader.ReadSingle();


                modelData.verteces.Add(vertex);
            }
            reader.Close();
        }
    }
}


DEMO CODE

---

---

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace LOL_MOD_DISPLAY
{
    /// <summary>
    /// 这是游戏的主类型
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Camera camera;
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";

            graphics.PreferredBackBufferWidth = 800;
            graphics.PreferredBackBufferHeight = 600;
        }

        /// <summary>
        /// 允许游戏在开始运行之前执行其所需的任何初始化。
        /// 游戏能够在此时查询任何所需服务并加载任何非图形
        /// 相关的内容。调用 base.Initialize 将枚举所有组件
        /// 并对其进行初始化。
        /// </summary>
        protected override void Initialize()
        {
            // TODO: 在此处添加初始化逻辑

            base.Initialize();

        }

        /// <summary>
        /// 对于每个游戏会调用一次 LoadContent，
        /// 用于加载所有内容。
        /// </summary>
        ///


        Model teemo;
        Texture2D texture;
        string name = "Ryze";
        protected override void LoadContent()
        {
            // 创建新的 SpriteBatch，可将其用于绘制纹理。
            spriteBatch = new SpriteBatch(GraphicsDevice);

            teemo = Content.Load<Model>(name);
            texture = Content.Load<Texture2D>(name+"_texture");
            camera = new Camera(this);
            this.Components.Add(camera);
            // TODO: 在此处使用 this.Content 加载游戏内容
        }

        /// <summary>
        /// 对于每个游戏会调用一次 UnloadContent，
        /// 用于取消加载所有内容。
        /// </summary>
        ///

        protected override void UnloadContent()
        {
            // TODO: 在此处取消加载任何非 ContentManager 内容
        }

        /// <summary>
        /// 允许游戏运行逻辑，例如更新全部内容、
        /// 检查冲突、收集输入信息以及播放音频。
        /// </summary>
        /// <param name="gameTime">提供计时值的快照。</param>
        protected override void Update(GameTime gameTime)
        {
            // 允许游戏退出
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // TODO: 在此处添加更新逻辑

            base.Update(gameTime);
        }

        /// <summary>
        /// 当游戏该进行自我绘制时调用此项。
        /// </summary>
        /// <param name="gameTime">提供计时值的快照。</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            Matrix world = Matrix.CreateWorld(new Vector3(-0, -20, -0), Vector3.UnitZ, Vector3.Up) ;

            Model model = teemo;
            Matrix[] modelTransforms = new Matrix[model.Bones.Count];
            model.CopyAbsoluteBoneTransformsTo(modelTransforms);

            foreach (ModelMesh mesh in model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.TextureEnabled = true;
                    effect.Texture = texture;
                    effect.World =Matrix.CreateTranslation(new Vector3 (0,-20,0))* Matrix.CreateRotationY((float)gameTime.TotalGameTime.TotalMilliseconds / 1000f) * modelTransforms[mesh.ParentBone.Index] * world ;
                    effect.View = camera.View;
                    effect.Projection = camera.Projection;
                }
                mesh.Draw();
            }


            // TODO: 在此处添加绘图代码

            base.Draw(gameTime);
        }
    }
}