CGI 2008 Conference Proceedings

Bernhard Thomaszewski · Simon Pabst · Wolfgang StraßerWSI/GRIS, Universitat Tubingen, Germany

Asynchronous Cloth Simulation

Abstract This paper presents a new method for clothsimulation, which uses asynchronous variants of bothtime integration and collision handling. Implicit integra-tion methods like backward Euler and BDF-2 are verypopular in computer graphics, since they allow for fastand stable animations. However, when combined withlarge time steps, their inherent numerical dissipation re-sults in over-damped simulations, which lack high fre-quency details such as small folds and wrinkles.

In this paper, we present a computationally efficientmethod which does not suffer from these restrictions.The time integration component uses an asynchronousvariational integrator (AVI), which allows dedicated timesteps for every element. Thanks to its energy preservingnature, low-damped cloth materials can be simulatedwithout compromising dynamic motion or suppressingimportant details. Our collision handling scheme com-bines both synchronous and asynchronous strategies and,in this way, allows focusing computation power on theimportant regions where collisions actually occur. Weprovide timings for several integration methods and showthat our AVI-based scheme performs consistently betterthan synchronous explicit variants. Compared to impli-cit schemes, superior quality is obtained while remainingcomparable in terms of computation times. Finally, wedemonstrate the robustness of our method on a series ofchallenging animations.

Keywords Asynchronous Time Integration · ClothSimulation · Collision Handling · Explicit Integrators

1 Introduction

The physically-based simulation of deformable objectshas been an active research area in computer graphicsfor more than two decades. Since the work of Baraff

WSI/GRIS, Universitat TubingenTel.: +49-7071-2970425Web: www.gris.uni-tuebingen.de/∼thomaszeeMail: {thomaszewski,pabst,strasser}@gris.uni-tuebingen.de

Fig. 1 Snapshots of an obstacle-walk animation.

et al. [BW98], A-stable (or unconditionally stable) im-plicit methods like backward Euler and BDF-2 have be-come predominant in computer graphics, since they al-low fast computations when combined with large timesteps [HE01]. However, this combination is known to suf-fer from significant numerical dissipation [CK02,OAW04,VMT05]. This manifests as over-damped simulations inwhich the formation of high frequency details such assmall folds and wrinkles is suppressed (see Fig. 2, left).As a promising alternative, variational integrators likethe symplectic Euler, the Verlet scheme or the implicitmidpoint scheme exhibit excellent energy conservationproperties [HLW06]. However, these methods are notwidely used for computer animation because of their in-herent stability limitations: the time step has to be smallenough to match the stability requirements of the stiffestcomponent of the system. This is especially unfortunatewhen using unstructured meshes, where a few small ele-ments (e.g. in regions of high curvature) can drasticallylimit the global time step and thus computational effi-ciency. This situation gets even worse for collision han-dling, which in many implementations is performed onceevery time step. Although there is some room for op-timisation, it is in general not advisable to carry outcollision handling at a significantly lower frequency than

2 Bernhard Thomaszewski et al.

Fig. 2 Views of a representative frame from a 4s simulation of a low-damped textile (5016 faces). Left to right: backwardEuler (∆t 0.033s), backward Euler (∆t 0.00075s), implicit Midpoint Rule (∆t 0.001s), symplectic Euler (∆t 0.0005s), AVI(∆te 0.00037s). Notice the lack of detailed folds when using backward Euler with a large time step (left). For the computationtime, the visual quality obtained with our method (right) is better than for backward Euler (2nd from left).

time integration, since explicit methods can, unlike im-plicit schemes, usually not recover from large strains orstrain rates due to abrupt collision response. In sum-mary, the computational costs associated with standardexplicit cloth simulation make this approach less attrac-tive in practice.

In this paper, we describe how an explicit and yetcomputationally efficient method can be designed usingboth asynchronous time stepping and asynchronous col-lision handling. The time integration component uses anexplicit variant of asynchronous variational integrators[LMOW04]. Because of its symplecticity and associatedenergy conservation properties, low-damped cloth mate-rials can be simulated without compromising their dy-namic character (see Fig. 1) or suppressing importantdetails such as small folds and wrinkles (see Fig. 2, left).Furthermore, the AVI scheme automatically distributescomputation power by assigning a dedicated elementaltime step to every element according to local stabilityrequirements. This is especially advantageous when ma-terials of different stiffness are used or when the meshhas differently sized elements. In order to further im-prove the stability and performance of the method weuse element-based strain and strain rate limiting. Thisenables us to use softer materials and thus larger timesteps without affecting the realism of the simulation.

Our collision handling scheme overcomes the abovementioned problems using a three-stage strategy, whichcombines both synchronous and asynchronous techniques.A global (synchronous) detection pass determines poten-tially colliding elements at equidistant instants in time,defined by a global detection step size. The second andcomputationally most intensive phase is tightly coupledto the element updates during asynchronous time inte-gration. Here, fast geometric proximity tests are appliedto the potentially colliding triangle pairs obtained in thefirst phase and impulse-based responses are generatedwhen necessary. Finally, the third, global pass ensuresthat no collisions are missed during a global detectionstep. We further exploit the flexibility of AVIs to selec-tively reduce elemental times steps in critical situations,when sudden character motion or high-velocity collisionsthreaten to destabilise the animation.

An advantage of this approach is that, due to thecomparably small elemental time steps, the resolution atwhich collision handling is carried out is much higherthan for implicit integrators with large time steps. Still,the computational burden is significantly lower as whenusing standard explicit integration with collision han-dling after every global time step. As a result, stableand intersection-free simulations are obtained even forcomplex scenarios with multi-layer self-collisions and lowinter-layer distance. Since this is achieved without exces-sive damping, the vivid character and lively motion ofcloth is preserved (see Fig. 1). Before we start the de-tailed exposition of our method we briefly comment onprevious and related research.

1.1 Related Work

In the early work of Terzopolous et al. [TPBF87] im-plicit integration was used for simulating the dynamicsof elastically deformable objects. Because this was com-monly believed to be too expensive, explicit integrationmethods like the Symplectic Euler (or Euler-Cromer)[VCMT95] or the 4th order Runge-Kutta scheme [EWS96]were preferred subsequently. In 1998 Baraff et al. [BW98]introduced a semi-implicit integration scheme for solvingthe linearised equations of motion. Its superior stabilityallowed using large time steps, which leads to fast com-putations. Subsequent work identified poor accuracy andunrealistically high damping as a shortcoming of semi-implicit schemes and suggested solving the full nonlin-ear equations [HE01], using higher order implicit meth-ods such as BDF-2 [CK02], or extracting the dampingof rotation-modes explicitly [OAW04]. Recent work alsoconsidered the Newmark scheme [BMF03,GHDS03], theimplicit midpoint rule [VMT05] and other variational in-tegrators for computer animation [KYT+06]. A differentapproach to variational time integration has been pre-sented by Lew et al. [LMOW04], who derived a fullyasynchronous scheme based on discrete Lagrangian me-chanics.

Collision handling is a well studied field in computergraphics field and literature is abundant. We thereforerefer the reader to the overview compiled by Teschneret al. [THM+05]. For cloth simulation, bounding vol-ume hierarchies (BVH) based on e.g. k-Dops [MKE03]

Asynchronous Cloth Simulation 3

are commonly used to accelerate the proximity detec-tion. The collision response which prevents intersectionsis usually based on constraints, forces or, as in our case,impulses (see [BFA02]).

There are only a few works concerned with asyn-chronous physically-based simulation in computer graph-ics. Celes [Cel98] describes an approach for simulatingmulti-body systems in which different bodies move withdifferent time-steps. The method described in [DGC04]is based on a similar idea but also accounts for sim-ple inter-object collisions. To our knowledge, the methodpresented in this work is the first to consider the asyn-chronous treatment of elemental collisions for highly de-formable objects.

The rest of this paper is organised as follows. Thenext section is a brief description of explicit AVI schemeby Lew et al. [LMOW04], which we included for thereader’s convenience. The subsequent section presentsour mechanical model including AVI-specific extensions.Our approach to asynchronous collision handling is de-tailed in section 4 and the paper concludes with Sec. 5,in which the performance of this approach is evaluated.

2 Asynchronous Time Stepping Framework

The most distinguishing aspect of AVIs is that they al-low each element to have its dedicated time step anddo not impose restrictions with respect to neighbouringelements. Unlike in conventional synchronous methods,with each element having a potentially different timestep, the nodes of the mechanical system evolve asyn-chronously in time as can be seen in Fig. 3. It is there-fore necessary to keep track of both elemental and nodaltimes. The figure also shows a further aspect of the AVI

Fig. 3 A 1D-chain containing 3 elements with different stepsizes is fixed at one point and subjected to gravity. Left : thenumber of times an element is updated depends on its stepsize. Right : element activations over time are indicated bytheir associated colours.

scheme: the time dimension is discretised with events,each corresponding to the activation of an element. Anelement becomes active whenever the continuous flowof time reaches a point at which, according to its lo-cal step size, the element has to be updated. Obviously,for maintaining causality, the order of elemental updatesis of paramount importance. A convenient and efficient

data structure to enforce this causality algorithmically isa priority queue. We provide a brief version of the updatealgorithm described in the original work [LMOW04], alsoindicating the extensions we made:

Algorithm 1 AVI Outline1: //Initialization:2: for i = 1 to nelem do3: compute elemental time step ∆te,i

4: push element (i; ∆te,i) into queue5: end for6: //Main loop7: while queue is not empty do8: (i; te,i) ⇐ queue.pop() //get top element from queue9: for j = 1 to 3 do

10: xi,j = xi,j + vi,j(te,i − ti,j) //Update positions11: ti,j = te,i //Update nodal times12: checkAndHandleCollisions()

13: vi,j = vi,j −∆te,i∂Ve,i

∂xi,j/mi,j //Update velocities

14: limitStrainAndStrainRate()15: end for16: if (te,i + ∆te,i) ≤ tend then17: queue.push(i, (te,i + ∆te,i))18: end if19: end while

Here, the subscript (e, i) refers to quantities relatedto element i and (i, j) indicates a variable related to itsjth node. Moreover, ∆te,i is the elemental time step andm(i,j) are corresponding nodal masses. In the initializa-tion stage (ll.2-5) a time step is computed for each el-ement according to the Courant criterion (see Sec. 3)and the elements are inserted into the queue. Duringthe main simulation loop the element which has to beupdated next is retrieved from the top of the priorityqueue (l.8). The three nodal positions are then updatedusing the current velocities (l.10) and nodal times areset to the current element time (l.11). Subsequently, theenergy stored during the previous time step is releasedby applying impulses to the element thus changing itsnodal velocities (l.13). Finally, if the end of the simu-lation is not yet reached, the element is rescheduled forevaluation (l.16) using the elemental time step (which, infact, does not need to stay constant over time). In orderto create geometry output, a snapshot of the system isgenerated in a regular manner. This is done by extrap-olating the nodal positions to the global time using thecurrent velocities.

3 Mechanical Model and Extensions for AVI

Our simulator for deformable objects is built upon non-linear continuum mechanics [BW97] with a Total La-grangian formulation of linear Finite Elements for dis-cretisation [Bat96]. Deformations of thin structures cangenerally be decomposed into membrane and bendingcomponents and we organise the following descriptionaccordingly.

4 Bernhard Thomaszewski et al.

Membrane Model The in-plane behaviour of our simula-tor is based on a nonlinear variant of the constant straintriangle (CST) [Bat96]. For a deformed CST element,the elastic forces (i.e. the gradients of strain energy withrespect to nodal positions) needed in l.12 of Alg. 1 areobtained as follows. We first compute the deformationgradient F as

Fij = ΣkdNk,jxk,i (1)

where xk,i are current nodal positions and dNk,j are thepartial derivatives of the element’s three linear shapefunctions with respect to reference coordinates. The non-linear Green strain then follows as E = 1

2 (FT F−I), withI denoting the identity. From this we obtain the secondPiola-Kirchhoff stress tensor as S = C : E, where C is theelasticity tensor describing the material. Using a simpleisotropic St. Venant-Kirchhoff material [BW97], we haveS = λ(E11 + E22)I + 2µE, where λ and µ are the Lameconstants. S (and also E) is a symmetric 2 × 2 tensor,which is stored as a 3-vector S for computational conve-nience. The nodal elastic forces are finally obtained as

fk = ∂Ve

∂xk= FBT

k SA0 , (2)

where A0 is the area of the undeformed triangle andBk is the 2× 3 strain-displacement matrix whose entriesconsist of the shape function derivatives for node k. Theadvantage of this model is that all involved quantitiesare easy to evaluate and, due to the non-linear strainmeasure, no rotations need to be explicitly extracted.

Although the explicit variational integrator excels atlong term energy conservation, one will most likely wantto add a small amount of dissipation for practical ani-mations. In this case the Lagrange D’Alembert Principlehas to be used, which extends the Lagrangian theory todissipative and forced systems (see [KMOW00]). We im-plement energy dissipation as viscous stress, which in ourcase is a linear function of the strain rate. Since we useonly low damping, the resulting viscous forces are smallerthan the elastic forces and stability is not affected.

Bending Model There are several alternatives to integratebending resistance into the AVI framework. The mostaccurate way is to augment the elastic potential in Eq.(2) with a thin-shell energy. In this way, both membraneand bending forces could be evaluated at the same timeusing a single element type. However, thin shell solu-tions from engineering are notoriously complex and leadto higher computational costs. As a more efficient alter-native, discrete bending energies as used in computergraphics like [GHDS03], [BMF03] or [BWH+06] seemattractive. For our implementation we chose to modelbending directly as an external force and follow the for-mulation of Bridson et al., which is particularly simple.Here, a bending element is defined by two adjacent tri-angles (forming a hinge). Evaluating the bending forcesacting on the nodes of a given triangle requires the evalu-ation of all hinge elements which share at least one node

Fig. 4 Connectivity for bend force computation. Left : 24hinge elements have influence on the membrane triangle (cen-tre), defining a 22-triangle neighbourhood. Right : the simpli-fied force computation considers only immediate neighbours.

with the triangle. Since elements in this neighbourhoodgenerally have different times, their positions have to besynchronised to the current element time, first. As canbe seen in Fig. 4, the bending connectivity of a trianglewith regular neighbourhood extents over 22 triangles and21 nodes. Synchronizing and evaluating forces over thislarge neighbourhood is an expensive process. We there-fore choose a simplified bending force computation whichonly considers the three hinge elements corresponding tothe edges of the membrane triangle. This approach is ina way similar to the bending element described e.g. in[FO01], which can be shown to capture all curvature di-rections. As a result, we obtain a simple and accurateway to implement bending forces at low computationalcosts, which integrates seamlessly with the membraneforce computation.

It should be noted that we implicitly assumed thatbending forces never become the limiting factor for sta-bility, which is true for cloth, but not for general thinshell materials with high bending stiffness. In this case,separate hinge elements with their own dedicated timestep should be employed.

Time Step Selection and Stability For explicit integrationschemes, stability is only guaranteed when certain con-ditions on the time step are met. The critical time stepbeyond which stability is threatened can be determinedusing the Courant-Friedrich-Lewy (CFL) condition (seee.g. [Bat96]). For the specific case of linear-elastic mate-rials, it is common to use an estimate of the form

∆tcr,i = α hi

√ρ/(λ + 2µ) , (3)

where hi is related to the size of element i (its inter-nal radius) and α is a scalar (usually 0 < α < 1). TheLame constants λ and µ describe an isotropic materialand ρ denotes the mass density. This condition requiresthat the elemental time step should be less than thetime it takes a material wave to pass the element. Obvi-ously, a less stiff material allows taking larger time steps.Textiles usually exhibit a highly nonlinear stress-strainrelationship, which can be roughly characterised as bi-phasic: the stretch resistance for small deformations isonly weak but becomes very stiff for large strains. Hence,using a soft material for the small deformation range isa reasonable approach if it is possible to reliably pre-vent large deformations, which are unphysical anyway.A computationally efficient way to do so was presented

Asynchronous Cloth Simulation 5

by Provot [Pro95] who used geometric elongation cor-rection, or strain limiting. This approach has proven ef-ficient for computer animations and was adopted e.g. in[BFA02], who extended it to strain rate limiting. A dif-ferent approach was recently proposed by Goldenthal etal. [GHF+07] who used implicit constraints to enforceinextensiblity.

Algorithm 1 offers a very simple way to integratestrain and strain rate limiting (see l.14). We first de-fine two thresholds εc and εn, which, depending on theamount of deformation, indicate when to active strain(e.g. εc,lim = 10%) and strain rate (e.g. εn,lim = 7.5%)limiting. Having computed new positions and updatedvelocities for an element, we compute the current strainεc, the strain rate ε, and the predicted next strain εn =εc + ∆teε for the edges of the element. We apply strainrate limiting impulses whenever εn > εn,lim. In the rarecases when εc > εc,lim we additionally correct positionsgeometrically.

For synchronous integrators deformation limiting isusually implemented as multiple correction passes overthe edges of the mesh. As pointed out e.g. in [BFA02], aproblem arising in this context is the biasing caused bythe fixed ordering of the edges. Although randomizationcan help alleviate this concern, it may also have a neg-ative effect on convergence. Especially for unstructuredmeshes, bias is very unlikely to occur in the asynchronousimplementation, since there is no static element order-ing. Due to the relatively small elemental time steps, asingle correction step after each element update is suffi-cient to enforce e.g. a strain limit of 10% in the first testscene, showing a low average strain of only 1.2% (see Fig.2). In practice, this method allows taking larger averagetime steps and, depending on the actual scene, signifi-cant accelerations (5 times and higher) can be achieved.It should, however, be noted that this technique can-not entirely replace the physical membrane model sinceit dissipates energy from the system and degrades theaccuracy of the simulation. It rather complements thephysical model and helps to maintain stability in criticalsituations when energy conservation is a lesser concernanyway.

4 Asynchronous Collision Handling

In most practically interesting scenarios, cloth collideswith other objects in the environment and with itself.It is therefore necessary to account for collision detec-tion and response in the asynchronous framework. Thesimplest method would be to synchronise the system (inanalogy to how frames are generated) and invoke a stan-dard collision handling scheme at regular intervals. Asmentioned in the introduction, stability reasons call forsmall intervals, which lead to high computation times. Asa consequence we choose to integrate collision handlingdirectly into the asynchronous update scheme.

Fig. 5 Complicated multi-layer self-collisions are reliably re-solved using our 3-stage collision handling pipeline. The rib-bon consists of 8000 faces.

4.1 Algorithm

The asynchronous collision handling scheme builds upontechniques commonly used in standard approaches as[BFA02]. Bounding volume hierarchies are used to quicklydetect potentially colliding close face pairs (cfp). Thesecfps are subsequently checked for actual proximity usinggeometric distance tests. If a cfp passes this test, it is de-composed into elementary edge-edge and vertex-trianglecollisions. These elementary collisions are then used tocompute stopping impulses, which prevent any imminentintersection.

The asynchronous handling scheme is organised intothree stages. The pre- and post-handling stage act glob-ally on the synchronised system state using a dedicatedcollision time step ∆tc (usually 0.01s). The second stage,which is coupled with the element update scheme, han-dles the actual collisions asynchronously. The followingparagraphs explain each of these stages in more detail.

Pre-Handling Stage The task of this stage is to detect anycfps that may potentially collide in the interval [t, t + ∆tc].Here, a conservative scheme that captures collisions asrobustly as possible is preferred. To this end, we first up-date the BVH using the current nodal positions. We thencompute candidate positions at the time t + ∆tc usinga simple explicit integration step. These candidate posi-tions are then used to enlarge the BVH, i.e. to extendthe bounding volumes (BVs) in such a way that they in-clude both initial and candidate positions. This is donefor both deformable and rigid moving objects. The globalcollision detection step yields a list of cfps valid for theentire interval [t, t + ∆tc] and its entries are mapped tothe corresponding elements of the cloth object.

Asynchronous Collision Handling Upon activation of anelement its nodal positions are first updated according toalgorithm 1, l.10. If the list of potentially colliding facesfor this element is empty the algorithm proceeds as usual.

6 Bernhard Thomaszewski et al.

However, if there are close faces in the list, the computednodal positions are reconsidered as candidate positionsfor the subsequently invoked local collision handling step.For every close element in the list, its nodal positions arefirst synchronised with the time of the current element.Subsequently, a geometric distance computation is car-ried out. If the distance is smaller than a user suppliedthreshold value, elementary collisions are created and ap-propriate responses are computed. In order to speed upthe response calculation (involving 9 edge-edge and 6vertex-triangle pairs) we use elementary bounding vol-umes for quickly ruling out pairs whose distance exceedsthe threshold. Stopping impulses that prevent imminentintersections and repelling impulses that push too closeelements apart are then generated for both of the faces(in the case of self or inter-cloth collisions) as describedin [BFA02]. After all elements in the list have been pro-cessed, the changed velocities of the current element areused to compute its final nodal positions for this updatestep.

Post-Handling Stage Even with a conservative detectionapproach there might still be collisions left that have notbeen captured by the first stage or could not be resolvedin the second one. For a robust collision handling schemeit is indispensable to have a fail-safe post-processing stepwhich reliably resolves any collisions remaining at theend of interval [t, t + ∆tc]. For this purpose, we carryout an additional collision detection step which is iden-tical to the first stage, except that the candidate posi-tions are now known from the asynchronous simulationstage. A continuous collision detection and handling passis then applied iteratively until all remaining collisionsare resolved. Corrections made in this third stage can beconsidered as rather strict interventions since, unlike theresponses computed in the second stage, they can con-stitute a rough discontinuity in the simulation. However,the second stage is usually capable of resolving almostall of the collisions, leaving no or very little work to dofor the third stage.

Continuous Geometric Culling The number of cfps de-tected in the first stage can become very high for com-plicated scenarios, thus slowing down simulation. Thissituation can be significantly improved using the factthat usually only a small fraction of the detected cfpsare actually handled subsequently. We therefore carryout an additional continuous geometric culling step afterthe first stage, which tests for every cfp whether the lin-early extrapolated trajectories of the involved triangles(determined by their initial and candidate positions) ac-tually intersect. If this is not the case, they are prunedfrom the input list for the second stage. The geometricintersection test is very fast and since it is applied onlyin the broad phase (i.e. once every collision time step)it does not have a significant impact on overall perfor-mance. Yet, the improvement in the ratio between de-tected and actually handled cfps can be significant: for

our ribbon test scene (Fig. 5) we obtained an averageculling rate of roughly 55% (see Fig. 6).

Fig. 6 Culling efficiency and incurred approximation errorfor the ribbon scene. Left : percentage of actually handledclose face pairs in the asynchronous phase over time. right :number of close face pairs missed in the asynchronous stage,which have to be handled by the third pipeline stage.

As can be seen in the right diagram of Fig. 6 the num-ber of cfps that are missed in the asynchronous stage isslightly higher when using culling. However, this value isstill very small compared to the number of asynchronouslyhandled collision and all of these remaining pairs can beresolved in the third stage.

Preventing Instabilities in Collision Response When sud-den character motion or high-velocity impacts occur, thecollision response can lead to large strains and strainrates which threaten to destabilise the simulation. Mostcases can be handled using the strain and strain ratelimiting described in Sec. 3. In cases of excessive defor-mation, which we define as εn > 2·εn,lim, we additionallyreduce the step size such that the condition holds for thenew time step. Although the number of times that thiscorrection needs to be applied is usually small, it is stillan important component for stable simulation.

Discussion There are situations in which it is not enoughto check only the element that is currently updated forcollisions. By advancing the particular element forwardin time adjacent elements are automatically affected andcollisions might be introduced without being noticed. Weare aware of this issue, but since a complete collisioncheck of the element’s entire neighbourhood would dras-tically increase computation costs, we leave this to thethird stage. In practice, this decision does not have anegative effect on the robustness of our scheme. Finally,since we use large collision time steps of 0.01-0.05 sec-onds, the computational costs for the global pre- andpost-handling stages become negligible and most of thecomputation time is spent on the actual asynchronoushandling.

Asynchronous Cloth Simulation 7

Integrator Timestep Tsolve

backward Euler 0.0333 5.66backward Euler 0.01 17.05backward Euler 0.00075 218.4forward Euler 0.00020 265.0symplectic Euler 0.00025 208.0semi-implicit MPR 0.001 247.4AVI 0.00037 215.0

Table 1 Computation times in seconds for scene 1 in sec-onds. The scene consists of a simple piece of cloth swingingfor 4s, consisting of 5016 faces.

5 Results

We evaluated our method on several test cases. In thefirst test we compare the performance of different explicitand implicit integration schemes with respect to bothcomputation times and especially their visual quality.The latter is, to some extent, subjective and we thereforechose a traditional example that clearly demonstratesthe differences between the methods: a piece of clothwith 5016 faces is pinned at two corners and left swing-ing for 4 seconds. For this example, we used a materialwith Young’s modulus of E = 300N/m, a shear mod-ulus of G = 150N/m and mass density ρ = 500g/m2.Moreover, strain limiting with 10% allowed strain wasused. Fig. 2 shows a representative frame of this anima-tion. Using a large time step of dt = 0.03s, the backwardEuler integrator damps out almost all of the importantfeatures (Fig. 2, left). Decreasing the time step helps, butcompared to the implicit midpoint rule, which performsslightly better, and especially the explicit integrators, theoverall appearance still looks rather flat. This behaviourcan be explained by the numerical dissipation inherentto the backward Euler scheme, which becomes particu-larly apparent when large time steps are used. The otherintegration schemes perform considerably better in thisregard, which can be attributed to their symplectic na-ture and the associated energy conservation properties.

Table 1 shows the computation times for the firstscene. With a time step of dt = 0.03s impressive com-putation times can be obtained for the backward Euler.However, the result appears overly flat and lacks detail.The situation becomes better when using dt = 0.00075s,which leads to roughly the same computation time asfor our method. Still, folds are not reproduced as de-tailed as with our AVI-based scheme or the symplecticEuler scheme, which yields similar visual results. Balanc-ing visual quality against computation times, the implicitmidpoint rule shows a rather deceiving performance. De-spite its symplectic nature, results look still too smooth,which is due to the fact that we had to use a high damp-ing value of 0.1 to maintain stability even for a smalltime step of dt = 0.001. We conjecture that in order tobe of practical use, the variant described in [VMT05] hasto be used. Note that although our AVI-based methodhas some overhead for managing asynchronicity, it stillperforms almost as well as the symplectic Euler, which

Integrator Time-step

Tsolve Tcoll Ttot

backward Euler 0.005 7.74 4.31 12.05backward Euler 0.001 16.1 9.7 25.8forward Euler 0.00001 571.5 213.3 784.8symplectic Euler 0.00005 109.5 62.09 171.59semi-implicit MPR 0.0001 323.9 51.98 375.88AVI 0.0002 47.2 21.12 68.32

Table 2 Computation times in seconds for scene 2. Thescene consists of an unstructured mesh of 2304 faces withnon-flat rest geometry falling onto the floor.

shows the best overall performance in this test. This isalso due to the fact that an unstructured mesh is used forsimulation, which, having triangles with slightly differ-ent sizes, leads to a higher average elemental time step.This advantage is even more pronounced for meshes opti-mised for accurately capturing regions of high curvatureswith small triangles, but which are otherwise coarse inflat parts (see Fig. 5). The second test scene uses sucha mesh with non-flat rest geometry. During 4 secondsof simulation, the object falls from 50 cm height onto aflat floor, where it comes to rest. The parameters are thesame as in scene 1 except for a higher bending stiffness,which lets the object keep its shape after the impact.Table 2 shows the computation times for this scene withseparate timings for time stepping and collision handling.Backward Euler is again the fastest, but our method per-forms significantly better than the other explicit schemesand the implicit midpoint rule.

The two remaining scenes show that our method canbe used for creating standard cloth simulations in combi-nation with character animations (see Fig. 1) as well aschallenging self-collision scenarios (see Fig. 5). The ac-companying video also shows a comparison between theresults obtained with our method and using backwardEuler.

Fig. 7 Simulation of an unstructured mesh containing ele-ments of different sizes. The ratio between the area of thelargest and the smallest element is 160:1. The mesh consistsof 2304 faces.

6 Conclusion

We presented an asynchronous simulation method forthin flexible objects, which enables efficient simulationof low damped cloth. Thanks to the energy conserva-tion properties of the underlying symplectic time inte-gration scheme, lively cloth motion is obtained, exhibit-

8 Bernhard Thomaszewski et al.

ing important details like small folds and wrinkles. Thecomputational costs of our method are similar to back-ward Euler with a time step of dt = 0.001. Yet it re-veals more surface details and leads to results which areless damped. Our method is particularly attractive whencombined with unstructured meshes having elements ofdifferent sizes. For future work we would like to extendour simulator to account for spatially adaptive meshessince in this way computation times could be further re-duced.

Acknowledgments

The first author would like to thank the DAAD for grantD/07/45108. The second author was supported by DFGgrant STR465/21-1.

References

[Bat96] K.-J. Bathe. Finite element procedures. PrenticeHall, New Jersey, 1996.

[BFA02] R. Bridson, R. Fedkiw, and J. Anderson. Robusttreatment of collisions, contact and friction forcloth animation. In Proceedings of ACM SIG-GRAPH ’02, pages 594–603, 2002.

[BMF03] R. Bridson, S. Marino, and R. Fedkiw. Simu-lation of clothing with folds and wrinkles. InProceedings of ACM SIGGRAPH/EurographicsSymposium on Computer Animation (SCA2003), pages 28–36, 2003.

[BW97] J. Bonet and R. D. Wood. Nonlinear ContinuumMechanics for Finite Element Analysis. Cam-bridge University Press, Cambridge, 1997.

[BW98] D. Baraff and A. Witkin. Large steps in clothsimulation. In Proceedings of ACM SIGGRAPH’98, pages 43–54, 1998.

[BWH+06] M. Bergou, M. Wardetzky, D. Harmon, D. Zorin,and E. Grinspun. A Quadratic Bending Modelfor Inextensible Surfaces. In Fourth Eurograph-ics Symposium on Geometry Processing (SGP),pages 227–230, Jun 2006.

[Cel98] W. Celes. Efficient asynchronous evolution ofphysical simulations. In Proceedings of SIB-GRAPI’98, pages 224–231, 1998.

[CK02] K. J. Choi and H. S. Ko. Stable but responsivecloth. In Proceedings of ACM SIGGRAPH ’02,pages 604–611, 2002.

[DGC04] J. Dequidt, L. Grisoni, and C. Chaillou. Asyn-chronous interactive physical simulation. Tech-nical Report RR-5338, INRIA, October 2004.

[EWS96] B. Eberhardt, A. Weber, and W. Straßer. A fast,flexible, particle-system model for cloth drap-ing. IEEE Computer Graphics and Applications,16(5):52–59, 1996.

[FO01] F. Flores and E. Onate. A basic thin shell tri-angle with only translational dofs for large strainplasticity. International Journal for NumericalMethods in Engineering, 51:57–83, 2001.

[GHDS03] E. Grinspun, A. Hirani, M. Desbrun, andP. Schroder. Discrete shells. In Proceedings ofACM SIGGRAPH/Eurographics Symposium onComputer Animation (SCA 2003), pages 62–67,2003.

[GHF+07] R. Goldenthal, D. Harmon, R. Fattal,M. Bercovier, and E. Grinspun. Efficientsimulation of inextensible cloth. In Proceedingsof ACM SIGGRAPH ’07, pages 281–290, 2007.

[HE01] M. Hauth and O. Etzmuss. A high performancesolver for the animation of deformable objectsusing advanced numerical methods. In EG 2001Proceedings, pages 319–328. Blackwell Publish-ing, 2001.

[HLW06] E. Hairer, C. Lubich, and G. Wanner. Geometricnumerical integration. Springer-Verlag, Berlin,5th edition, 2006.

[KMOW00] C. Kane, J. Marsden, M. Ortiz, and M. West.Variational integrators and the newmark algo-rithm for conservative and dissipative mechani-cal systems. International Journal for NumericalMethods in Engineering, 49:1295–1325, 2000.

[KYT+06] L. Kharevych, W. Yang, Y. Tong, E. Kanso,J. E. Marsden, P. Schroder, and M. Des-brun. Geometric, variational integrators for com-puter animation. In Proceedings of ACM SIG-GRAPH/Eurographics Symposium on ComputerAnimation (SCA 2006), pages 43–51, 2006.

[LMOW04] A. Lew, J. E. Marsden, M. Ortiz, and M. West.Variational time integrators. InternationalJournal for Numerical Methods in Engineering,60:153–212, 2004.

[MKE03] J. Mezger, S. Kimmerle, and O. Etzmuß. Hi-erarchical Techniques in Collision Detection forCloth Animation. Journal of WSCG, 11(2):322–329, 2003.

[OAW04] S. Oh, J. Ahn, and K. Wohn. A new implicitintegration method for low damped cloth sim-ulation. In Proceedings of GMCG 2004, pages115–121, 2004.

[Pro95] X. Provot. Deformation constraints in a mass-spring model to describe rigid cloth behavior. InGraphics Interface ’95, pages 147–154, 1995.

[THM+05] M. Teschner, B. Heidelberger, D. Manocha,N. Govindaraju, G. Zachmann, S. Kimmerle,J. Mezger, and A. Fuhrmann. Collision Handlingin Dynamic Simulation Environments. In Euro-graphics Tutorials, pages 79–185, 2005.

[TPBF87] D. Terzopoulos, J. Platt, A. Barr, and K. Fleis-cher. Elastically deformable models. In Proceed-ings of ACM SIGGRAPH ’87, pages 205–214,1987.

[VCMT95] P. Volino, M. Courchesne, and N. Magnenat-Thalmann. Versatile and efficient techniques forsimulating cloth and other deformable objects.In Proceedings of ACM SIGGRAPH ’95, pages137–144, 1995.

[VMT05] P. Volino and N. Magnenat-Thalmann. Implicitmidpoint integration and adaptive damping forefficient cloth simulation: Collision detection anddeformable objects. Computer Animation in Vir-tual Worlds, 16(3-4):163–175, 2005.