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

 一篇通俗易懂的.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:   Frame Scene_Root { FrameTransformMatrix { 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000;; } Frame body {...   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: Mesh { 4432; -34.720058; -12.484819; 48.088928;,   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. XSkinMeshHeader { 2; 4; 35; } SkinWeights { "Bip01_R_UpperArm"; 156; 0,   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: Frame Bip01_Head { FrameTransformMatrix { 0.979775, -0.188667, -0.066683, 0.000000, 0.195389, 0.973921, 0.115333, 0.000000, 0.043184, -0.126029, 0.991086, 0.000000, 27.900173, 0.000003, 0.000000, 1.000000;; } Frame Dummy21 { FrameTransformMatrix { 1.000000, -0.000000, -0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, -0.000000, 1.000000, 0.000000, 59.615768, 0.000027, 0.000002, 1.000000;; } } }   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:   AnimationSet { Animation { AnimationKey { 4; 2; 0; 16; 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000;;, 4960; 16; 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000;;; } { Scene_Root } }...   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: Timer timer; // use timer to refresh the display Device device; // the device for DX float radius; // the radius and center of the mesh Vector3 center; AnimationRootFrame rootFrame; // the root frame object   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": void LoadAnim ( string fileName ) { MyAllocateHierarchy alloc = new MyAllocateHierarchy ( ); // build the hierarchy of frames from the x file using our alloc object rootFrame = Mesh. LoadHierarchyFromFile (fileName, MeshFlags. Managed, device, alloc, null ); radius = Frame. CalculateBoundingSphere (rootFrame. FrameHierarchy, out center ); // connect the bones the frames in the mesh AttachBones ( (MyFrame )rootFrame. FrameHierarchy ); }   "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". // // walk the tree and attach each bone // void AttachBones (MyFrame frame ) { if (frame. MeshContainer != null ) { AttachBones ( (MyMeshContainer )frame. MeshContainer ); } if (frame. FrameSibling != null ) { AttachBones ( (MyFrame )frame. FrameSibling ); } if (frame. FrameFirstChild != null ) { AttachBones ( (MyFrame )frame. FrameFirstChild ); } }   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. // // when we have a mesh container, we set its frameMatrices accordingly // void AttachBones (MyMeshContainer mesh ) { if (mesh. SkinInformation != null ) { int numBones = mesh. SkinInformation. NumberBones; // for each bone, find the frame of the same name MyFrame [ ] frameMatrices = new MyFrame [numBones ]; for ( int i = 0; i < numBones; i++ ) { MyFrame frame = (MyFrame )Frame. Find (rootFrame. FrameHierarchy, mesh. SkinInformation. GetBoneName (i ) ); if (frame == null ) throw new ArgumentException ( ); // asssign the found frame into the MeshContaienr frameMatrices frameMatrices [i ] = frame; } mesh. FrameMatrices = frameMatrices; } }   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: protected override void OnPaint ( System. Windows. Forms. PaintEventArgs e ) { // move our animation ahead (the constant 0.05 was obtained by trial and error) if (rootFrame. AnimationController != null ) rootFrame. AnimationController. AdvanceTime ( 0.05f, null ); // update all the hierarchy of frames with the new transform values UpdateFrameMatrices ( (MyFrame )rootFrame. FrameHierarchy, Matrix. Identity ); device. Clear (ClearFlags. Target | ClearFlags. ZBuffer, Color. Blue, 1.0f, 0 ); device. BeginScene ( ); // draw the animation DrawFrame ( (MyFrame )rootFrame. FrameHierarchy ); device. EndScene ( ); device. Present ( ); }   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": // // walk the tree and update the hierarchy // void UpdateFrameMatrices (MyFrame frame, Matrix parentMatrix ) { // first transform with the parent frame. Combined = frame. TransformationMatrix * parentMatrix; // if sibling, use transform with parent if (frame. FrameSibling != null ) { UpdateFrameMatrices ( (MyFrame )frame. FrameSibling, parentMatrix ); } // if child, transform with new combined matrix if (frame. FrameFirstChild != null ) { UpdateFrameMatrices ( (MyFrame )frame. FrameFirstChild, frame. Combined ); } }   "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. // // walk the tree of frames and draw each one // void DrawFrame (MyFrame frame ) { MyMeshContainer mesh = (MyMeshContainer )frame. MeshContainer; while (mesh != null ) { DrawMeshContainer (mesh ); mesh = (MyMeshContainer )mesh. NextContainer; } if (frame. FrameSibling != null ) { DrawFrame ( (MyFrame )frame. FrameSibling ); } if (frame. FrameFirstChild != null ) { DrawFrame ( (MyFrame )frame. FrameFirstChild ); } }   "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:   public class MyMeshContainer : MeshContainer { // I'm not a big fan of properties public Texture [ ] Textures = null; public int NumberAttributes = 0; public int NumberInfluences = 0; public BoneCombination [ ] BoneTable; public MyFrame [ ] FrameMatrices; public Matrix [ ] OffsetMatrices; }   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: public override MeshContainer CreateMeshContainer ( string name, MeshData meshData, ExtendedMaterial [ ] materials, EffectInstance [ ] effectInstances, GraphicsStream adjacency, SkinInformation skinInfo ) { // create the container object and set some of its properties MyMeshContainer mesh = new MyMeshContainer ( ); mesh. Name = name; int numFaces = meshData. Mesh. NumberFaces; Device dev = meshData. Mesh. Device; mesh. SetMaterials (materials ); mesh. SetAdjacency (adjacency ); // fill in the texture info Texture [ ] meshTextures = new Texture [materials. Length ]; for ( int i = 0; i < materials. Length; i++ ) { if (materials [i ]. TextureFilename != null ) { meshTextures [i ] = TextureLoader. FromFile (dev, materials [i ]. TextureFilename ); } } mesh. Textures = meshTextures; // if needed, fill in the skin info if (skinInfo != null ) { mesh. SkinInformation = skinInfo; // stores the bone offset matrix away int numBones = skinInfo. NumberBones; Matrix [ ] offsetMatrices = new Matrix [numBones ]; for ( int i = 0; i < numBones; i++ ) offsetMatrices [i ] = skinInfo. GetBoneOffsetMatrix (i ); mesh. OffsetMatrices = offsetMatrices; // Fill the skin info by calling ConvertToBlendedMesh, this generates the BoneTable meshData. Mesh = skinInfo. ConvertToBlendedMesh (meshData. Mesh, MeshFlags. Managed | MeshFlags. OptimizeVertexCache, mesh. GetAdjacencyStream ( ), out mesh. NumberInfluences, out mesh. BoneTable ); mesh. NumberAttributes = mesh. BoneTable. Length; } // use new mesh for our drawing mesh. MeshData = meshData; return mesh; }   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":   when we have a mesh container with skin info, we set the proper// blending information//void DrawMeshContainer(MyMeshContainer mesh){ if (mesh.SkinInformation != null) {Matrix[] offsetMatrices = mesh.OffsetMatrices;MyFrame[] frameMatrices = mesh.FrameMatrices; // for each subset with similar attrib, draw it for (int iattrib = 0; iattrib < mesh.NumberAttributes; iattrib++) { // set the proper world matrix for blendingBoneCombination boneCombo = mesh.BoneTable[iattrib]; for (int i = 0; i < mesh.NumberInfluences; i++) { int matrixIndex = boneCombo.BoneId[i]; // it seems when the BoneId is not -1, the matrix index is valid // where is the doc for this??? if (matrixIndex != -1) {Matrix tempMatrix = offsetMatrices[matrixIndex] *frameMatrices[matrixIndex].Combined;device.Transform.SetWorldMatrixByIndex(i, tempMatrix); } } // set the render state, material and texturedevice.RenderState.VertexBlend = (VertexBlend)boneCombo.BoneId.Length - 1;device.Material = mesh.GetMaterials()[boneCombo.AttributeId].Material3D;device.SetTexture(0, mesh.Textures[boneCombo.AttributeId]); // draw the subsetmesh.MeshData.Mesh.DrawSubset(iattrib); } }} // // when we have a mesh container with skin info, we set the proper // blending information // void DrawMeshContainer (MyMeshContainer mesh ) { if (mesh. SkinInformation != null ) { Matrix [ ] offsetMatrices = mesh. OffsetMatrices; MyFrame [ ] frameMatrices = mesh. FrameMatrices; // for each subset with similar attrib, draw it for ( int iattrib = 0; iattrib < mesh. NumberAttributes; iattrib++ ) { // set the proper world matrix for blending BoneCombination boneCombo = mesh. BoneTable [iattrib ]; for ( int i = 0; i < mesh. NumberInfluences; i++ ) { int matrixIndex = boneCombo. BoneId [i ]; // it seems when the BoneId is not -1, the matrix index is valid // where is the doc for this??? if (matrixIndex != -1 ) { Matrix tempMatrix = offsetMatrices [matrixIndex ] * frameMatrices [matrixIndex ]. Combined; device. Transform. SetWorldMatrixByIndex (i, tempMatrix ); } } // set the render state, material and texture device. RenderState. VertexBlend = (VertexBlend )boneCombo. BoneId. Length - 1; device. Material = mesh. GetMaterials ( ) [boneCombo. AttributeId ]. Material3D; device. SetTexture ( 0, mesh. Textures [boneCombo. AttributeId ] ); // draw the subset mesh. MeshData. Mesh. DrawSubset (iattrib ); } } }   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.