Introduction

In computer graphics, things move around.
Animation is the process by which we can create these kinds of continuous motions as well as changes in shapes of objects.
Today, we are going to at some of the techniques and algorithms used for animation.
The intent is mainly to give a flavor of this area rather than to describe anything in particular depth.

Interpolation and Key Framing

The basic idea of interpolation is for an artist to specify certain important aspects of a scene to be animated, then let the computer fill in missing data needed to complete the animation.
One way to do interpolation is called keyframing.
In keyframing, the animator sketches out the animation sequence at a low-resolution set of time samples, the computer then uses smooth interpolation methods to generate the frames that are in between the artist-specified ones.
Recall we covered smooth interpolation for animation via Bezier curves last semester.
This is still one of the most popular animation techniques for movies and TV.

Which of the following statements is true?

The auxiliary neighborhood function used in converting two dimensional CSG to B-rep representation where the primitives were rectangles performed tests on the four quadrants of a point on the boundary.
If `M^0` is a cube, the number of vertices in `M^1` if Catmull Clark is being used would be 24.
The winged-edge representation supports clockwise but not counter-clockwise traversals of the edges of the faces of an object represented using it.

Skinning is a technique used to simulate the deformation of body parts in a triangle mesh.
It can be done in a vertex shader and is commonly used in video games.
To use this technique, the artist starts with an input triangle mesh describing the object in a "rest position".
Each vertex is described in object coordinates. i.e., `tilde p = vec \bb{o}^t \bb{c}`.
In a process called rigging, the artist designs a geometric skeleton and fits it to the mesh (this might be done in a tool like Blender we used last semester).
This skeleton is described as a set of bones that are connected by joints.

The skeleton gives rise to a hierarchy of subobject coordinate frames and subobject matrices.
Each of these subobject matrices represents the relationship between a frame and its "parent" frame in rest post.
For example, to describe a lower right arm join, we might have rigid matrices for the shoulder joint, `A_r`, the upper arm, `B_r`, the elbow joint `C_r`, and the lower arm, `D_r`.
The lower arm frame can be determined from the object frame via `vec bb d_r^t = vec bb o_r^t A_r B_r C_r D_r`.
We define the cumulative matrix for this bone as `N_r = A_r B_r C_r D_r`. So `vec bb d_r^t = vec bb o_r^t N_r`.
Consider some vertex with coordinates `bb c` that has been associated with the lower bone. i.e., some mesh point connected to this bone.
This point can be written as `tilde p = vec bb o^t bb c = vec bb d_r^t N_r^(-1) bb c`.
To animate this bone we can update our starting matrices to `A_n`, `B_n`, `C_n`, `D_n`. Here the subscript `n` is for "new".
This moves the lower arm frame according to the map `vec bb d_r^t => vec bb d_n^t`.

The lower arm frame update `vec bb d_r^t => vec bb d_n^t` of the last slide can be used to move the mesh point `tilde p` along with the frame.
To do this we use the update rule:
`tilde p = vec bb o^t bb c = vec bb d_r^t N_r^(-1) bb c => vec bb d_n^t N_r^(-1) bb c = vec bb o^t N_n N_r^(-1) bb c`
The eye coordinates of the transformed point are `E^(-1)ON_n N_r^(-1) bb c`. (`E` for eye frame, `O` to get into object frame)
So the modelview matrix for this vertex should be `E^(-1)ON_n N_r^(-1)`.
In this example, the mesh point moves with respect to only one bone. This is called hard skinning.

In smooth skinning, the animator is allowed to associate a vertex to more than one bone.
We apply the computation of the last slide for each bone and then blend the results together.
More specifically, we allow the animator to set, for each vertex, an array of weights `w_i`, summing to one, that specify how much the motion of each bone should affect this vertex.
During animation, we compute the eye coordinates for the vertex as:
`sum_i w_iE^(-1)O(N_n)_i(N_r)_i^(-1) bb c`,
where the `(N)_i` are the cumulative matrices for bone `i`.

Skinning can be implemented in a vertex shader.
Instead of passing a single model view matrix to the shader, we pass an array of model view matrices as a uniform variable.
The weight for each vertex are passed asatrribute variables using a vertex buffer object.
Finally, the sum from the last slide is done in the vertex shader code.

Physics gives us equations that govern the movement and evolution of objects over time.
Given input initial conditions, we can computational simulate such equations to predict how actual physical objects in the real world would move.
Physical simulation in its basic form is a predictive process: You feed in the initial conditions and out comes an animation.
It is less clear how that animation should be controlled.
Physical simulation is often used in special effects generation and in video games.

The starting equation in physical simulation is often Newton's Second Law:
`F = ma = m dot v = m ddot x`
where `F` is a force, `m` is a mass, `a` is acceleration, `v` is velocity, and `x` is position. Dots above things mean derivatives with respect to time.
The force can represent something like gravity, or the wind or a spring force, etc.
The above is an example of an ordinary differential equation (ODE) (an equation involving derivatives with respect to only one variable).
Starting from an initial condition, we can discretize this ODE and march forward in time using so called Euler Steps:
`x_(t+h) = x_t + v_t h`
`v_(t+h) = v_t + a_t h`
`a_(t+h) = (F(x_(t+h), t+h))/m`.
This process is called time integration.
In our SDL class set-up it would be done for each object in the onLoop method.
To prevent crazy things from happening in our simulation, we typically want to try to keep the change of time reasonably small.

In particle system animation, we model our scene as a set of noninteracting point-particles evolving under the equation of the last slide.
This can be used to models things such as a flowing fall of water particles or a stream of smoke particles in the air.
Typically, each particle is rendered as semitransparaent little blob or surface.