# Morphing and Animation

Document Sample

```					Morphing and Animation
GPU Graphics
Gary J. Katz
University of Pennsylvania CIS 665

taken from
ShaderX 3, 4 and 5
And GPU Gems 1
Morphing
   Vertex Tweening – two key meshes are
blended varying by time.

   Morph Targets – vertex tweening applied only
to local displacements.
   Represent morph targets by relative vectors from
the base mesh to the target meshes
Morph Target Animation
   Morph Target Animation – one base mesh can
morph into multiple targets at the same time.
   Facial animation
   Muscle Deformation
Morph Target Animation

2   3   4   5
1                                             12     1                                      11 12
6
2                                    11                                  7   8   9 10
3                           10
4                   9
5           8
6   7

Linear Interpolation:
Relative: PositionOutput = PositionSource + (PositionDestination * Factor)
Absolute: PositionOutput = PositionSource + (PositionDestination – PositionSource)*Factor
Relative vs. Absolute
3                     < 7, 3, 9 >

4

< 4, 3, 5>

Relative              Absolute
Constraints
1.   Number of vertices must be the same
2.   Faces and attributes must be the same
3.   Material must be equal
4.   Textures must be the same
5.   Shaders, etc must be the same

Useful only where skinning fails!
Data Structures for Morphing
   DirectX allows for flexible vertex formats
   Unsure if OpenGL supports flexible formats
   Position 1 holds the relative position for the morph target
D3DVERTEXELEMENT9 pStandardMeshDeclaration[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION, 1 },

{ 0, 24, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_NORMAL, 0 },
{ 0, 32, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
}
Skeletal Animation
    Hierarchical animation
1.   Mesh vertex is attached to exactly one bone
2.   Transform vertex with the inverse of the bone’s
world matrix
    Issues
    Buckling occurs at regions where two bones are
connected
Skeletal Subspace Deformation
Vertices are attached to multiple bones by weighting
1.   Move each vertex into every associated bone space by
multiplying the inverse of the initial transformation
2.   Apply current world transformation
3.   Resulting vertices are blended using morphing
Shader Model 2.0 Approach
   Go into Dawn demo here
GPU Animation
   Can skip the processing of unused bones or morph
targets
   Need hardware support for:
   Dynamic branching
   Can separate the modification and the rendering
process
   Need hardware support for:
   Four component floating-point texture formats
   Multiple render targets
   Normal Map
   Position Map
   Tangent Map
Method 1
   Hold the vertex data in texture arrays
   Manipulate the data in the pixel shader
   Re-output to texture arrays
   Pass the output as input to vertex shader
Storage Procedures
If:
vertex array is one-dimensional
frame buffer is two-dimensional

index2D.x = index % textureWidth;
index2D.y = index / textureWidth;

index = index2D.y * textureWidth + index2D.x;
Redefining the View
Draw a rectangle of coordinates
(0,0), (0,1), (0,1), (1,1)
(-1, 1), (1,1), (-1,-1), (1,-1)
Remap them using the following vertex program

float4 VS(float4 index2D: POSITION0,
out float4 outIndex2D : TEXCOORD0) : POSITION {

outIndex2D = index2D;
return float4(2 * index2D.x – 1, -2 * index2D.y + 1, 0, 1);
}
GPU Animation Pixel Shader

float2 halfTexel = float2(.5/texWidth, .5/texHeight);
float4 PS(float4 index2D : TEXCOORD0,
out float4 position : COLOR0,
out float4 normal : COLOR1, ...)
{
index2D.xy += halfTexel;
float4 vertAttr0 = tex2Dlod(Sampler0, index2D);
float4 vertAttr1 = tex2Dlod(Sampler1, index2D);
...
...
// perform modifications and assign the final
// vertex attributes to the output registers
}
Analysis
 Keeps vertex and geometry processing units workload at a
minimum
   Why is this good?
  Good for copy operations and vertex tweening
 Per-vertex data has to be accessed through texture lookups
 Number of constant registers is less in pixel shader (224) than
 Can not divide modification process into several pieces
because only a single quad is drawn
 Therefore, Constant registers must hold all bone matrices and
morph target weights for entire object
Method 2
  Apply modifications in the vertex shader, do nothing
in the pixel shader
 Destination pixel is specified explicitly as a vertex
 Still writing all vertices to a texture
Can easily segment the modification groups
Speed issues make this method impractical
Accessing Modified Data
   Do NOT want to send the data back to the CPU, except in one case
   Solution: Direct-Render-To-VertexBuffer
   The problem:
Direct-Render-To-VertexBuffer doesn’t exist yet (but we can always dream)
   Solution 2: Transfer result from render target to vertex buffer object on
graphics card
   Use OpenGL’s ARB_pixel_buffer_object
   Solution 3: Use RenderTexture capability and then access the texture in
   Store the texture lookup in the vertices texture coordinates
   Problem:
Vertex textures are SLOW
Can not execute vertex texture lookups and other instructions in parallel
Performance Issues
   Preferable to perform modification and
rendering in single pass
   Accessing vertex attributes using vertex
texturing is always slower than performing a
fast copy within video memory
   Accessing morph in a vertex texture makes
the application too slow, must use constants
Usage
    To get real speed advantage use a hybrid CPU GPU
approach
1.   Let the CPU compute the final vertex attributes used during
rendering frames n and n+k
2.   Let the GPU perform vertex tweening at frames greater than
n and smaller than n+k
3.   Phase shift the animations between characters so that the
processors do not have peak loads
   Vertex tweening is supported on almost all hardware
   No restrictions on modification algorithms because it is performed
on CPU
Massive Character Animation
   Can perform simple AI effects
   Each pixel of output texture holds one
character’s state
   Pixel shader computes next state
   State is used to determine which animation to
use
Simulating Character Behavior
   Implement Finite State Machine in Pixel Shader

Turn

If no Obstacle          If Obstacle
If Obstacle
Walk

If Chased
Run

If Chased
Implementing an FSM on GPU
Use dependent texture lookups

   Agent-space maps: Contain information about the
state of characters (position, state, frame)
   World-space image maps: Contain information about
the environment to influence the behavior of the
character
   FSM Maps: Contain information about the behavior
for each state and about transitions between states.
   Rows group transitions within the same state
   Columns contain conditions to trigger transitions

```
DOCUMENT INFO
Shared By:
Categories:
Stats:
 views: 280 posted: 9/3/2010 language: English pages: 23
How are you planning on using Docstoc?