Morphing in Action
Back in the early 90s, a revolutionary computer−graphics animation technique
known as morphing hit the big league and was brought into the mainstream, thanks
to a man known as Michael Jackson. No, I'm not referring to one of his plastic
surgery fiascos−rather, the use of morphing in one of his music videos. Yep, the
King of Pop used morphing techniques in his video for the song "Black or White"
and created an animation phenomenon that continues to this day.
In case you haven't seen the video, let me explain. It includes a segment in
which a person is grooving to the tune, and the camera is centered on that
person's face. Every few seconds, the person's face morphs into another person's
face. This continues while the face morphs more than 10 times. The results of
the morphing in the video are incredible, and I still remember them clearly to
this day!
As the years rolled by, morphing eventually made its way to gaming. Whereas
the older days of morphing involved digitally editing video footage to smoothly
change one image into another (such as in "Black or White" ), nowadays morphing
(or at least the morphing we're going to discuss here) involves the smooth
change of 3D meshes over time.
Probably the most popular example of morphing in gaming has got to be with
id's Quake. In Quake, all of the characters' animation sequences are constructed
from a series of morphing meshes. One mesh slowly changes shape to a second
mesh, the second mesh changes shape to match a third mesh, and so on.
Spaced over a short period of time and using enough meshes from which to
morph, all animation sequences are smooth and extremely easy to process. Even
the lowliest of computer systems can run Quake decently. That's because morphing
animation is extremely easy to work with, as you'll see in the next few
chapters.
So as you can surmise, morphing−or tweening, as it is sometimes referred to
(such as in the DirectX SDK)−is the process of changing one shape into another
over time. For you, those shapes are meshes. The process of morphing a mesh
involves slowly changing the coordinates of the mesh vertices, starting at one
mesh's shape and progressing to another.
The mesh that contains the orientation of the vertices at the beginning of
the morphing cycle is called the source mesh. The second mesh, which contains
the orientation of the vertices at the end of the morphing cycle, is called the
target mesh. Take a closer look at these two meshes to better understand the
whole morphing process.
Defining Source and Target Meshes
The source and target meshes you'll deal with are everyday ID3DXMesh objects.
However, you can't use just any two meshes for a morphing operation; there are
some rules to follow. First, each mesh must share the same number of vertices.
The morphing operation merely moves vertices from the source mesh positions to
match the target mesh positions. This brings up the second rule: Each vertex in
the source mesh must have a matching vertex (that is, a matching index number)
in the target mesh. Take the meshes shown in Figure 8.1 as an example.
Vertex ordering is important here. For a vertex to move from the source
position to the target position, it must share the same index number. If you
were to renumber the order, the vertices would move in the wrong direction while
morphing and produce some funky−looking results such as those shown in Figure
8.2:
As long as you design the meshes to have the same number of vertices and so
that the vertex ordering matches up, you'll do just fine. As for getting the
actual mesh data, I'll leave that in your capable hands. You can use the
D3DXLoadMeshFromX function to load your meshes. After you've got two valid
meshes loaded and ready to use, you can begin morphing them!
Morphing the Meshes
Now that you have two meshes to work with (the source and target meshes), you
can begin the morphing process. Remember that morphing is the technique of
changing one shape to another. You want the vertices in the source mesh, in
their initial positions, to gradually move to match the positions of the target
mesh's vertices.
You can measure the time period used to track the motion of the vertices from
the source mesh coordinates to the target mesh coordinates using a scalar value
(ranging from 0 to 1). With a scalar value of 0 the vertices will be positioned
at the source mesh coordinates, whereas with a scalar value of 1 the vertices
will be positioned at the target mesh coordinates. As Figure 8.3 illustrates,
any scalar value between 0 and 1 will place the vertices somewhere between the
source mesh and target mesh coordinates.
It is quite simple to calculate the coordinates in which to position a vertex
between the source mesh coordinates and target mesh coordinates. Take a vertex
from the source mesh and multiply the vertex's coordinates by the inversed
scalar value (1.0−scalar). Using the inversed scalar means that the original
vertex coordinates will use 100 percent of the vertex's coordinate position when
the scalar is at 0.0, and zero percent of the vertex's coordinate position when
the scalar is at 1.0.
Next, using the same indexed vertex's coordinates from the target mesh,
multiply the vertex's coordinates by the scalar value. Adding the two resulting
values gives you the final coordinates to use for the vertex during the morphing
animation.
At first, this concept of multiplying the vertex coordinates by a scalar
value and adding the results together might seem strange. If you're unsure of
the math, perform the following calculations to see that the results are indeed
correct. Use a one−dimensional value to represent the vertex coordinates. Set
the source vertex coordinate to 10 and the target vertex coordinate to 20. To
make things easy, use a scalar value of 0.5, which should give you a resulting
morphing vertex coordinate of 15.
Multiplying the source coordinate (10) by 1−0.5 gives you 5. Multiplying the
target coordinate (20) by 0.5 gives you 10. Adding the two results (5 and 10)
gives you 15. Isn't that special−it comes out to the correct value after all!
This procedure would resemble the following code, assuming that the vertex's
source coordinates are stored in vecSource, the target coordinates are stored in
vecTarget, and the scalar is stored in Scalar.
// vecSource = D3DXVECTOR3 with source coordinates
// vecTarget = D3DXVECTOR3 with target coordinates
// Scalar = FLOAT with scalar value
// Multiply source coordinates by inversed scalar
D3DXVECTOR3 vecSourcePos = vecSource * (1.0f−Scalar);
// Multiply target coordinates by scalar
D3DXVECTOR3 vecTargetPos = vecTarget * Scalar;
// Add the two resulting vectors together
D3DXVECTOR vecPos = vecSourcePos + vecTargetPos;
After that last bit of code, the vecPos vector will contain the coordinates
to use for positioning a vertex during the morphing animation. Of course, you
would repeat the same calculations for each vertex in the source mesh. In the
next section, you'll get to see how to perform these calculations to build your
own morphing meshes. Before that, however, I'd like to mention something about
timing your morphing animations.
Up to this point, I've been ignoring the factor of time−both the length of
the animation cycle (how long the morphing animation takes to progress from the
source coordinates to the target coordinates) and exactly what point in time you
are sampling the coordinates from in the animation sequence. Assuming you are
measuring time in milliseconds, with the animation's length stored as Length (a
FLOAT value) and the time at which you are sampling the coordinates stored as
Time (also a FLOAT value), you can compute a proper scalar value to use in your
calculations as follows:
Scalar = Time / Length;
Using the calculations you've already seen in this section, you can use the
scalar value to compute the coordinates of the vertices to build your morphing
mesh.
That's the second time I've mentioned building a morphing mesh, so I won't
keep delaying things. Read on to see how to build a morphing mesh you can use to
render. Although I previously hinted at using a vertex shader, first I will show
you the easiest way to build a morphing mesh−by manipulating the mesh's vertex
buffers directly.