Abstract
In many computer animation systems, the motions of the moving objects have to be calculated
at a sufficient rate to support the interactivity. Yet those motions should look natural to the
user of such a system. A method of making motions look natural is to program into the
animation system, the laws of physics which in reality govern the motions of objects. This
method of motion calculation is called dynamics.
This thesis describes the design of class library Dynamo. Dynamo users can use classes from
this library to add dynamics functionality to their own animation systems. Dynamo has been
designed completely in an object oriented fashion, allowing for interfaces that abstract from
implementation details, and for a very structured design. This benefits extendibility, understandability
and maintainability of the software. Dynamo consists of three major subsystems,
dealing with forward dynamics, controllers, and inverse dynamics, respectively.
The forward dynamics subsystem implements the calculation of the motions of (in this case,
rigid) bodies, as a function of their inertia and forces that are applied to them. The differential
equations that describe the motions are integrated over time, while accounting for the fact
that in animation systems time is modeled in a discrete manner. In Dynamo, several motion
integrators are available to a user. This allows the user to choose an appropriate balance
between computational effort and precision.
The controller subsystem provides controllers: devices that are provided with a reference
signal and try to calculate forces that steer the motions in an animation in a way that
corresponds to the reference signal. Dynamo provides several kinds of controllers, such as
controllers which model springs, and so-called PID controllers.
The inverse dynamics subsystem provides a user of Dynamo with the option of specifying
constraints on the motions of the rigid bodies. Constraints can for example be used to
connect several rigid bodies to form articulated rigid bodies. While controllers not always
instantly match the behavior of the system to the reference signal, constraints have to be
valid at all times. Constraint satisfaction is automatically performed by Dynamo, so that a
user only has to declare a constraint once to have it enforced from then on. The constraint
correction algorithms employed in Dynamo allow for a wide variety of constraints, including
non-holonomic constraints, and allow them to be combined freely, allowing for loops in the
constraint configurations. Over a dozen constraint types are available, and the software is
designed to facilitate the addition of new constraint types.
Several examples show how Dynamo can be used in a variety of application areas, and show
that Dynamo is fast enough to provide animation at interactive speeds for non-trivial systems.
They also show that systems of rigid bodies that are connected by constraints, often exhibit
emergent behavior on a system level. The high-level interfaces of Dynamo, obtained through
the object oriented approach, make it very easy to specify systems with such a complex
behavior, which can be studied through the simulation of the motions in the animation.
Original language | English |
---|---|
Qualification | Doctor of Philosophy |
Awarding Institution |
|
Supervisors/Advisors |
|
Award date | 27 Apr 2000 |
Place of Publication | Eindhoven |
Publisher | |
Print ISBNs | 90-386-0751-2 |
DOIs | |
Publication status | Published - 2000 |