程序博客网 > c语言的运算程序

一篇通俗易懂的.x文件解析+骨骼动画实现的文章

来源：互联网 发布：c语言的运算程序 编辑：程序博客网 时间：2024/05/19 00:38

 一篇通俗易懂的.x文件解析+骨骼动画实现的文章（需要国外代理看）
网址：http://www.informikon.com/various/the-simplest-skeletal-animation-possible.html
推荐代理：http://www.9i7.cn/（http://www.orzin.com/）

该站内还有一些ManagedCode环境下使用DirectShow的经验文章

The simplest skeletal animation possible    

This document presents, possibly, the simplest skeletal animation sample. A zip file with code can be found here.

Eversince I got my hands on the application Poser, I wanted to create my own utilities to do something similar. At the time, the only information in the DirectX SDK about this stuff could be found in the "SkinnedMesh sample". I recall searching the DirectX mailing list for the string "Craig Peeper" because he was the MS developer who answered the questions about this sample.

Then Jim Adams "Advanced Animation" book helped clear further the subject and Tom Miller's "KickStart" contains a chapter about skeletal animation. Since I had to refresh my mind about this stuff recently, I decided to create the simplest possible code to get "Miss Tiny" up and walking. The sample is strongly influenced by Miller's chapter. Another very good reference about skin meshes is this pdf.

Before starting to look at the code, I believe it is useful to take a look at the content of an x file with bones and animation. Only after being familiar with all the data that need to be processed, we can start to take a look at the functionality provided in the DirectX Extension library. So if you open "tiny.x" in a text editor, you'll find, after some header and template definitions, the following: 

  1.  
  2. Frame Scene_Root {
  3.  
  4. FrameTransformMatrix {
  5.  1.000000,0.000000,0.000000,0.000000,
  6.  0.000000,1.000000,0.000000,0.000000,
  7.  0.000000,0.000000,1.000000,0.000000,
  8.  0.000000,0.000000,0.000000,1.000000;;
  9.  }
  10. Frame body {...
  11.  
  

You have a "Frame" named "Scene_Root" followed by a "FrameTransformMatrix" then the beginning of another frame (named "body"). A little further, you'll find the mesh information: 

  1.  
  2. Mesh {
  3.  4432;
  4.  -34.720058;-12.484819;48.088928;,
  5.  
  

The mesh contains 4432 vertices; the coordinates for these vertices are all listed. Inside the curly braces for the mesh data, you'll find many other template instances. You'll find materials, textures, normals informations like in any other mesh but also what make a skin mesh special the "XSkinMeshHeader" which tell how many bones we can find and the "SkinWeights" template instances with information about one particular bone. 

  1.  
  2. XSkinMeshHeader {
  3.  2;
  4.  4;
  5.  35;
  6.  }
  7. SkinWeights {
  8.  "Bip01_R_UpperArm";
  9.  156;
  10.  0,
  11.  
  

Here, we have a mesh with 35 bones and the bone named "Bip01_R_UpperArm" affects 156 vertices. These bones information are contained inside the "curly braces" for the mesh object. After the mesh and its "frame object" ends, you'll find frames with the bone names, for example: 

  1.  
  2. Frame Bip01_Head {
  3.  
  4. FrameTransformMatrix {
  5.  0.979775,-0.188667,-0.066683,0.000000,
  6.  0.195389,0.973921,0.115333,0.000000,
  7.  0.043184,-0.126029,0.991086,0.000000,
  8.  27.900173,0.000003,0.000000,1.000000;;
  9.  }
  10. Frame Dummy21 {
  11.  
  12. FrameTransformMatrix {
  13.  1.000000,-0.000000,-0.000000,0.000000,
  14.  0.000000,1.000000,0.000000,0.000000,
  15.  0.000000,-0.000000,1.000000,0.000000,
  16.  59.615768,0.000027,0.000002,1.000000;;
  17.  }
  18.  }
  19.  } 
  20.  
  

These are the "TransformMatrix" for each bone. They represent the transformation that has to be apply to the vertices in order to be properly positioned with respect to the parent bone.

Closer to the end of the file, we find the animation data: 

  1.  
  2. AnimationSet {
  3.  
  4. Animation {
  5.  
  6. AnimationKey {
  7.  4;
  8.  2;
  9.  0;16;
  10.  1.000000,0.000000,0.000000,0.000000,
  11.  0.000000,1.000000,0.000000,0.000000,
  12.  0.000000,0.000000,1.000000,0.000000,
  13.  0.000000,0.000000,0.000000,1.000000;;,
  14.  4960;16;
  15.  1.000000,0.000000,0.000000,0.000000,
  16.  0.000000,1.000000,0.000000,0.000000,
  17.  0.000000,0.000000,1.000000,0.000000,
  18.  0.000000,0.000000,0.000000,1.000000;;;
  19.  }
  20.  { Scene_Root }
  21.  }...
  22.  
  

We have an "AnimationSet" followed by an "Animation". Then the "AnimationKey" applies to the "Scene_Root" frame. The "AnimationKey" has a keytype 4 (for matrix keys) with 2 keys at "time" 0 and 4960. Our code needs to handle all this data.

Now that we had a peek at the kind of data involved in skeletal animation, let's have a look at the facilities provided by DirectX to deal with such data. One of the first structure we'll encounter is the AnimationRootFrame, if you look up its documentation, you'll see only two properties: the AnimationController and the "FrameHierarchy" which is just a Frame object (a name wrapped around a transformation). The AnimationController will only be used for its AdvanceTime method which takes care of interpolation for times during the animation between keyframes. The "FrameHierarchy" property will point to the "top level" transformation in our x file.

To build this hierachy of frames will call the static method LoadHierachyFromFile of the class Mesh. One of the arguments to this method is an object of type AllocateHierarchy. This is an abstract class with two important methods: CreateFrame and CreateMeshContainer.

The method LoadHierarchyFromFile is responsible for parsing all the data in the x file. The "Create..." methods of the AllocateHierarchy object that we pass to LoadHierarchyFromFile will be called for every "Frame"s and "Mesh"es template instances found in the x file. Both of these "Create..." methods return objects derived from an abstract class; so we'll have to implement these two abstract classes by deriving new classes from Frame and MeshContainer to store the information that we need for our processing. The MeshContainer class contains some important properties: MeshData, SkinInformation The MeshData is just a structure for the mesh data found in the x file (stored in the MeshData property Mesh). The SkinInformation is used to store the information of the "SkinWeights" template instances found in the x file.

After these preliminaries, we can look at the code. We start with some standard using statement and VS-generated code. Then we found some fields: 

  1.  
  2. Timer timer; // use timer to refresh the display
  3. Device device; // the device for DX
  4.  float radius; // the radius and center of the mesh
  5. Vector3 center;
  6. AnimationRootFrame rootFrame; // the root frame object 
  7.  
  

We'll use a "Windows Form" timer to be reminded to refresh the display, we need a DirectX Device object. The "radius" and "center" variables will be used in setting the "View" and "Projection" transform. And the "rootFrame" is used to access its FrameHierarchy and AnimationController properties. After some pretty standard code for a Managed DirectX application, we call, in "InitializeGraphics", the method "LoadAnim": 

  1.  
  2. void LoadAnim(string fileName)
  3.  {
  4. MyAllocateHierarchy alloc = new MyAllocateHierarchy();
  5.  // build the hierarchy of frames from the x file using our alloc object
  6. rootFrame = Mesh.LoadHierarchyFromFile(fileName, MeshFlags.Managed,
  7. device, alloc, null);
  8. radius = Frame.CalculateBoundingSphere(rootFrame.FrameHierarchy,
  9.  out center);
  10.  // connect the bones the frames in the mesh
  11. AttachBones((MyFrame)rootFrame.FrameHierarchy);
  12.  }
  13.  
  


"LoadAnim" create our derived AllocateHierarchy object and call the static LoadHierarchyFromFile with this object for one of its arguments. This method returns our "rootFrame" object. Then we calculate the values for the variables "radius" and "center" and we call the method "AttachBones". 

  1.  
  2. //
  3. // walk the tree and attach each bone
  4. //
  5. void AttachBones(MyFrame frame)
  6. {
  7.  if (frame.MeshContainer != null)
  8.  {
  9. AttachBones((MyMeshContainer)frame.MeshContainer);
  10.  }
  11.  if (frame.FrameSibling != null)
  12.  {
  13. AttachBones((MyFrame)frame.FrameSibling);
  14.  }
  15.  if (frame.FrameFirstChild != null)
  16.  {
  17. AttachBones((MyFrame)frame.FrameFirstChild);
  18.  }
  19. }
  20.  
  

This method recursively goes through the "FrameHierarchy" and calls itself or the the method with the same name but using a MeshContainer as argument. The "AttachBones" with a MeshContainer method retrieves the bone transformations and stores it away in a field our MeshContainer derived class. If you look back at "tiny.x", you'll see that the "Frame" template instance contains the "Mesh" template instance and inside the "Mesh" template instance you find all the "SkinWeights" template instances. But after the "Frame" template instance ends, you have a bunch of "Frame" template instances wrapped around a bone name. The "AttachBones" method connect the "SkinWeight" template instance inside the "Mesh" template with the "Frame" transform of the same name. 

  1.  
  2. //
  3. // when we have a mesh container, we set its frameMatrices accordingly
  4. //
  5. void AttachBones(MyMeshContainer mesh)
  6. {
  7.  if (mesh.SkinInformation != null)
  8.  {
  9.  int numBones = mesh.SkinInformation.NumberBones;
  10.  // for each bone, find the frame of the same name
  11. MyFrame[] frameMatrices = new MyFrame[numBones];
  12.  for (int i = 0; i < numBones; i++)
  13.  {
  14. MyFrame frame = (MyFrame)Frame.Find(rootFrame.FrameHierarchy,
  15. mesh.SkinInformation.GetBoneName(i));
  16.  if (frame == null)
  17.  throw new ArgumentException();
  18.  // asssign the found frame into the MeshContaienr frameMatrices
  19. frameMatrices[i] = frame;
  20.  }
  21. mesh.FrameMatrices = frameMatrices;
  22.  }
  23. }
  24.  
  

Looking at this code, we notice that our MeshContainer derived class will need a field for an array of transform (named "FrameMatrices"). Now that we have all our matrices setup properly, we can draw our scene: 

  1.  
  2. protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
  3.  {
  4.  // move our animation ahead (the constant 0.05 was obtained by trial and error)
  5.  if (rootFrame.AnimationController != null)
  6. rootFrame.AnimationController.AdvanceTime(0.05f, null);
  7.  // update all the hierarchy of frames with the new transform values
  8. UpdateFrameMatrices((MyFrame)rootFrame.FrameHierarchy, Matrix.Identity);
  9. device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Blue, 1.0f, 0);
  10. device.BeginScene();
  11.  // draw the animation
  12. DrawFrame((MyFrame)rootFrame.FrameHierarchy);
  13. device.EndScene();
  14. device.Present();
  15.  }
  16.  
  

We override OnPaint by first calling AdvanceTime then we have to update all our transforms in the "FrameHierarchy" to reflect the new transforms in the bones. This is done with the call to "UpdateFrameMatrices": 

  1.  
  2. //
  3. // walk the tree and update the hierarchy
  4. //
  5. void UpdateFrameMatrices(MyFrame frame, Matrix parentMatrix)
  6. {
  7.  // first transform with the parent
  8. frame.Combined = frame.TransformationMatrix *
  9. parentMatrix;
  10.  // if sibling, use transform with parent
  11.  if (frame.FrameSibling != null)
  12.  {
  13. UpdateFrameMatrices((MyFrame)frame.FrameSibling, parentMatrix);
  14.  }
  15.  // if child, transform with new combined matrix
  16.  if (frame.FrameFirstChild != null)
  17.  {
  18. UpdateFrameMatrices((MyFrame)frame.FrameFirstChild, frame.Combined);
  19.  }
  20. }
  21.  
  

"UpdateFrameMatrices update the "Combined" matrix with the "parentMatrix" passed as argument. When we have a sibling transform, we update with this same "parentMatrix" and when we have a child transform, we update with the newly combined matrix. After that, we are ready to call "DrawFrame". The "DrawFrame" method is in two parts. First, we draw each mesh container with the method "DrawMeshContainer" then we just walk the tree recursively. 

  1.  
  2. //
  3. // walk the tree of frames and draw each one
  4. //
  5. void DrawFrame(MyFrame frame)
  6. {
  7. MyMeshContainer mesh = (MyMeshContainer)frame.MeshContainer;
  8.  while (mesh != null)
  9.  {
  10. DrawMeshContainer(mesh);
  11. mesh = (MyMeshContainer)mesh.NextContainer;
  12.  }
  13.  if (frame.FrameSibling != null)
  14.  {
  15. DrawFrame((MyFrame)frame.FrameSibling);
  16.  }
  17.  if (frame.FrameFirstChild != null)
  18.  {
  19. DrawFrame((MyFrame)frame.FrameFirstChild);
  20.  }
  21. }
  22.  
  

"DrawMeshContainer" is where the "real" work gets done. Before we look at the code for this method, we'll first start to look at its argument: an object of type "MyMeshContainer" which is defined as follow: 

  1.  
  2. public class MyMeshContainer : MeshContainer
  3. {
  4.  // I'm not a big fan of properties 
  5.  public Texture[] Textures = null;
  6.  public int NumberAttributes = 0;
  7.  public int NumberInfluences = 0;
  8.  public BoneCombination[] BoneTable;
  9.  public MyFrame[] FrameMatrices;
  10.  public Matrix[] OffsetMatrices;
  11. }
  12.  
  

It's just a MeshContainer with some extra data. The objects of type "MyMeshContainer" are created when we call LoadHierarchyFromFile with our AllocateHierarchy-derived object. This last object calls CreateMeshContainer whose code is next: 

  1.  
  2. public override MeshContainer CreateMeshContainer(string name,
  3. MeshData meshData, ExtendedMaterial[] materials,
  4. EffectInstance[] effectInstances, GraphicsStream adjacency,
  5. SkinInformation skinInfo)
  6.  {
  7.  // create the container object and set some of its properties
  8. MyMeshContainer mesh = new MyMeshContainer();
  9. mesh.Name = name;
  10.  int numFaces = meshData.Mesh.NumberFaces;
  11. Device dev = meshData.Mesh.Device;
  12. mesh.SetMaterials(materials);
  13. mesh.SetAdjacency(adjacency);
  14.  // fill in the texture info
  15. Texture[] meshTextures = new Texture[materials.Length];
  16.  for (int i = 0; i < materials.Length; i++)
  17.  {
  18.  if (materials[i].TextureFilename != null)
  19.  {
  20. meshTextures[i] = TextureLoader.FromFile(dev, materials[i].TextureFilename);
  21.  }
  22.  }
  23. mesh.Textures = meshTextures;
  24.  // if needed, fill in the skin info
  25.  if (skinInfo != null)
  26.  {
  27. mesh.SkinInformation = skinInfo;
  28.  // stores the bone offset matrix away
  29.  int numBones = skinInfo.NumberBones;
  30. Matrix[] offsetMatrices = new Matrix[numBones];
  31.  for (int i = 0; i < numBones; i++)
  32. offsetMatrices[i] = skinInfo.GetBoneOffsetMatrix(i);
  33. mesh.OffsetMatrices = offsetMatrices;
  34.  // Fill the skin info by calling ConvertToBlendedMesh, this generates the BoneTable
  35. meshData.Mesh = skinInfo.ConvertToBlendedMesh(meshData.Mesh, MeshFlags.Managed
  36. | MeshFlags.OptimizeVertexCache, mesh.GetAdjacencyStream(),
  37.  out mesh.NumberInfluences, out mesh.BoneTable);
  38. mesh.NumberAttributes = mesh.BoneTable.Length;
  39.  }
  40.  // use new mesh for our drawing
  41. mesh.MeshData = meshData;
  42.  return mesh;
  43.  }
  44.  
  

We'll concentrate on what is new with skin meshes. First, we assign to the property SkinInformation the argument of type "SkinInformation" passed into the method. This method gets called when we load the hierarchy from an x file. If the mesh is a skin mesh, it will contain a "XSkinMeshHeader" template instance; so we store this information away. Then the matrix at the end of each "SkinWeight" template instance is also stored away in the field "OffsetMatrices".

Now, we have to look at the call ConvertToBlendedMesh. When we add "bones" to a mesh (in a modeling application), we have vertices that are affected by more than one bone (so we have a smooth deformation when the elbow bends, for example). The method ConvertToBlendedMesh takes all the vertices and all the bones and creates a new mesh with subsets that can be drawn in a single call. Moreover, it returns a BoneCombination table that we'll use to perform "geometry blending". We define the field NumberAttibutes to be the "BoneTable" length.

We can look at the code for "DrawMeshContainer":

 

  1.  
  2. //
  3. // when we have a mesh container with skin info, we set the proper
  4. // blending information
  5. //
  6. void DrawMeshContainer(MyMeshContainer mesh)
  7. {
  8.  if (mesh.SkinInformation != null)
  9.  {
  10. Matrix[] offsetMatrices = mesh.OffsetMatrices;
  11. MyFrame[] frameMatrices = mesh.FrameMatrices;
  12.  // for each subset with similar attrib, draw it
  13.  for (int iattrib = 0; iattrib < mesh.NumberAttributes; iattrib++)
  14.  {
  15.  // set the proper world matrix for blending
  16. BoneCombination boneCombo = mesh.BoneTable[iattrib];
  17.  for (int i = 0; i < mesh.NumberInfluences; i++)
  18.  {
  19.  int matrixIndex = boneCombo.BoneId[i];
  20.  // it seems when the BoneId is not -1, the matrix index is valid
  21.  // where is the doc for this???
  22.  if (matrixIndex != -1)
  23.  {
  24. Matrix tempMatrix = offsetMatrices[matrixIndex] *
  25. frameMatrices[matrixIndex].Combined;
  26. device.Transform.SetWorldMatrixByIndex(i, tempMatrix);
  27.  }
  28.  }
  29.  // set the render state, material and texture
  30. device.RenderState.VertexBlend = (VertexBlend)boneCombo.BoneId.Length - 1;
  31. device.Material = mesh.GetMaterials()[boneCombo.AttributeId].Material3D;
  32. device.SetTexture(0, mesh.Textures[boneCombo.AttributeId]);
  33.  // draw the subset
  34. mesh.MeshData.Mesh.DrawSubset(iattrib);
  35.  }
  36.  }
  37. }
  38.  
  

We grab the "FrameMatrices" and the "OffsetMatrices" and for every subsets, we set the "world matrix" to perform "geometry blending" (there is a good discussion of this technique in the DirectX documentation). This "world matrix" is obtained by composing the transformations for the bone offset and the updated transform matrix whose index is given by the property BoneId. The BoneCombination table returned by ConvertToBlendedMesh contains an entry for each subset, and each entry has an AttributeId and a BoneId. The BoneId is an array of indexes to perform "geometry blending".

Then we set the RenderState property VertexBlend to the length of the BoneId array, and after we have set the materials and textures and we are ready to draw the corresponding subset.

This might be the simplest skeletal animation program in MDX. The program is not efficient nor robust. But it serves to illustrate the minimal amount of code needed to perform such animation in Managed DirectX.

c语言的运算程序 c语言的运算程序
原创粉丝点击
热门IT博客
linux swap分区大小linux swap分区大小
如何电话投诉淘宝卖家如何电话投诉淘宝卖家
苹果设计软件
seo搜索引擎推广
电商和微商的区别 知乎
阿里云主营业务
2钻淘宝店铺不开了
寿命试验 二型删失数据
综合性数据库包括
怎么办理网络记者证
esxi mac os 10.11
国际云计算大会
哈萨克音乐软件
mac怎么设置qq邮箱
金山毒霸网络卸载密码
中小型网络实训
印刷品制作软件
尼格罗人种知乎
网络诈骗举报平台
mac ppt自动播放设置
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 我们每日的面包 有道词典每日一句 每日一句英文 每日分享小故事 英语每日必听 英语每日一学 每日英语听力软件 每日钙摄入量 每日限行时间 每日优鲜电话 每日优鲜客服 每日所需热量计算 酷基金每日基金净值 卜易居每日一签 每日三大件报价 每日所需维生素 小学数学每日一练 每日黄金价格走势图 每日口语练习 高中生每日计划表 三年级每日一题 每日一签下载 开放式基金每日净值查询 每日工作报表 每日一则小故事 每日基金净值一览表 鸡蛋每日报价 每日英语听力 电脑 每日安全一句话 每日食盐摄入量 虚拟试衣软件 新款 虚拟试衣 天天天基金网每日净值 毐 繆毐 毐怎么读 缪毐 毒q 毒妃不乖王爷请克制 总裁有毒丫头你不乖

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里