ABSTRACT
The purpose of this project is to create 3D
engine that displays the interaction of nonrigid bodies. As a part
of our project we researched existing models for elastic and
deformable bodies and algorithms for their collision detection and
collision response. We have created a model of the object as a set
of points connected by springs of given elasticity factor k. The
model uses spring forces and damping to give elasticity to the
objects. Object collisions are determined using our collision
detection engine. After collision occurs the response is calculated
using physics laws.
MODEL OF A SINGLE
OBJECT
 Overview
The objects we are
working with are elastic and deformable bodies. They change their
shape under the influence of outside forces and then return to
their original shapes. Considering gravity as an external force,
in the real world situation, even in a state of rest, for example
sitting on a table, this type of object will have a slight
deformation of shape and due to it the springs will not be in
equilibrium. This can be used to model objects made out of rubber,
jell, metal or other similar substances.
These objects
behave according to a set of rules commonly used in physics
models. They maintain constant velocity and shape if no external
forces are applied (Newton’s First Law). Without deformation the
object has six degrees of freedom (three for translation and three
for rotation). If an external force is applied to some part of the
object it deforms to find a state of rest where its internal
energy is balanced by its external forces. If the influence of the
force stops, the object returns to its previous shape, after any
vibrations have dampened. We will assume that objects are
nonbreakable, do not change their elasticity over time, and do
not deform permanently.
 Prior Work
Over the past two
decades, people in academia and industry have been working on
simulating physically realistic elastic objects. Different models
have been developed over time. Most of them use some kind of
elasticity rule combined with different constraints Terzopoulos
and Witkin presented the Hybrid model [4],
where an object has a reference component, which represent shape
and displacement components. These components represent a
deformation from the initial shape. In later research other models
and ideas were introduced, including the concept of local and
global deformations [5];
using extra layer coatings [8];
using elastic grids with additional constraints. Recently,
adaptive models for elastic and deformable bodies were developed;
some of them use massspring system similar to the one we used for
our project [6].
Compared to these models, our model is quite simple; however it
includes all the main factors needed to animate and provide
interaction between elastic and deformable bodies.
 Description
For our
models an object is represented as a mesh of polygons, namely
triangles. The edges of the triangles possess the physical
qualities of springs. Vertices have properties of rigid bodies
that are connected by springs. Vertices have only three degrees of
freedom – they can move in space but cannot rotate. If a distance
between two adjacent vertices shortens, the spring which connects
them forces them to move farther from each other and vice versa.
The principal idea behind our model is that each point
behaves as an independent body, or particle, and only spring
forces of its direct neighbors affect velocity and acceleration of
this point. In our model we do not maintain information about
linear and angular acceleration or the velocity of the object, and
instead we only store the accelerations and velocities of each
particle.

Physics Involved As mentioned
earlier, the main forces that move and deform the objects are the
internal spring forces of is edges. The force applied on each
vertex is calculated by the spring equation [1]:
Where k is
elasticity constant of the object and Dx is the displacement of
the length of the edge, and n is number of direct neighbors of the
vertex. Although we work in 3D, this force is calculated as
projection on 1D space of each edge.
While working with
springs the problem of damping arises. In a real world, springs do
not oscillate forever because of the loss of internal energy. In
graphics and mechanics the loss can be simulated by applying a
damping on the spring. There are several ways to do damping:
viscous damping, linear damping, or Rayleigh’s damping [1].
For this project we have chosen the viscous damping. After
including damping the formula for the force applied to each vertex
changes to the following:
Where c is
a damping constant and v is the velocity of a vertex.
The
displacement of each vertex is calculated using Newton’s Laws and
basic formulas for the motion of the body [2]:
To achieve the
best performance, some assumptions should be made about the
object. As each vertex of an object is assumed to have the same
mass, the distances between adjacent vertices should be
approximately equal to each other. So even if it is not needed for
the appearance, the mesh of the object should be equally
distributed over the object’s surface, otherwise a more
sophisticated algorithm is needed to compute mass of each vertex
so that mass of the body is uniform.

Algorithms and Other
Issues After deriving the formulas for the
vertex forces there are two problems that need to be solved:
creating a data structure for the object and applying linear
algebra for projection of 3D space to 2D or 1D.
The data
structure of the model includes a set of vertices with velocities
and accelerations for each vertex. Each vertex also holds a list
of its direct neighbors as well as the initial (rest) distances to
each of them. So in order to update the position of a vertex, we
calculate the force applied (using the difference between the
current and initial distances between the vertex and each
neighbor), then update acceleration and velocity, and finally
compute the displacement from previous position. There is also set
of faces (triangles) and edges stored for each object and are used
later for the collision detection and rendering.
The
principal advantage of our model is that natural behavior of the
elastic object can be achieved using a number of easily computed
algebraic physics equations of degree at most two. The object mesh
is easy to create using standard 3D graphics tool, for example 3D Studio Max
[13].
Note that our model does not necessarily preserve the volume of
the body. If this is desired, additional constrains must be added.
Also the elasticity constant depends on the complexity of the
object and has to be calculated for each different object. One of
the disadvantages of our model is that creating objects with no
elasticity (rigid bodies) results in strong oscillation which
damping cannot handle. For this reason, nonelastic objects are
handled by a different method.
MECHANICS
BEHIND OBJECT INTERACTION
 Overview
Given the object
model presented in the previous section, the next building block
to consider is how to combine them into a single world. One of the
factors involved in this is updating movements between objects,
namely applying the appropriate forces to each object and updating
their coordinates over some time step. Following any type of
nonpredetermined movement, some sort of collision detection
algorithm is run between all appropriate pairs of objects. If any
contact is detected, all of the information regarding the
collision must be extracted and the appropriate collision response
mechanism is applied.
Typically in complex rendering
programs or games, the objects in space would be contained in some
type of data structure, such as an octree or kdtree as proposed
by Samet [11].
Such an implementation can provide several performance gains,
including rendering of objects and limiting the pairs of objects
to which the collision test must be applied. In the rendering
process these data structures can help to determine whether an
object needs to be drawn on the screen. For example the
partitioning nature of these structures organizes spatial
information such as objects in such a way that they can determine
when other objects are very close to it or when one is occluded
behind another. These properties help when trying to decide what
objects need to be drawn or need to have complex operations
applied to them such namely collision detection. Inaccuracies in
the collision detection can arise when the time step between
screen updates is large enough that the physical forces would
place them on opposite sides of each other. To compensate for this
scenario the objects typically require being sufficiently scaled
in size or a smaller time step has to be used in the collision
detection process.
 Prior Work
There are many methods
that have been proposed for collision detection. Generally all
objects have some sort of boundary or more commonly a radius in
which they are contained within, and whenever another object comes
sufficiently near, a series of calculations are performed to see
if there was an actual collision. When dealing with convex
objects, this method works well because the object can be
simplified to a sphere or ellipse and your chances of finding a
collision are higher in an early time step. With concave objects
there is a chance that the object could be very complex and a
collision might not be found until several time steps later. To
get around this problem this idea has been taken to another level
with the use of hierarchal collision detection [12].
As the name suggests, there are layers of boundaries or radii that
have to be penetrated before a collision is detected. In the case
of concave objects this works well because, after the primary
radius has been penetrated, the collision detection is done
against the next set of radii and so forth, as necessary. This
works well when the nature of the object is sparse or has convex
substructures, because it increases the accuracy of the collision
detection while reducing the need for computationally expensive
algorithms.
When it is determined that the collision
boundary has been penetrated, it is required to be known exactly
if there was a collision and where. There are various algorithms
that can calculate this but the overall method used by most of
them is to compare all the faces or edges of one object and see if
any of them lie within the boundaries of the other object. While
simple in concept, most techniques require several floatingpoint
calculations to check against many edges and points of every
polygon in one object to the other. Typically there is a check to
see if either point of any edge in one object penetrates any
polygon in the other object. This procedure is run twice,
reversing the roles of edges and polygons between the two objects.
If this does not reveal an intersection, all the individual faces
and edges are checked to see if they are coplanar and/or
coincident. When naively implemented, this technique will still
work but can be very expensive if the object consists of a large
number of edges. In this instance some type of selection against
the object is done in order to select a minimal set of edges and
polygons to check against. For example, if the relative centers of
two objects can be determined and the two points used as a vector
and treated as the normal of a plane, then it suffices to test
only points that lie on one side of that plane. In the situation
where the objects are represented by polynomial equations, it is
common to check if the surfaces defined by these equations
intersect using any of several techniques based on integral
calculus.
After it has been determined that a collision
has occurred, we need to know where the collision has occurred and
make an appropriate response to the point of intersection. In this
stage, the need for accuracy in the location of the collision is
the driving factor for what collision information should
collected. In one case we can attempt to calculate the actual
point of collision and try to isolate all the elements involved,
such as the direction of the collision and the force being applied
at that point. At the time of collision, if it is determined that
the two objects have penetrated each other, somewhere between the
previous time step and the current step there was a point in time
when the collision first occurs. So in order to find the instance
of collision, the collision data is recalculated using a time step
that is a half of the current time step and the previous. This
process is repeated until there is collision without penetration
or until some threshold is met. While this solution provides
accuracy in the collision data, it is computationally expensive to
repeat several calculations, which can produce redundant
information between iterations. What can happen instead is that
all the information about the collision can be collected and then
approximate what the real collision information data should
be.
 Algorithms Used
In our
implementation we maintain a collection of objects, and then at
arbitrary time intervals we update their positions in space, check
for collisions and respond appropriately to them and repeat this
process as necessary [10].
For the collision detection step, we used a variation of a ray to
triangle intersection algorithm. For any two objects that we find
to be within each other’s collision boundary, we iterate over the
edges of one object and check for any intersection with any of the
planes of the triangles that make up the other object. If the edge
has been found to be crossing or touching the plane, the point of
intersection with the plane is then calculated. If that point is
contained within the triangle on that plane then we have detected
a collision. As we continue to iterate over the rest of the edges,
we mark all the edges and points of one object that were found to
have intersected the other object. Then with this set of edges, we
run a depthfirst search against the graph of the object’s
polygonal mesh to collect all the points that are contained within
the other object. Once this set is complete, we apply our
collision response system with the appropriate physics, as
described in the previous section.
IMPLEMENTATION
DETAILS
In order to
illustrate the models and algorithms we created and used, we
developed an application that takes text file of meshes and their
initial velocities as input and animates the behavior of these
objects. This application was developed using C++ under the
Microsoft Visual C++ .NET Compiler and the Standard C, OpenGL, STL
libraries and the Win32 API. The program structure is intended to be
cross platform compatible so there are areas where things such as
the timing mechanism is abstracted away into its own
object.
You can download the source code here and
text files with model meshes here.
The
most general class in our program is World, which contains list of
objects displayed on the screen (EObject). Each object has list of
faces (Triangle), edges (Edge), and points (GLPoint). The principal
functional elements of the program, including collision detection,
collision response, and each point location update can be found in
the source file EObject.cpp. In the main loop for our program, after
all models have been loaded into memory and initialized, we iterate
over our collection of objects calling an update on their movements
using the time span between the last iteration and the current as
the time step. After the updates, we check all appropriate objects
for collisions against each other. If a collision is found, we apply
the appropriate collision response mechanism for that
collision.
In Windows, the standard timing library did not
allow for precision in timing beyond seconds so we had to use the
WIN32 API to achieve greater precision. Our program uses a single
thread for execution. Rather than using the timestamps from the
system clock which would include time allocated to other programs by
the processor, we used the timestamp for the lifetime of the
thread.
CONCLUSIONS AND
SCREENSHOTS
In the project
we presented a 3D engine for the animation of nonrigid bodies. We
were able to achieve natural behavior of elastic bodies and their
collisions. Here is set of screen shots which were taken from the
engine:
Animation of multiple objects falling on the ground and
interaction with each other.
A box falling on the ground and flipping
over.
POSSIBLE FUTURE
WORK
There
are several ways to extend this project. The first is to improve
current engine. This might include adding global constraints such as
preserving object volume; optimizing the collision detection
algorithm by creating more sophisticated bounding boxes for each
object, improving the algorithm for spring damping. The other
possible direction is to use a similar system to create other types
of flexible objects, for example cloth [9] or
hair. As longer term work, it might be possible to extend our
approach to create a model for much more general classes of
substances. That would require adding more physically realistic
elements into the model, creating uniform mesh over all the volume
of the object, and finding specific constraints to satisfy
properties of different types of the material
REFERENCES
 Tongue, Benson H., “Principles of Vibration,”
1996
 Hibbeler, R. C., “Engineering mechanics.
Dynamics,” 8th ed, 1997
 Bourge, David M. “Physics for Game Developers”,
November 2001
 Terzopoulos,
D., Witkin, A, “Physically based models with rigid and deformable
components,”
Computer Graphics and Applications, IEEE, Volume:
8 Issue: 6, Nov 1988, Page(s): 41 51
 Metaxas,
D., Terzopoulos, D., ”Dynamic 3D models with local and global
deformations: deformable superquadrics,”
Pattern Analysis and
Machine Intelligence, IEEE Transactions, Volume: 13 Issue: 7, Jul
1991, Page(s): 703 714
 Barr,
A., Cani, M.P., Debunne, G., Desbrun, M.,”Adaptive simulation of
soft bodies in realtime,”
Computer Animation 2000.
Proceedings, 2000, Page(s): 15 20
 Wang,
J.F., Wang, Y.F., “Surface reconstruction using deformable models
with interior and boundary constraints,”
Computer Vision,
1990. Proceedings, Third International Conference, 47 Dec 1990,
Page(s): 300 303
 CaniGascuel,
M., Desbrun, M., “Animation of deformable models using implicit
surfaces,”
Visualization and Computer Graphics, IEEE
Transactions, Volume: 3 Issue: 1, JanMar 1997, Page(s): 39
50
 Eberhardt,
B., Strasser, W., Weber, A., “A fast, flexible, particlesystem
model for cloth draping,”
Computer Graphics and Applications,
IEEE, Volume: 16 Issue: 5, Sep 1996, Page(s): 52 59
 Miller,
Kurt “flipCode  Tutorial  Collision Detection” Jan 2000. Jul 14,
2002
 Samet, Hanan, “Design and Analysis of Spatial
Data Structures,” AddisonWesley, Reading MA.
 Ramaekers,
Marc, “Hierarchical Collision Detection Methods” May 1999. Jul 12,
2002
 “Discreet products  3ds max” http://www.discreet.com/products/3dsmax/
