Working with skeletal animation(4)
Working with Skinned Meshes
In the first half of this chapter, you learned how to manipulate a hierarchy of bones that forms the basis of skeletal animation. That's all fine and dandy, but playing with imaginary bones isn't going to cut the mustard. Your game's players need to see all your hard work in the form of rendered meshes, which is where skinned meshes come in.
Skinned meshes are almost like the standard meshes with which you are already familiar. Using a D3DXMESHCONTAINER_EX object, you can store your mesh's data, from the vertices and indices to the materials and texture data, all wrapped up in one convenient ID3DXMesh object. As for the actual skinned mesh data, that information is contained in a special object called ID3DXSkinInfo.
I'll skip the ID3DXSkinInfo introductions for the moment and instead explain what makes a skinned mesh unique to other meshes. A skinned mesh deforms to match the orientation of the underlying skeletal structure. As the bones twist and turn, so do the mesh's vertices. The mesh−s vertices make the skinned mesh unique. You'll be dealing with the changing positions of the vertices when it comes to skinned meshes.
Take a look at Figure 4.3, which shows a skeleton surrounded by a simplistic mesh.
In Figure 4.3, each vertex is connected to a bone. As a bone moves, so do the vertices that are attached to it. For example, if you were to rotate the bone 45 degrees about the x−axis, the attached vertices would rotate 45 degrees as well, with the bone's joint acting as the pivot point or the origin of the rotation.
Now take a closer look at Figure 4.3, and you'll see that a couple vertices are attached to more than one bone. That's right−you're not limited to attaching a vertex to a single bone. In fact, you can connect a vertex to as many bones as you want with DirectX. Whenever one of the bones to which the vertex is attached moves, the vertex inherits a percentage of the motion. For example, if a bone rotates 60 degrees about the z−axis, an attached vertex may inherit only 25 percent of the motion, meaning the vertex will rotate only 15 degrees about the z−axis.
The exact percentage of motion the vertex inherits is called the vertex weight. Each vertex in the skinned mesh is assigned one vertex weight per bone to which it is attached. Those weights are typically 1.0 for vertices that are attached to only one bone, meaning that the vertex inherits the full motion of the bone. The weights are divided among the bones for vertices attached to multiple bones, and are usually calculated by taking into consideration the vertex's distance from each bone. (Most 3D modeling programs will graciously
calculate this for you.) For example, suppose a vertex is attached to two bones, meaning that both weights are set to 0.5. The vertex will inherit 50 percent of the motion from each bone. Notice that the total of all weights summed must always equal 1.
The purpose of using skin weights is quite ingenious. By allowing certain bones to influence specific vertices, you can have awesome effects such as wrinkling skin, bulging muscles, and stretching clothes−all in real time as your characters animate!
The way DirectX treats the vertex weights is quite simple. After you've loaded a mesh to use as your skinned mesh and you've loaded the vertex weights (also called skin weights), you can transform the vertices to match the bones' orientations using the following steps.
1. Iterate all vertices. For each vertex, proceed to Step 2.
2. For each bone to which the current vertex is connected, get the bone transformation. For each bone transformation, multiply the matrix by the vertex's weight and apply the result to a combined transformation for the vertex.
3. Repeat Step 3 for each bone connected, and repeat Steps 2 through 4 for each vertex. When you're finished, apply the combined transformation matrix to the specific vertex being iterated (from Step 1).
How exactly do you obtain these skin weights? With the help of the ID3DXSkinInfo object I mentioned earlier, you can load the weights from an .X file. The skin weights are stored within a Mesh data object, usually at the end of the Mesh object's data.
For each bone in your skeletal structure, there is a matching SkinWeights data object. Inside the SkinWeights object is the name of the bone, followed by a number of vertices attached to it. A skinned mesh header determines the number of bones to which each vertex in the mesh can be connected. If some of the vertices are attached to two bones, then all vertices must be attached to two bones. To get around the oddity of having vertices that connect to different numbers of bones, you can assign a weight of 0 to the second bone.
As I mentioned, the SkinWeights object includes the number of vertices that are connected to the bone. It lists an array of vertex index numbers. After the array of vertex indices, there is an array of vertex weight values. Finally, there is an inversed bone transformation to help you orient the vertices around the bone's joint.
Take a look at this sample SkinWeights template data object:
SkinWeights {
"Bip01_R_UpperArm";
4;
0, 3449, 3429, 1738;
0.605239, 0.605239, 0.605239, 0.979129;
−0.941743, −0.646748, 0.574719, 0.000000,
−0.283133, −0.461979, −0.983825, 0.000000,
0.923060, −1.114919, 0.257891, 0.000000,
−65.499557, 30.497688, 12.852692, 1.000000;;
}
In this data object, a bone called Bip01_R_UpperArm is used. There are four vertices attached to the bone, and the vertex indices are 0, 3449, 3429, and 1738. Vertex 0 has a weight of 0.605239, vertex 1 has a weight of 0.605239, and so on. A transformation matrix aligns the vertices listed around the bone's joint. This matrix is very important. Without it, the vertices will rotate around the origin of the world instead of the bone's joint.
Thankfully, you don't have to deal directly with the SkinWeights templates. The data is handled for you while you are loading the skinned mesh from an .X file using the D3DX helper functions.