Tech Memo 2002-23
Collision Handling for Interactive Garment Simulation
2002. 11. 1
오승우, 김형석 원광연
한국과학기술원 전산학과
1
본 보고서는 과학재단 지원 가상현실연구센터의 지원으로 이루어졌음.
1
Collision Handling for Interactive
Garment Simulation
Seungwoo Oh, Hyungseok Kim, Kwangyun Wohn
Virtual Reality Laboratory
Department of Electrical Engineering & Computer Science
Korea Advanced Institute of Science and Technology (KAIST)
redmong,likidas,[email protected]
Abstract. This paper deals with real-time interactive garment simulation, and focuses specifically on
collision handling between a character and garments. Because simulation speed must be kept over a certain
limit in interactive garment simulation, regardless of the speed or type of a character’s motion, a rapid and
stable collision handling method is required. For this reason, we approximate the shape of the character
model with quadric bounding volumes and handle collisions using an adaptive approach to motion speed. In
the adaptive approach, the quadric implicit function is used in slow movement and a simplified dynamic
collision detection method devised in this paper is used in fast movement. Using our simplified method is
about 10 times faster than only using static collision handling method. We also propose relative garment
simulation method that computes the garment’s deformation relative to the character’s translation for the
stable collision handling in fast translation of the character. Experimental results demonstrate that our
collision handling method work stable even though the character moves several steps or the limbs (arms and
legs) of the character move largely in two successive frames.
1.
Introduction
Garment simulation is a technique to create a garment’s deformation by using virtual
reality technology. This technique has been used in various applications including digital
movies such as ‘Shrek’ and ‘Monster’s Inc’. This paper focuses specifically on real-time
interactive garment simulation. Interactive garment simulation is a technique to create a
garment’s deformation by controlling a character or environments in real-time. It is a core
technology in virtual reality applications such as garment-related electronic commerce or
computer games in which the interactivity is very important. The final goal of our work is
to develop an interactive simulation system to be used in garment-related electronic
commerce. There are two important things, one is to create the deformation of various
garment material types and the other is to create the deformation of garments along the
character’s motion in real-time.
We focus on the latter rather than the former. We model the geometric structure and
physical property of garments in the simplest spring-mass system. We compute the force
exerted on each mass-point and then integrate the force to get the deformation. In this
process, the interaction between a character and garments, the collision, is very important
since the global deformation of garments follows the character’s motion. In interactive
garment simulation, the penetration of garments into the character must be avoided
regardless of the speed or type of the motion. The penetration problem happens more often
in time-based simulation than in frame-based simulation. For example, it is common for
the character to move several steps between two successive frames in time-based
simulation on slow hardware. Therefore, rapid and stable collision handling is critical. For
this, we propose two methods. First, to solve the penetration problem occurring in large
translation of a character, we propose a relative garment simulation method that computes
the garment’s deformation relative to the character’s translation. Second, to solve the
penetration problem occurring in large rotation of character’s segments, we propose a
method where we approximately enclose the character by quadric bounding volumes and
handle collisions using an adaptive approach to movement speed. In the adaptive approach,
a quadric implicit function is used in slow movement and a simplified dynamic collision
detection method devised in this paper is used in fast movement. Thanks to the
simplification of the dynamic collision detection, we can handle collisions very fast. These
methods were applied to the garment making and simulation system that is implemented
with Java3D. Experimental results show that our method can handle collisions stably even
though the arms or legs of a character may rotate largely at the moment of the character's
large translation.
This paper is organized as follows. Section 2 reviews related works, section 3 describes
the simulation overview, section 4 describes the relative garment simulation method,
section 5 describes garment modeling and deformation computing, section 6 deals with the
collision handling method, section 7 shows the experimental results, and section 8
concludes this paper and discusses future works.
2.
Related Work
For computing a garment’s deformation, we model its geometric structure and physical
properties, compute the forces exerted on each part of garment, and integrate the forces.
We need a physically-based model to create realistic deformation. The physically-based
model is classified into FECM (Finite Element Continuum Model) [3][8] and PSM
(Particle System Model)[2][4][5][6][9]. FECM defines the energy and the force for the
whole garment on the assumption that the garment is a continuous object such as rubber or
paper, and then computes the deformation of each part of the garment after making it
discrete using FDM or FEM. Since a linear system resulting from this process has to be
solved every simulation time, it takes a long time to compute the deformation. On the other
hand, the PSM models the garment with linked particles and computes each particle’s force
interacting with neighboring particles, so it takes a shorter time to compute the deformation
in PSM than FECM. However the deformation is very local because it is created by
interactions with neighboring particles. Because of this locality, the deformation gets more
elastic and the simulation gets less stable as the simulation time step increases. Baraff’s
method[1], exploiting implicit integration shows stable results even in large time step.
However, it is unreasonable to apply the method to a real-time simulation because it
requires solving a linear system every simulation time. To decrease the computing time,
Desbrun[4] proposed a method that is able to rapidly simulate the deformation by
precomputing the linear system through simplification, and Kang[9] simplified this method
more. However, it is unreasonable to simulate a garment composed of many particles in
these simplified methods because of simplification error[10]. Provot[6] proposed a length
correction method that corrects the length of over-lengthened springs. This method needs a
number of iterations and the convergence is not clear, however, it can make stable
simulations and can easily propagate deformations since the springs can’t be
over-lengthened. In this paper, the garment is modeled using the simplest particle system,
namely spring-mass system, and we use explicit Euler integration and Provot’s
length-correction method to compute the deformation.
One of the methods typically used to detect collisions between a character and a
garment is to test the proximity or intersection between the character model’s polygons and
the garment’s polygons[7]. This method usually has used bounding volume hierarchy
[1][11] to get more efficiency, but it is unreasonable to apply this method to the real-time
simulation because there are too many triangles and the collision detection method for
successive frames is very complex[7]. Also, it is hard to maintain consistency when the
garment penetrates into the character due to inaccurate simulation because volume
information can’t be expressed easily in polygon models. Spatial subdivision method that
subdivides 3D space or the character itself, is also applied to the garment
simulation[13][14]. It has, however, a limit in that it can’t be applied to interactive garment
simulation in the aspect of speed, and it is hard to apply to fast movement since it can only
handle collisions occurred in the current frame. Although Vassilev’s image-based collision
detection method[12] brought much elevation of speed, it requires not only hardware
assistance but also a special process for the case that the segments of a character are
overlapped. The methods referred to so far are hard to apply to real-time simulation since
they can’t deal with the collision stably during fast movement or in large time step. For
real-time collision handling, Rudomin[15] used ellipsoids that approximate the shape of a
character, and computed the deformation after making each particle move along the
ellipsoid closest to itself. Though this method removes the penetration problem, it is not
applicable to a variety of garment’s types because even the mass-points that don’t collide
are moved along the closest ellipsoid. In this paper, we approximate the shape of a
character more closely by using ellipsoids with both ends cut and spheres. We also detect
collisions accurately by using a simplified dynamic collision detection method.
Collision response is a process that deforms the shape of garment naturally, avoiding the
penetration after the collision detection. We can control the force, velocity, and position of
each part of the garment for collision response. Since the force-control method[8] controls
the garment’s form through integration, it is hard to handle the penetration in a few
simulation time steps[1]. Baraff’s method[1] is a good solution but it is unusable in
interactive garment simulation because implicit integration takes a long time to compute.
Therefore, the method directly controlling position or velocity [4][5][7] is desirable in the
aspect of the computing speed. We also adopt this approach. Since it is desirable that
collision handling process is included in integration process, we first handle the
mass-points in contact in the length-correction process, and then handle the other
mass-points completely.
3.
Simulation Overview
Interactive garment simulation is time-based simulation. Therefore we must compute
the character’s motion corresponding to the current CPU time every simulation iteration,
and create the garment’s deformation depending on it. We estimate the next simulation
time by using the computing time of the last simulation. Therefore the next simulation time
is as follows.
Tnext = Dlast + Current_CPU_Time (where, Dlast is the computing time in the last frame
and Current_CPU_Time is current CPU time.)
The character can move several steps in two successive frames in the time-based
simulation. To solve the penetration problem in large movement, we propose the relative
garment simulation method that computes the garment’s deformation relative to the
character’s translation. We assume that the garment moves attached to the character, and
then compute the garment’s deformation relative to the character considering the inertial
force and air resistance force generated by the character’s translation (this is described
fully in section 4). We simulate garments depending on the character’s motion without the
root segment’s (generally the pelvis) translation, and simply add the inertial force and air
resistance force to the simulation. This makes the simulation result easily usable for a fast
moving simulation without affecting to the stability of collision detection method and
integration method. This relative garment simulation method can be easily integrated with
pre-existing simulation methods[1][4][6][9].
The garment simulation process of this paper is as follows. 2)-5) is repeated several
times with fixed time step h allowed by this simulator between two frames. The number of
iteration is limited by pre-fixed count ICmax for the fast simulation. Therefore, if simulation
speed is slow (< 15fps), then the simulation time (iteration count ICmax * time step h) can’t
be matched with real time so that it can decrease the quality. However, since the character’s
motion is synchronized with CPU time (real time) and the global deformation of the
garment follows the character’s motion, there is just a little decrease in quality.
Figure 1. Simplification of a character and a mass-point.
1. Compute the character’s motion corresponding to Tnext. In this, each segment’s
transformation is computed. In 2)-5), the translation of the character’s root segment is
ignored.
2. Compute the internal force of a garment depending on the defined garment model, and
compute the external force of gravity, air resistance force, and so on. Also add the
inertial force and air resistance force resulting from the relative garment simulation.
3. Compute the deformation at the next simulation time through the explicit Euler
integration.
4. Repeat Provot’s length-correction process[6] so that the springs are not
over-lengthened. After the first length-correction iteration, we handle collisions of
contact mass-points, and then continue the length-correction process.
5. Handle collisions between a character and a garment completely. We handle collisions
between every bounding volume and every mass-point after enclosing the segments of
a character with several quadric bounding volumes (this is fully described in section
6).
6. Translate all mass-points equally to the translation of the character’s root segment.
4.
Relative Garment Simulation
This section describes how to compute the garment’s deformation relative to the
character’s translation. The main idea of this method is to simulate without translation of
the character and then translate the simulation result equally to the translation. To mimic a
real situation, we add artificial forces to the simulation. By employing this method, it is
possible to handle collisions regardless of the translation of a character. This makes the
time-based simulation possible.
We can assume that the garment is attached to the character and moves along it because
of the friction between the two. Therefore this situation can be simplified as shown in
Figure 1 for every mass-point. A box b is a character, p is a mass-point, and the line from p
to b is a simplified garment’s structure between p and b. v0 is the velocity of the character
at the simulation’s start, vp(t) is the velocity relative to the character, ∆x is a translation
vector, m is the mass of p, ∆t(= t1-t0) is the time step between two frames, and a(t) is the
acceleration of the character. The forces generated by the character’s translation are inertial
force and air resistance force. Therefore the force exerted on p is as follows.
F(t ) = − ma (t ) − k (v 0 + a (t )(t − t 0 )) − kv p (t ) + mg + Finternal (t )
Eq. 4-1
Where –ma(t) is inertial force, -k(v0+a(t)(t-t0)) is the air resistance force generated by
the character’s translation velocity, -kvp(t) is the air resistance force generated by p’s
velocity relative to the character, Finternal(t) is the internal forces of the garment, and mg is
gravity. To compute the exact change in position of each mass-point, we have to solve the
differential equation for t derived from Eq. 4-1. We usually assume that acceleration and
velocity are constant by first-order taylor’s series, so we can approximate vp0 to vp(t), and
v0+a0∆t/2 to v0+a(t)(t-t0). vp0(= vp(t0)) can be inferred from the last simulation result and
a0(= a(t0)) from the character’s motion data, or ∆x = v0∆t +a0∆t*∆t /2. Therefore the force
exerted on p is as follows.
F(t ) = −ma 0 − k (v 0 + a 0 ∆t / 2) − kv 0p + mg + Finternal (t 0 )
Eq. 4-2
We apply Eq. 4-2’s force to the simulation without the character’s translation, and, after
the simulation process, translate every mass-point equal to the character’s translation.
Using this relative garment simulation, it is easy to compute the friction force of colliding
mass-points since the force generated by the colliding character’s segment can be
computed directly without complex calculation. We will study how to apply the relative
simulation to computing the friction force of contact points, and extend this work to in
rotation of a character’s segment.
5.
Garment Modeling and Deformation Computing
We use Provot’s spring-mass model and deformation computing method[6]. A vertex
corresponds to a mass-point and an edge between two points corresponds to a linear spring.
The mass of each point is computed proportional to neighboring triangles’ area and density.
The garment is deformed by spring force, gravity, air resistance force, wind force, etc.
exerted on each mass-point. For the deformation computing, we compute the force exerted
on each mass-point and then integrate the force. Integration methods include explicit Euler
integration, Runge-Kutta integration, implicit Euler integration, simplified implicit Euler
integration[4][9], etc. From these we choose explicit Euler integration since it’s computing
time is the shortest. Using explicit Euler integration is the same as assuming that
acceleration and velocity are constant, thus the position at the next time step is computed
as following.
x(t 1 ) = x(t 0 + h) = x(t 0 ) + v(t 0 ) h + 0.5( F(t 0 )/m) h 2
Eq. 5-1
where h is simulation time step. Using this integration, as the time step gets larger or
exerted force gets higher, the integration error gets larger and the system is likely to
explode. Therefore it is hard to apply to the interactive garment simulation[6][4]. We use
the length-correction method[6] that shortens the over-lengthened springs after the
integration to tackle this problem. Velocity is not computed until the correction process is
finished.
(
)
v(t 1 ) = v(t 0 + h) = x correction (t 0 + h) − x (t 0 ) / h
Eq. 5-2
where xcorrection is the position after the length-correction process.
It is unclear whether this method converges or not, however, it can rapidly propagate the
deformation and remarkably decrease the oscillation of springs. For this reason, this
method has been used in many real-time garment simulations[4][9]. The length-correction
method results in more stable simulation than Vassilev’s velocity-correction method
differently from the contents in his paper[12].
Figure 2. Character model approximately enclosed by quadric bounding volumes.
6.
Collision Handling
6.1. Approximate Character Model
This paper handles the collision with a character model approximated by quadric
bounding volumes. We have implemented a simple system that allows users to create and
coordinate bounding volumes. Figure 2 shows the character model approximated by
spheres and ellipsoids with both ends cut. Since a small number of bounding volumes are
used, the collision handling process gets fast. Also, because the character’s volume is
expressed in the quadric implicit function, we can easily notice whether or not the
penetration occurs not only in slow movement but also in fast movement. The garment
deforms a little apart from the character’s surface since the character can’t be enclosed
perfectly by quadric bounding volumes. We will use more exact bounding volume such as
NURBS in future work to overcome this disadvantage.
6.2. Collision Handling
This paragraph describes how to handle collisions between mass-points and quadric
bounding volumes. We explain the collision handling method in slow movement (static
collision handling) and fast movement (dynamic collision handling) separately, and explain
how to apply these two methods to the adaptive approach. We use the quadric implicit
function for static collision handling, and a ray-quadric intersection method for dynamic
collision handling. The ray-quadric intersection method is applicable to the detection only
by using our simplification of dynamic collision detection. Our dynamic collision handling
methods detect the collision efficiently not only in translation but also in rotation of
bounding volume between two successive frames.
In this paper, we handle the collision using only mass-points, not line segments or
triangles of garments. The collision of each mass point is handled independently. As a
result, the penetration problem often occurs in fast movement. To reduce the penetration
situations, we handle the collisions of the mass-points in contact in the deformation
computing process and then completely handle the collisions after the process.
It is inefficient to test the collision in all case between every bounding volume and every
mass-point. We can quickly determine the pair of objects that will be collide with each
other using spatial or temporal coherence methods[11]. In this paper, a simple temporal
coherence method was adopted. The method caches a list of recently-collided bounding
volumes for each mass-point, and then tests collisions first with the cached bounding
volumes.
Figure 3. Left : Simplification of collision detection in fast movement including rotation..
6.2.1. Simplification of Collision Detection
Each segment of a character is in complex motion where translation is mixed with
rotation. Consequently, the dynamic collision detection for the fast movement is too
complex to be used in the interactive garment animation. To tackle this problem, we devise
an efficient dynamic collision detection method.
This method exploits a mass-point’s trajectory relative to the bounding volume’s
movement. Let’s look at Figure 3. We assume that the bounding volume translates and
rotates simultaneously, and that a mass-point moves in constant velocity. Let p0 be the
mass-point’s position at t0, p1 be at t1, e0 be the quadric at t0, and e1 be at t1. The point p will
collide with the ellipsoid at a certain position on the line segment p0p1.
The point p’s relative trajectory to quadric e1 starts at p0’ and ends at p1 where p0’ is the
position relative to e1 at t=0. The bold dotted line in Figure 3 shows the relative trajectory
which is very complex because translation is mixed with rotation. The intersection test
between the complex trajectory and the quadric requires too much computing time, so we
simplify the relative trajectory as a line. Hence the intersection of the line segment p1p0’
and the quadric e1 is the colliding position relative to the quadric e1. From this, we can also
get the absolute collision time and position. This simplification can be applied to the other
methods such as a polygon model, a voxel model or other parametric surface models. The
simplification error gets larger as the mass-point moves farther away from the quadric.
However, the simplified trajectory is equal to the original trajectory when it only translates.
Even though the quadric rotates largely, the error is very small if the mass-point moves
close to the quadric. Since the garment deforms close to the character, we can detect
collisions efficiently by exploiting this simplification. Our experiments demonstrate this
fact in Section 7.
Since the length of relative trajectory indicates the movement speed, we can use it as
criteria for a speed-adaptive approach. We use a static collision handling method if the
relative trajectory is short, and use an exact dynamic collision handling method if it is long.
The standard distance is decided according to the radius of quadric. In our experimental
results, one-eighth of the radius was appropriate.
Figure 4. Upper left : Collision handling for a sphere in slow movement. Upper right : for an ellipsoid.
Bottom : Collision handling between a quadric and mass-point in fast movement.
6.2.2. Static Collision Handling
We use the quadric implicit function for collision detection in slow movement. The
implicit function (Eq. 6-1) reports whether the mass-point is in the sphere, on the sphere, or
outside of the sphere.
2
2
2
 x  y  z
f ( x, y , z ) =   +   +   − 1
a a a
Eq. 6-1
If a mass-point is in the sphere, we pull the mass-point out of the sphere. The mass-point is
moved to the intersection of the sphere‘s surface and the line connecting the mass point
with the center of sphere (see upper left figure in Figure 4). Because we can assume the
collision is perfectly inelastic, the perpendicular velocity of the mass-point is eliminated.
For the friction effect, we modify the velocity instead of the force according to the
modified Coulomb’s law[7].
1 

p1
0
 v0 − v0 ⋅ p 
=
=
v
c
v
c
,
new
fric tangent
fric

p1
p1 

0


vnormal
0
0
1 − k f 0

≥ k f vnormal
, if vtangent
=

vtangent


else
0
,


pnew = (r + ε )
c fric
Eq. 6-2
where r is the radius of sphere, p0 and p1 is the position of mass-point at time t0 and t1
respectively, v0 is the velocity of mass-point at t0, kf is friction coefficient, and ε is epsilon
distance for stable response handling.
Collision handling with an ellipsoid is a little different from the handling with a sphere.
Since the ellipsoid is used to approximate to the segment of character, the shape of the
ellipsoid is elongated along a certain axis. In a following equation, az is larger than ax and
ay.
 x

 ax
2
  y   z
 +   + 
 
  a y   az
2
2

 = 1

Eq. 6-3
Therefore, we correct the x position and the y position in the same way as the sphere’s,
while keeping the z position (see upper right figure in Figure 4). We handle the response in
the same way as the sphere’s.
p new, x
p new, y







=


−




p 1y
= 1
px



+ ε, if p1,x > 0 
2
2
1



p
 1   y 

  +
1

 a x   a y p x 
 ,
2

 p 1z 
1 −  

 az 

ε
,
other
wise
−
2

2
1
 1   p y 

  +
1 


 ax   a y px 

 p1 
1 −  z 
 az 
2
Eq. 6-4
0
p new, x , p new, z = p 1z , v new = c fric v tangent
Since the ellipsoid with both ends cut is used (as Figure 2), we simply test whether pz1 is
in both ends or not.
6.2.3. Dynamic Collision Handling
For the collision detection in fast movement, we test the intersection of an ellipsoid and
the relative trajectory. The relative trajectory is expressed as follows.
l (α ) = p 0 + α ( p 1 − p 0 ),0 ≤ α ≤ 1
Eq. 6-5
The intersection between the relative trajectory and the ellipsoid can be found from
simultaneous equations of Eq. 6-5 and Eq. 6-3 (It is applied equally in the case of sphere).
The induced equation is Eq. 6-6 which is a second order equation about α. We solve the
equation to get two collision times, and regard the smaller value as the collision time.
2
 l x (α )   l y (α )   l z (α ) 
 +

 + 
 = 1

 
 rx   ry   rz 
2
2
Eq. 6-6
The exact collision position is obtained from the collision time as follows.
pcollide =
p 0 + α collide ( p 1 − p 0 )
p 0 + α collide ( p 1 − p 0 )
(p
0
)
+ α collide ( p1 − p 0 ) + ε , 0 ≤ α collide ≤ 1
Eq. 6-7
During the remaining time after the collision, the mass-point will be moved. It is difficult
to estimate the movement accurately because a mass-point is linked with neighboring
points[1]. Instead of accurately estimating the movement, we move the point by attaching
it to the collided bounding volume to decrease the penetration situations, and then move
the point in proportion to the remaining time as follows.
 2p
, x 2 p collide , y 2 p collide , z
v normal =  collide
,
,
2
2
 a
a
a z2
x
y

0
v new = c fric v tangent




Eq. 6-8
p new = p collide + ctime (h − hα collide )v new , 0 < ctime < 1
Where h is time step. This intersection test is accelerated by using an optimized
algorithm[16].
This collision response handling approach often causes penetration problems in very
fast movement. For more stable and accurate response handling, we have to simulate not
the velocity-based pseudo friction force, but the real friction force. In future work, we will
study how to compute friction exerted on the mass-point in this contact situation using the
relative simulation method which is described in section 4.
7.
Experimental Result
In this paper, we tested the proposed methods with the system implemented with
Java3D on a Pentium III 866Mhz PC with 256M RAM, and a Geforce 2 graphic card. First,
we demonstrate the accuracy of our dynamic collision detection method. We measured the
simplification error of the method in the situation shown in Figure 3. In this experiment, an
ellipsoid moved up by 0.1m/s and rotated counterclockwise by 90 degree/s, and a
mass-point fell by 0.5m/s, and leaned leftward by 45 degrees from various starting
positions above the ellipsoid in various time steps. The colliding position resulting from
the dynamic collision detection (6.2.3) is compared with the colliding position resulting
from the static collision detection (6.2.2) which has a 0.00001s time step (so it is very
accurate). Figure 5 shows the difference between the two positions (simplification error). If
the mass-point is close to the ellipsoid, the error is very small regardless of time step even
though the mass-point and the ellipsoid move very fast. Also, if the time step is smaller
than 0.1s, the error is very small. Figure 6 demonstrates the performance for our simplified
dynamic collision handling method. Using this method is about 10 times faster than using
the static collision handling method because far larger time step is possible though the
dynamic method itself is slower.
Table 1.
Short skirt
Computing time : R – rendering time; I – integration time; CH – collision handling time.
Number
(mass-points/
springs)
343/1275
R(sec.)
I(sec.)
CH(sec.)
Total
FPS
0.0125
0.0057
0.0141
0.0323
31
Long skirt
564/2147
0.0128
0.0122
0.0226
0.0476
21
Pants
548/2126
0.0128
0.0119
0.0241
0.0488
20.5
One-piece
672/2571
0.0133
0.0161
0.0238
0.0532
18.8
Figure 5. Simplification error. The error is difference between the colliding positions resulting from the
dynamic collision detection and the static collision detection.
Figure 6. Performance for our dynamic CH (collision handling) method. The performance is measured by
comparing the computing time with it of static collision handling method whose time step is set so adequate
that the static CH’s error (see Figure 5) is the same as the dynamic CH’s. This figure shows the performance
in the case that the distance is 145mm in Figure 6’s situation.
We draped the skirt, pants, and one-piece around the character model enclosed by 10
quadric bounding volumes (In the case of one-piece, 15 quadric bounding volumes are
used), and we simulated walking motion of a dressed character. In this experiment, the
mass was 20, the acceleration of gravity was 0.5, the spring coefficient was 10000, the
spring damp coefficient was 100, the air resistance coefficient was 20, the limit ration of
the length correction was 1%, and the friction coefficient was 0.2. Table 1 shows the
computing time in each process when 6 simulation iterations, 2 length correction iterations
and 0.04s time step were used. The results were 2-3 times slower than the results
implemented by C++ and OpenGL[17]. The penetration didn’t occur even though the
character translated by several steps/s and legs of the character rotated by 180 degrees/s.
Movie files of the results can be found at http://vr.kaist.ac.kr/~redmong.
Figure 7. Snapshots from simulations.
8.
Conclusion and Future Work
This paper dealt with interactive garment simulation where user can interact with virtual
environment in real-time. Based on related works and experiments, we modeled the
garment with Provot’s spring-mass model and created stable deformations of garments
through the length-correction process. For the collision handling that is the most important
part in the interactive garment simulation, we proposed two methods. First, we proposed
the relative garment simulation method to efficiently solve the penetration problem that
occurs in the large translation of a character. By employing this method, it is possible to
handle collisions regardless of the translation of a character. This also makes time-based
simulation possible. Second, we proposed the method where we approximately enclosed
the character with quadric bounding volumes and handled collisions using an adaptive
approach to movement speed. The efficiency of the proposed method is got from using the
simplification of dynamic collision detection. The simplified dynamic collision detection
method works well in the complex and fast motion of a character. Experimental results
show that the proposed method can handle collisions stably even though the arms and legs
of a character rotate largely at the moment of character's large translation. These methods
were applied to the garment making and simulation system implemented with Java3D. The
results show the possibility of interactive garment simulation on the web. Future works
will explore accurate contact simulation using our relative simulation method, time-critical
garment simulation (simulation LoD), multi-layered garment simulation, image based
wrinkle generation, and modeling of various garment materials.
Acknowledgments
This research was supported by VRRC (Virtual Reality Research Center) in KAIST. We also thank Credo
Interactive for supplying the model in our experiments.
Reference
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
[10]
[11]
[12]
[13]
[14]
[15]
[16]
[17]
D. Baraff, A. Witkin, Dynamic Simulation of Non-Penetrating Flexible Bodies, Computer Graphics
(SIGGRAPH’92 proceedings), Addison-Wesley, 26(2), 303-308, 1992.
Breen, David E., Donal H. House, and Michael J. Wozny. Predictiong the Drape of Woven Cloth
Using Interactiong Particles. In Computer Graphics Proceedings, Annual Conference Series,
365-372, Auguset 1994.
Carignan, Michel, Ying Yang, Nadia Magnenat Thalmann, and Daniel Thalmann. Dressing Animated
Synthetic Actors with Complex Deformable Clothes. In Computer Graphics Proceedings, Annual
Conference Series, 92-104, July 1992.
Desbrun, M. P. Schroder and A. Barr. “Interactive Animation of Structured Deformable Objects”,
Proceedings of Graphics Interface ’99, 1-8, June 1999.
Eberhardt, Bernhard Andreas Weber, and Wolfgang Strasser. A Fast, Flexible, Particle-System Model
for Cloth Draping. IEEE Computer Graphics and Applications, 16(5):52-59, September 1996.
Provot, X. Deformation Constraints in a Mass-Spring Model to Describe Rigid Cloth Behavior. Proc.
Graphics Interface, 147-154, 1995.
Provot, X. Collision and self-collision handling in cloth model dedicated to design garments. Eighth
Eurographics Workshop on Animation and Simulation Proceedings, 1997
Terzopoulos, D., j. Platt, A. Barr and K. Fleischer, Elastically Deformable Models. Computer
Graphics (Proc. SIGGRAPH), 21(4): 205-214, 1987.
Young-Min Kang, Jeong-Hyeon Choi, Hwan-Gue Cho, Do-Hoon Lee. An efficient animation of
wrinkled cloth with approximate implicit integration, The Visual Computer Journal, Springer-Verlang,
2001.
Pascal Volino, Nadia Magnenat-Thalmann. Comparing Efficiency of Integration Methods for Cloth
Animation. proceedings of CGI'01, July 2001.
M. Lin and S. Gottschalk. Collision Detection between Geometric Models: A Survey, Proc. IMA
Conference on Mathematics of Surfaces, 1998.
T. vassilev, B. Spanlang, Y. Chrysanthou, Fast Cloth Animation on Walking Avatars,
EUROGRAPHICS, 20(3) , 2001.
Mark Meyer, Gilles Debunne, Mathieu Desbrun, and Alan H. Barr. Interactive Animation of
Cloth-like Objects in Virtual Reality, The Journal of Visualization and Computer Animation, 12(1),
1-12, May 2001.
Dongliang Zhang, matthew M.F. Yuen, Collision Detection for Clothed Human Animation,
Proceedings of the Pacific Graphics, 2000.
Rudomin, I., Castillo, J., Real-Time Clothing: Geometry and Physics, WSCG, February 2002.
Tomas Moller and Eric Haines, Ray/Sphere Intersection, Real-Time Rendering, A K Peters, 295-298,
1999.
Dean Macri, Real-Time Cloth, 2000 GDC Proceedings, 2000.
( http://cedar.intel.com/cgi-bin/ids.dll/content/content.jsp?cntKey=Generic+Editorial%3a%3aclothsa
mple&cntType=IDS_EDITORIAL&catCode=0&path=11 )