Game Development Reference
In-Depth Information
Most modern engine architectures do not support or utilize layered mesh de-
formations. Typically, character meshes are modified with a single smooth skin-
ning algorithm. Occasionally, this is supplemented with morph target animation
applied directly to the vertices prior to skinning. These two deformation methods
are hitting a ceiling in terms of their ability to keep pace with audience expecta-
tions.
Advancements in shading and lighting have accelerated to the point where
real-time characters look remarkably lifelike. That is, until they move. The
canned animation and rubber hose deformations in modern video games destroy
the illusion created by a modern renderer.
When characters are rendered with full subsurface scattering, ambient occlu-
sion, and high-resolution textures, the disparity between rendering and motion
quality becomes even more apparent. Believable deformations, combined with
plausible animation synthesis, are the only way we're going to fix this troubling
discontinuity.
13.2.1 A Deformer Base Class
From here on, I will refer to a deformer (to use Maya parlance) as a literal C++
function (or vertex shader, compute shader, CUDA kernel, etc.) that takes a poly-
gon mesh as input (complete with connectivity/edge data), modifies the vertex
positions according to some formula, and outputs new vertex positions.
Layered deformers are commonly employed in film and television animation.
Commercial animation packages like Maya and 3ds Max use a stack of deformers
to compute the final vertex positions. For simple deformations, this stack may
have only one deformer (usually one that calculates smooth skinning), but for
more complex animations, it's not uncommon to see five or more deformations
stacked on each other.
A good deformer base class should be designed in such a way to allow for the
concatenation of multiple types of deformers into a stack. In this arrangement,
each deformer in the stack operates on the output of the previous deformer. This
can easily be implemented using something like a linked-list data structure, where
each deformer has a pointer to the next.
When the Update() function of the first deformer is finished, it calls the
Update() function of the next deformer in the list (provided it's not at the end
of the chain), the result being that the mesh is passed through a linear series of
modifications (deformations), each of which adds some contribution to the posi-
tion of the final vertices. Conceptually, this is all very simple, but it's an important
change in the way we think about deforming meshes.
Search Nedrilad ::




Custom Search