View-Dependent Control of Elastic Rod Simulation for 3D Character Animation
Yuki Koyama∗
The University of Tokyo

Takeo Igarashi†
The University of Tokyo(a) With our method(b) With our method (from a fixed view direction)(c) Without our method

Figure 1: (a) An animation of the camera moving around Bunny. His swinging ears are view-dependently simulated by our method so thatthey always have the best configurations according to each view direction. (b) The same scene from a virtual fixed view direction. (c) An
animation of the same scene without our method.

Abstract1This paper presents view-dependent control of elastic rod simulation for 3D character animation. Elastic rod simulation is often usedin character animation to generate motion of passively deforming
body parts such as hair, ear, and whiskers. Our goal is to allow artistic control of the simulation in a view-dependent way, for example
to move a hair strand so that it does not hide the eye regardless ofthe view direction. To achieve this goal, the artist defines several
example rest poses of the rod in preparation, each of which is associated with a particular view direction. In run time, the systemcomputes the current rest pose by blending the example rest poses
associated with the view directions near the current view direction,and then pulls the pose to the current rest pose. Technical contribution is in the formulation of example-based rod simulation using
view direction as an input, and an algorithm to suppress undesirable increase of momentum caused by dynamically changing rest
poses.

3D animations that look like 2D traditional cell animations (e.g. themovie 009 RE:CYBORG [2012]) have become popular thanks to theadvancement in sophisticated cartoon shading methods. In order toimitate 2D-like animations using 3D, or to realize the know-how of
2D animations in 3D, it is important to stylize contents according
to view directions; for example, Ramemacher [1999] presented amethod to change object geometry depending on the view direction.
Such view-dependent stylizations or adjustments are quite common
in creating 2D animations.

CR Categories: I.3.7 [Computer Graphics]: Three-Dimensional
Graphics and Realism—Animation;
Keywords: example-based materials, view-dependent control,
elastic simulation∗ e-mail:koyama@is.s.u-tokyo.ac.jp† e-mail:takeo@acm.org© Yuki Koyama and Takeo Igarashi, 2013. This is the author's version of the work.
It is posted here for your personal use. Not for redistribution. The definitive version
will be published in Proceedings of the ACM SIGGRAPH/Eurographics Symposiumon Computer Animation (SCA '13), and DOI will be provided after publication.

Introduction

In this paper, we present a method to control elastic rod simulation in a view-dependent way. Elastic rod simulation is often usedin character animation to generate motion of passively deforming
body parts such as hair, ear, and whiskers. The artist defines the
motion of the active body parts such as arms, legs, and head, andthe motion of these passive body parts are generated by physicalsimulation. Fig. 2(a) shows examples of elastic rods used in character animation. Physical simulation frees the artist from manuallyspecifying the motion, but at the same time makes artistic control
difficult. Our goal is allow artistic control in such a simulation process.
Our method works as follows. The artist first defines several example rest poses of the rod, each of which is associated with a particular view direction. At run time, the system computes the current rest
pose by blending the example rest poses associated with the view
directions near the current view direction. The system then runs thesimulation using the computed current rest pose. The overall framework is based on example-based materials [Martin et al. 2011], but
we present multiple extensions to make it work appropriately in our
problem setting. Specifically, we present a formulation of examplebased material for rod simulation and a method to blend example
rest poses using the view direction as an input. We also present an

(a)

(c)

rest pose

not alive. Therefore, we present an algorithm to suppress the effectthat makes the object look alive (section 4).

2(b)Figure 2: (a) Examples of elastic rods in a 3D character. (b) Examples of joint chains. (c) Examples of additional user input forour method. The input consists of an arbitrary number of (here 5)
example poses of joint chains, each of which is associated with aview direction and an extent (magnitude of its influence, here notshowed).

algorithm to suppress undesirable increase of momentum caused bydynamically changing rest poses.

1.1

Related Work

View-dependent control is considerably important, especially for creating cartoon-like highly stylized
animations. For this purpose, Rademacher [1999] proposed ViewDependent Geometry (VDG), which allows a 3D surface mesh toadapt its shape according to view directions. To achieve this, inaddition to the base surface mesh, users make additional deformed
surface meshes for each key view direction. At run time, they dynamically blend the input meshes by weights calculated from view
directions. There are some inspired view-dependent animation systems such as [Chaudhuri et al. 2004; Chaudhuri et al. 2007]. To
our knowledge, our method is the first one that attempts viewdependent control for physical simulation.
View-Dependent Control.

The concept of example-based materials was first proposed by Martin et al. [2011] based on the elastic simulation by Finite Element Method (FEM). The basic idea is,given some desired deformed poses as additional input, they define
an example manifold as a non-linear interpolation space of input
poses. This example manifold is considered a pose space of thedesired deformations, and used for calculating the rest pose of theelastic materials. Koyama et al. [2012] presented an implementation of example-based materials using shape matching dynamics [Müller et al. 2005] to achieve real-time simulation.
Example-Based Material.

Extending this concept, Schumacher et al. [2012] introduced theconcept of explicit weight control as an attractive application of
example-based materials. The original Martin et al.’s work produces passive materials, which means the blending weights are calculated by only the conditions of materials, while the weights in
explicit weight control can be calculated from any other conditions; for example, velocities, joint angles, and so on. Our idea is to
use this explicit weight control concept with the weights calculated
from view directions.
There is a method for generating locomotions of elastic objects[Coros et al. 2012], which exploits the concept of example-basedmaterials in the algorithm. Their goal is making elastic objects as
if they were alive. In our case, the targets, such as hair, are usually

User Input

Our method takes a skinned mesh as input, in which a surface meshdeforms according to the configuration (pose) of a skeleton. The
skeleton consists of active joints and passive joints in our representation. Active joints represent main body parts such as arms andlegs, and passive joints represent secondary body parts such as hairs
and ears. The artist explicitly specifies the motion of active joints(mainly by key framing), and the system computes the motion ofpassive joints via physical simulation. We group a set of connectedpassive joints together and call it as a joint chain. We assume thatthe base of a joint chain is connected to an active joint, and the endof the joint chain is not connected any joint. We also do not handle a joint chain with branches or loops. Fig. 2(b) shows examples
of joint chains. In the rest of this paper we will discuss how tocompute the motion of a joint chain.
Our method also takes an arbitrary number of view-dependent example poses for each joint chain as input (see Fig. 2(c)). Each example pose is associated with a view direction and an extent (magnitude of its influence). Note that each example represents a shape(vertex positions) of a mesh in the original VDG, while each example represents a pose of a joint chain in our method.
Given a pose of a joint chain consisting of a set of N joints, thepose P can be represented as:
P
X
Q

=
=
=

(X, Q) ,(x1 , . . . , xN ) ,(q1 , . . . , qN ) ,

(1)
(2)
(3)

where xi ∈ R3 and qi ∈ R4 are the position of the i-th particle
in Eulerian coordinates and its orientation in quaternion representation, respectively. Here, the 1st joint is attached to an active joint(base joint). Note that the positions and the orientations are represented in an absolute way, not relative to the parent joint. We omit
the scale information for our definition of poses because it is seldom used for posing; however, our method could be extended todeal with scale information if needed.
The view direction is represented as a unit 3-dimensional vectord: the direction of the camera as seen from the base joint in its
local coordinate frame. Our definition of the view direction does
not include other camera parameters such as the tilt, pan, roll, angleof view, and the distance between the camera and the model.

we denote Pj = Xj , Qj , dj , and M as the j-th
example pose, view direction, and the number of example poses,
respectively. When we use j = 0, it means the base input.

Convention.

3

View-Dependent Rod Simulation

In this section, we explain how to simulate example-based materials in real-time rod simulation controlled in a view-dependent way.
The basic idea is to exploit the concept of explicit weight control [Schumacher et al. 2012] and calculate the blending weights
similarly to VDG [Rademacher 1999]. We make non-trivial extensions to these methods to make it work appropriate in our problem setting. First, we explain how to blend the example poses inrod simulation. Second, we discuss how to compute the blending
weights from the given view direction.

(a)

(b)

!"#

compatible incompatible
Figure 3: (a) 2D and 1D examples of compatible (left) and incompatible (right) poses. Incompatible poses cannot be used inour case. (b) To blend input poses, our method use the rotations
r1 , . . . , rN −1 . Here, N = 4.

3.1

We use Oriented Particles (OP) [Müller and Chentanez 2011] as
the rod simulation framework. It can simulate elastic solid, shell,
and rod in the same framework in real time. As OP is based on
Position-Based Dynamics (PBD) [Müller et al. 2007], our method
is also implemented upon PBD. For further information of PBD,
please refer to [Bender et al. 2013]. For ensuring inextensibility ofrods, which is often expected in 3D characters’ elastic parts, we use
distance constraints presented in [Müller et al. 2007]. The definitionof local regions of OP is arbitrary in our method; if you make theregion larger, the rod becomes stiffer.
Interpolation of example poses is not a trivial problem. Martin
et al. [2011] use non-linear interpolation in their method, because
simple linear interpolation of their deformation descriptor breaks
the compatibility of the deformation, which is undesired in their
method. This non-linearity makes the computation cost expensive.
Schumacher et al. [2012] and Koyama et al. [2012] proposed methods that allow incompatible interpolated results so that they canuse simple linear interpolation, which makes their methods faster.
Fig. 3(a) shows examples of compatible and incompatible poses,
and please refer to [Schumacher et al. 2012; Koyama et al. 2012]
for details. In our case, we cannot handle incompatible interpolated
results because of the ghost force problem, which is mentioned in[Müller and Chentanez 2011]. At the same time, our interpolation
should be linear because of the computational cost, and the interpolated poses should preserve the lengths for ensuring inextensibility.
We therefore use relative rotations as the interpolation space. Using
rotations allows us to interpolate linearly, and we can always reconstruct a compatible pose from relative rotations by using forward
kinematics. Here we assume that the lengths between neighboring
joints l1 , . . . , lN −1 are constant.
Specifically, given blending weights w = (w0 , . . . , wM ), the resultof linear blending P(w) can be written as=(X(w), Q(w)) ,1$"%&'"

Figure 4: (a) Rademacher’s algorithm for calculating blending
weights from view directions. They use barycentric coordinates of atriangle as weights. (b) Our algorithm. We use Gaussian functions
on a sphere surface. Note that if the total of the Gaussian weights
is less than 1 (the white area on the sphere), we give the remaining
weight to the base pose.

i = 1, . . . , N − 1, the angle and axis of the rotation that makes the
direction of xji,i−1 into the direction of xji+1,i can be calculated as

Example-Based Rod Simulation

P(w)

!(#

$"%&'"

(4)
M

X(w)

=

LBX (w; X , . . . , X ),

(5)

Q(w)

=

LBQ (w; Q1 , . . . , QM ),(6)

where LBX means the linear blending of Xs, and LBQ means thelinear blending of Qs.
For the algorithm of LBX , we use relative rotations as interpolation space (see Fig. 3(b)). Here we denote xi,i0 = xi − xi0
for simplicity. First, for each pose j = 0, . . . , M and each jointθij = cos−1

j

j

j

j

hxi,i−1 ,xi+1,i i
kxi,i−1 kkxi+1,i k

,

eji =

j

j

j

j

xi,i−1 ×xi+1,i
kxi,i−1 ×xi+1,i k.

(7)Then, from the angle and axis, the rotation can be obtained as aquaternion
rji = cosθj
θij
+ eji sin i .
2
2

(8)

xj1,0 is constant, for example xj1,0 = (1, 0, 0), for any pose j. In
addition, we set rji directly to (1; 0, 0, 0) if |θij | <  for stability reasons. Now, our pose descriptor for interpolation can be describedasRj = (rj1 , . . . , rjN −1 ).
(9)In order to blend these descriptors with w and obtain R(w), weapply QLERP (the linear interpolations of quaternions) [Kavan andŽára 2005] for each joint. After blending, X(w) can be obtainedusing forward kinematics from R(w) and l1 , . . . , lN −1 .
In contrast to LBX , the algorithm of LBQ can be simple; Q(w)can be obtained by simply using QLERP for each joint.

3.2

View-Dependent Control

As with VDG [Rademacher 1999], we determine the blending
weights w by view directions. However, we use a different scheme
for weight computation.
In Rademacher’s algorithm, they consider a triangle mesh that covers the model, where each vertex corresponds to the input key view
direction. In runtime, the system finds a triangle enclosing the given
current view direction, and then uses its barycentric coordinates as
weights to blend example shapes (Fig. 4(a)). However, this method
is inconvenient for artists because it is necessary to cover the model
entirely with the triangle mesh (at least 4 vertices) and it is not easy
to arbitrarily change the extent (influence) of each example.
We therefore use scattered data blending for the computation ofblending weights. Given the current view direction d, the system
first computes the Gaussian weight for each example, φj (x) =exp(−(x/αj )2 ) where x is the angle between the two directions
d and dj , and αj > 0 is the user defined extent of the example (forexample, we use αj = 0.5 and 1.3 to make our results). We thenblend the example poses with these Gaussian weights. If the totalof the Gaussian weights exceeds 1, then the system modulates theweights so that total equals one. If the total is less than 1, we givethe remaining weight to the base pose P0 . Algorithm 1 describes
these computations. This algorithm returns the pose similar to Pj
when d is close to dj , and returns a pose similar to P0 when d is
far away from all examples.
Algorithm 1 Calculating weights from view directions.
1: for j = 1 to M do
2:angle ← ArcCos(DotProduct(dj , d));3:
wj ← φj (angle);
4: end for
5: sum ← w1 + · · · + wM ;6: if sum ≤ 1.0 then7:
w0 ← 1.0 − sum;
8: else9:
for j = 1 to M do
10:wj ← wj / sum;11:
end for12:
w0 ← 0.0;
13: end if

4

Figure 5: The concept of our algorithm to suppress ghost momentum. There is always an internal force (a) that pulls the current
deformed pose P towards the goal pose P(w). There is an external force (b), too. We decompose the internal force to the force thatmakes the pose move to the example manifold (c) and the force thatis caused roughly by changing the weights for blending the poses(d). Finally, we use only (b) and (c) for the velocity updates.

Suppression of Ghost Momentum

The direct application of the algorithm described in the previous
section causes ghost momentum, that is, the joint chain gains unnecessary momentum as the user changes the view direction. This
makes the joint chain look alive, which is undesirable for passive
body parts such as hairs and whiskers. A naive approach to suppress such ghost momentum is to use damping. However, it does
not work well because damping also suppresses the momentum
caused by external forces and internal forces that pull the current
pose towards the example manifold, making the entire animation
unnaturally slow and dull.
In order to selectively suppress the ghost momentum caused by thechange of the rest pose, we modify the velocity update step in the
PBD formulation. The idea is to use different preferred positions
for position updates and velocity updates. In generalized PBD for
OP [Müller and Chentanez 2011], each particle is updated by
v
x

←
←

(xp − x)/h,
xp ,

(10)
(11)

ω
q

←
←

axis(qp q−1 ) · angle(qp q−1 )/h,
qp ,

(12)
(13)

where xp , qp , h are the estimated position, orientation, and the time
step, respectively. Please refer to [Müller et al. 2007; Müller and
Chentanez 2011] for the details. In our algorithm, we replace Equation 10 and 12 withv
ω←(x0p − x)/h,

(14)

←

axis(q0p q−1 ) · angle(q0p q−1 )/h,(15)

where x0p , q0p are the newly introduced position and orientation,
which can suppress the undesired increase of momentum. Notethat the modifications are on the update of velocity v and angularvelocity ω. The position x and orientation q are updated the same
way as generalized PBD for OP.
Fig. 5 describes the concept of our algorithm. The key idea is thedecomposition of the internal elastic force into two forces: the force
that pulls the current pose P towards the nearest pose Pproj in theexample manifold, and the other force that pulls Pproj to the modified rest pose P(w). The latter force is the main cause of the ghost
momentum, so we only use the former force for velocity update.

Note that we still use P(w) for positional update so that the poseapproaches to the blended rest pose. That is, xp and qp for position
updates are computed using P(w) as the target position also considering the external forces and inertia, while x0p and q0p for velocity
updates are computed using Pproj as the target position.
Pproj is a given as a linear projection of the current pose P towards
the example manifold defined by the example poses Pj . Specifically, Pproj is defined as P(wproj ) (see Equations 4-6) and wecompute wproj as the weights that minimize a quadratic energy

w

proj

= arg min
w

where

M
X

2
k

wk R − R

,

(16)

k=0

PM

k=0 wk = 1, and it can be obtained byproj T(w1proj , . . . , wM
)

=


−1

LT L
LT R − R0 (17)w0proj=1−

M
X

wkproj(18)

k=1

where R, Rj ∈ R4(N −1) are the concatenations of the elementsof quaternions from Equation 9, and L = (R1 − R0 , . . . , RM −R0 ) ∈ R4(N −1)×M . This projection process is similar to [Koyama
et al. 2012], but these is a subtle difference in the post processing. They modify the result of projection so that it stays within theconvex combination of the examples. That is, they clamp all theweights between 0 and 1, while maintaining the total to be 1. On
the other hand, we modify the result of projection wproj so that itremains sufficiently close to the weights for the current rest pose
w. We do this to avoid visual artifacts caused by the inconsistency
between positional update (by w) and velocity update (by wproj ).
We omit the details of this implementation, but in short, we set a
sliding window around w, and force the wproj to stay within thesliding window. We also adjust the values so that the total equals to
1.
Note that all the quaternions should satisfy hq, qpivot i > 0 with apivot quaternion qpivot before the projection. We use qpivot = r01 .
If not, we replace q with −q. This is necessary for ensuring theinterpolation paths of the example manifold are the shortest ones,
analogous to QLERP [Kavan and Žára 2005].

Table 1: The conditions and performance of the animations. The
numbers put in parentheses indicate the total number of joint chains
including those simulated without our method (by pure OP). FPS
indicates the frames per second of the entire system including simulation, rendering, and so on. Note that all animations are generated
in over 60 FPS using a consumer-level laptop.
Figure 6: The top part of the character’s hair is always facing thecamera in the best configuration, even when the character moves orrotates.

model
Bunny
Front hair
Top of head#joint chains
2 (2)
3 (6)
1 (4)

#particles
8, 8
7, 5, 73

#examples
5, 5
3, 5, 1
5

FPS
60+
60+
60+

velocity. Another possibility is to avoid the use of the examplebased elasticity in the first place in order to achieve the viewdependence; for example, using direct constraints on position andvelocity based on view directions in addition to the standard elastic
rod simulation.
In this paper, we proposed a method for controlling
elastic rod simulations by view directions for real-time 3D character animations. View-dependent control could help the artists toachieve traditional 2D-like stylizations, or to adjust results of simulation more effectively according to view directions. Our method
is fast enough to be used in real-time environments such as games.
The algorithm for suppressing undesired increase of momentum is
empirically derived and lacks physical validity, but it is very practical and generates visually plausible results in our experiments.
Conclusion.

Figure 7: The front hair attempts to avoid the eyes. The top row
shows the camera view. The bottom row shows a fixed view.

5

Results and Discussions

Fig. 1, 6, and 7 show the results of our method1 . The conditions
and performance are shown in Tab. 1. Our current implementation
works on Unity [2013], and the results are exported as interactive
games. All animations are generated at over 60 FPS, but it is difficult to accurately measure the performance of each computation.
In practice, ghost momentum can be ignored when the elastic partis moving constantly, for example, being swayed by wind. In thatcase, it is better not to use our algorithm of suppression because it
doubles the computational cost.
There are several limitations in our method and implementation. Our current method cannot handle a structure thathas loops or branches. The algorithm of suppression cannot completely suppress the increase of the momentum (see the supplemental video, 01:35). View-dependent behavior is inherently incompatible with physical law, and thus our formulation lacks physicalvalidity.
Limitations.

Discussions. As we mentioned above, the suppression algorithm
cannot completely solve the problem of ghost momentum. It would
be possible to explore the alternatives to this algorithm; for example, taking view directions into account more directly for updating
1 The 3D models are provided by Blender Foundation (Fig. 1), Yamamoto (Fig. 6), and Kio (Fig. 7), and we modified them for simplicity. Big
Buck Bunny is copyrighted by Blender Foundation. c Blender Foundation.
Hatsune Miku is copyrighted by Crypton Future Media, INC. c Crypton
Future Media, INC.

Acknowledgements
We would like to thank Yasunori Harada and Nobuyuki Umetani formany useful discussions, and anonymous reviewers for their helpfulcomments. We also thank Yamamoto and Kio for their model data
and the permission for use of them, Crypton Future Media, Inc. forthe permission for use of the character, Hatsune Miku, and Blender
Foundation for the Bunny data under a Creative Commons Attribution 3.0 License. This project was funded in part by grants from theJapanese Information-Technology Promotion Agency (IPA).

References
009 RE:CYBORG P RODUCTION C OMMITTEE.
re:cyborg. http://009.re-cyb.org/.

2012.

009

B ENDER , J., M ULLER , M., OTADUY, M. A., AND T ESCHNER ,M. 2013. Position-based methods for the simulation of solid
objects in computer graphics. In EG 2013 - STARs, Eurographics
Association, 1–22.
C HAUDHURI , P., K ALRA , P., AND BANERJEE , S. 2004. A systemfor view-dependent animation. Computer Graphics Forum 23,
3, 411–420.
C HAUDHURI , P., K ALRA , P., AND BANERJEE , S. 2007. Reusing
view-dependent animation. The Visual Computer 23, 9-11, 707–
719.
C OROS , S., M ARTIN , S., T HOMASZEWSKI , B., S CHUMACHER ,C., S UMNER , R., AND G ROSS , M. 2012. Deformable objects
alive! ACM Trans. Graph. 31, 4 (July), 69:1–69:9.
K AVAN , L., AND Ž ÁRA , J. 2005. Spherical blend skinning: a realtime deformation of articulated models. In Proceedings of the2005 symposium on Interactive 3D graphics and games, ACM,
New York, NY, USA, I3D ’05, 9–16.

KOYAMA , Y., TAKAYAMA , K., U METANI , N., AND I GARASHI ,T. 2012. Real-time example-based elastic deformation. In Proceedings of the ACM SIGGRAPH/Eurographics Symposium on
Computer Animation, Eurographics Association, Aire-la-Ville,
Switzerland, Switzerland, SCA ’12, 19–24.
M ARTIN , S., T HOMASZEWSKI , B., G RINSPUN , E., AND G ROSS ,M. 2011. Example-based elastic materials. ACM Trans. Graph.
30, 4 (July), 72:1–72:8.
M ÜLLER , M., AND C HENTANEZ , N. 2011. Solid simulation withoriented particles. ACM Trans. Graph. 30, 4 (July), 92:1–92:10.
M ÜLLER , M., H EIDELBERGER , B., T ESCHNER , M., AND
G ROSS , M. 2005. Meshless deformations based on shape
matching. ACM Trans. Graph. 24, 3 (July), 471–478.
M ÜLLER , M., H EIDELBERGER , B., H ENNIX , M., AND R ATCLIFF , J. 2007. Position based dynamics. J. Vis. Comun. Image
Represent. 18, 2 (Apr.), 109–118.
R ADEMACHER , P. 1999. View-dependent geometry. In Proceedings of the 26th annual conference on Computer graphics andinteractive techniques, ACM Press/Addison-Wesley PublishingCo., New York, NY, USA, SIGGRAPH ’99, 439–446.
S CHUMACHER , C., T HOMASZEWSKI , B., C OROS , S., M ARTIN ,S., S UMNER , R., AND G ROSS , M. 2012. Efficient simulationof example-based materials. In Proceedings of the ACM SIGGRAPH/Eurographics Symposium on Computer Animation, Eurographics Association, Aire-la-Ville, Switzerland, Switzerland,
SCA ’12, 1–8.
U NITY T ECHNOLOGIES. 2013. Unity. http://unity3d.
com/.