A Cloth Modelling System for Animated Characters - Semantic Scholar

A Cloth Modelling System for Animated Characters Olaf Etzmuß, Michael Hauth, Michael Keckeisen, Stefan Kimmerle, Johannes Mezger, Markus Wacker Wilhelm-Schickard-Institut Universit¨at T¨ ubingen E-mail: {etzmuss, hauth, keckeisen, kimmerle, jmezger, wacker}@gris.uni-tuebingen.de

Abstract

The basis of the simulation system is a coupled particle system. These systems have been increasingly employed for physically based modelling of deformable objects especially textiles and garment [1, 3, 6, 9, 19], because they have been proven to allow for fast simulations and convincing results. Moreover, they can be derived from models of continuum mechanics by a finite difference formulation [8]. Hence, correct forces and physical material properties such as bending, shearing, and tension parameters (weft and warp direction) of cloths can be directly derived for the particle model from continuum theory.

We present a complete simulation engine to produce fast and realistic animations of clothes. This system is able to model clothes for animated and motion captured characters. Efficient algorithms for solving the arising equation of motion are employed. Also fast and reliable algorithms for proximity detection and collision response are crucial in animation, and we will present new methods allowing rapid and stable simulations.

1

In this model solving a stiff differential equation is crucial for the animation. With the work of Baraff and Witkin [1] computer graphics reoriented to implicit methods to allow large time steps. Recent work reduces the computational costs by approximated or simplified systems [4, 15] or introduces various integration methods [5, 23]. As our model possesses physical soundness, much care has to be taken not to loose this in the numerical solution. An analysis [12] has led to the use of an implicit integrator coupled with an adapted nonlinear solver. With our special architecture of the integration scheme well-adapted to the appearing differential equation we achieve fast computation times and high accuracy of the calculation which lead to high quality animations. Moreover, the solver directly contains constraint treatment which allows elegant and very stable integration of collision response in the solving process [7]. Furthermore, this approach allows simple and flexible insertion of additional

Introduction

In the last years animation of deformable objects has attracted great attention in computer graphics. In particular much progress has been made for realistic modelling of clothes for virtual characters generating physically based animations. Efficient numerical algorithms have been developed to solve the appearing differential equations both fast and stable guaranteeing accuracy of the solution and preserving the material properties of the textile. Our simulation engine for physical modelling and simulation of textiles comprises an interface for animated scenes and a simulation system to create realistic physically based animations of garment in complex scenes. We have developed the animation system to dress Poser’s 1 virtual characters. 1 Poser 3D character animation and design toolkit by Curious Labs

1

(non-stiff) forces, for instance air resistance and friction.

the collision response. All objects are represented as triangle or quadrilateral meshes. The environment contains the topological, geometrical, and physical data for each object, such as the current positions, velocities and accelerations of all vertices. Animated rigid objects can be stored as keyframes before the simulation starts, and an interpolation scheme such as linear or cubic spline interpolation for the keyframe sequences can be chosen. Thus, an easy to use interaction with 3D character animation tools like Curious Labs’ Poser is provided. We use Poser to create a series of keyframes from an animated avatar and include them in our system together with the clothes to be animated. The simulator then computes the movement of the cloth objects and updates their representation in the environment, while the proximity detection and the collision response retrieve the actual positions and velocities in every time step.

Interaction of the textile with itself and other objects plays an important role in physically based animation in order to model collision and friction and to produce realistic behavior. Therefore, collision detection and response are major issues in creating realistic animations for garment. To this end, textile interaction with rigid objects and self-collisions have to be taken into account, and therefore, simulation time can be dramatically effected. Hence, a suitable model for collision detection has to be developed to find collisions rapidly. In our model we use a method based on k-DOP hierarchies. They are checked very fast for contact and lead to fast hierarchically more accurate approximations of the objects. Additionally, we exploit heuristics and temporal coherence based on velocity cones to achieve further speed-ups. The detected collisions have to be treated appropriately to model inelastic collisions and friction. Also the collision algorithm must be stable and not impede the physical behavior in producing local instabilities that effect the animation. Here we use a special kind of constraints imposed on the system which enters directly our solving method. If collisions are detected the algorithm aims to ensure a minimal collision distance setting the velocity for the colliding particles of the textile. The velocities are set in direction of the nearest distance of the colliding objects adaptively to their relative velocity. Moreover, certain conditions are checked to release the constraints after each solver step. This algorithm turns out to be very stable also for multiple collisions.

2

Particle System Avatar keyframes

Proximity Detection and Collision Response Environment

Animated Scene

Clothes

Figure 1: System Architecture

3

Elastic Model

In their book on cloth modelling Donald House and David Breen state that “cloth is a mechanism, not a continuous material” [2, p. 55]. This is certainly true. However, in computer animation we cannot afford to model each detail of this mechanism, i.e. each single thread and structure. The only way to avoid this is to represent a patch of textile as continuous material, which allows us to use low resolution models without loosing basic material properties. Unfortunately, accurate continuum models usually lead to very time consuming computations that are far too slow for animation purposes. Therefore, we have developed a particle system from a continuum mechanics model in order to simulate continuous

System Architecture

In order to incorporate character animation we need to equip our cloth simulator with an interface that stores the scene and allows all components of the system to query this data. In the simulator this interface is implemented as an environment class that holds all deformable and rigid objects and is accessible by the particle system as well as the proximity detection and 2

objects [8]. We apply this particle system to the simulation to obtain a sound description of the clothes. This elastic model will be summarized here briefly.

Analogously to the diagonal components of the stress 1 12 tensor, the corresponding force terms ∂σ ∂v ksu k su and ∂σ21 1 ∂u ksv k sv

are computed. Curvature dependent forces that counter bending can not be derived from the stress tensor (1). Therefore, we add forces derived from the thin plate energy projected onto the surface normal. These forces are given by

The key is an approximation of the stress tensor. Given the deformed surface s(u, v), we approximate the stress tensor by µ ¶ k1 (ksu k − 1) 12 µ < su , sv > σ= , (1) 1 k2 (ksv k − 1) 2 µ < s u , sv >

f = B < N, suuuu + 2suuvv + svvvv >, where B is the bend modulus and N the vertex normal. The fourth derivatives are discretized by finite differences as above. Viscous forces are derived analogously to the elastic forces from the strain rate tensor.

where k1 , k2 , and µ are the elastic material constants, and the subscripts as in su and sv denote the partial derivatives. This tensor is plugged into the equation of motion for continuous objects ρ

∂2s − div σ = f, ∂t2

(2)

For rectangular meshes we verified that this particle system approximates the accurate continuum model with linear precision, i.e. we have convergence to the accurate solution when the resolution is increased. Unfortunately, the finite difference interpretation requires regular, quadrilateral meshes, which impose restrictions on the clothes to be modelled. In order to allow more flexibility in our modelling system, we are able to apply the same forces to unstructured, triangular meshes. However, preservation of material properties and independence of the triangulation cannot be guaranteed for these meshes.

where ρ is the mass density, and the divergence of the stress σ yields the force density due to the interior energy of the elastic object. Here f denotes an external force density, e.g. the gravity force density ρg. From the divergence of the stress tensor the internal elastic forces are derived. Particularly, by approximations we derive stretch and shear forces, and by a finite difference semidiscretization equation (2) is reduced to an ODE. From the diagonal components of the stress tensor we derive linear spring forces by finite difference discretizations: ¸ · xi − x j k1,2 , fi,j = 2 (xi − xj ) − l l kxi − xj k

4

The actual simulation has to solve the ODE that describes the temporal evolution of the physical system. Our cloth modelling system makes use of the numerical architecture developed previously [12] and shown in figure 2. It consists of an implicit integration method combined with a tailor-made nonlinear system solver. The implicit methods that are employed here guarantee unconditional stability, i.e. the integration with arbitrary time steps remains stable. The flexibility of the implementation allows to choose the implicit Euler method, the implicit midpoint method, and BDF(2) as integration scheme. When using

where l is the rest distance between the particles at xi and xj . Note that the fi,j are actually force densities as we have continuous objects. The shear term σ12 = µ2 < su , sv > as given in equation (1) is also approximated by finite differences yielding σ12

=

Implicit Integrator Core

µ < xi+1,j − xi−1,j , xi,j+1 − xi,j−1 > 8l2 +O(l3 ). 3

Integration Method

Collisions

Implicit Equation for y1

Check

volumes to be able to deal with standard collisions and self-collisions simultaneously by using the same acceleration structures. We decided against voxelbased methods, although they are sometimes superior to bounding volume hierarchies [25]. But they lack flexibility in large, sparsely occupied space, and moreover they are likely to be inefficient in proximity detection.

Newton Method Nonlinear Equation for y1

Linear Solver Solve for Update ∆y1 Enforce Constraints

Set Constraints

Bounding Volume Hierarchy In complex dynamic scenes, bounding volumes have to be permanently readapted to the approximated geometry. Arbitrary object deformations cannot be expressed by rigid rotations and translations, thus orientable bounding volumes like OBBs [11], QuOSPOs [13] or Dynamically Aligned DOPs [24] are not suitable for cloth modelling. We therefore use common k-DOPs [16], which provide better convergence than spheres [14] or ordinary AABBs [21] and can be adjusted to memory limits by the choice of k. Additionally, kDOP bounding volumes (BVk ) inherit from AABBs the feature [ BVk (V ) = BVk (p) (3)

Residual Contol

Stepsize Control

Figure 2: Architecture of the integration scheme. large time steps, both second order methods ensure a higher precision than the commonly used first order Euler method. The arising nonlinear systems need to be solved by a Newton like method, which again contains a conjugate gradient method as an embedded linear solver.

5

p∈P (V )

for a set of vertices V and an arbitrary partition P (V ). Hence, the optimal bounding volume for a node in the hierarchy can be easily computed by the superset of its child bounding volumes. Vice versa the hierarchy can be efficiently built using a top-down splitting method. Figure 3 shows the region borders and the corresponding 26-DOPs for some quadtree levels approximating a hemisphere.

Collision Detection

A physically correct cloth simulation demands penetration avoidance and therefore an effectively robust detection system, since any penetration violates reality and often results in expensive correction procedures. In order to benefit from the considerable advantages of the collision response described in this paper, an efficient method for detecting mesh proximities is essential. Existing collision detection techniques usually fail either in handling highly concave surfaces or in measuring distances. Our collision response, however, relies on an exact measure for distances between several deformable and rigid objects and even between parts of a particular textile itself. To reduce the large number of m × n primitive tests for two mesh objects of sizes m and n, usually hierarchies [17] are used. A number of approaches to various collision detection demands can be found in [18]. We use an object-based hierarchy of bounding

(d)

(c)

(b)

(a)

Figure 3: Approximating a hemisphere by 26-DOPs The bounding volumes are split according to the longest side rule. In our implementation the longest 4

side of a k-DOP is determined by the face pair having the maximum distance. The DOP is split parallel to this face pair through its center. As generally some polygons are cut by the splitting plane, they are assigned to that child node which would have the fewest polygons without those being cut. In the lower hierarchy levels, if all polygons happen to be cut, each of them is assigned to an own node. This method turns out to be very efficient on the one hand and to produce well balanced trees on the other hand. The complete hierarchy setup for objects holding several thousands of polygons can be performed within merely a second, allowing to add objects rather dynamically to the scene. Usually, the splitting is not stopped before a single polygon remains per leaf. In order to comply with memory needs, splitting can also be applied until every leaf holds a maximum number of polygons, indeed significantly reducing the detection speed. In order to use rather large time steps for the simulation, not only real collisions, but already object proximities have to be detected. Let εclose be the maximum distance of two meshes where proximities have to be detected, depending on the velocities of the vertices and the time step size. Now, proximity detection is implemented by enlarging the k-DOPs by an offset εclose /2 in each of its k directions. It easily can be shown that the overlap of two enlarged k-DOPs is a necessary condition for actual εclose –proximity.

v

á

significance

node

Figure 4: Velocity Cone meet suitable conditions, updates of the corresponding bounding volume can be omitted or simplified for a number of steps. Trees Binary trees are most common to store the hierarchy since they require the smallest number of overlap tests. However, the depth and number of nodes are maximal, and consequently the recursion during overlap tests is deeper than for any higher order trees. Figure 5 shows the reduction of recursion depth for detecting two overlapping leaves using equivalent quadtrees instead of binary trees. Note that in this case the recursion depth is reduced by the factor 2, whereas the number of overlap tests remains equal. However, if only the root nodes overlap, but not any other nodes do, the quadtrees require four overlap tests, which is two times more than using binary trees. Since overlap tests for k-DOPs only need k/2 interval tests in the worst (overlapping) case, a slight increase of overlap tests is acceptable. Our implementation is able to use arbitrary 2n -trees, but quadtrees and octrees have turned out to be the fastest. Particularly, they are significantly faster than binary trees.

Lazy Hierarchy Update We propose a new heuristic for those parts of the scene where only small velocities occur. For that purpose we introduce the velocity cone, which is also used to detect temporal coherence during the detection process. A velocity cone (figure 4) is similar to Provot’s normal cone [20] (see below) for surface curvature heuristics in selfcollision detection and can be similarly computed. The velocity cone represents an approximation of the velocity distribution in a hierarchy node by a very small number of values, thus permitting fast calculation and comparison. The angle α, the direction v, and the size of the cone depend on the movement of the vertices. In particular, α measures the correlation of the velocity vectors, and the size represents the significance of the movement. If the values

Distance Computation Whenever two colliding hierarchy leaves have been found, the distance between each pair of primitives is calculated, and candidate pairs are detected and passed to the collision response. We compute the closest points between convex polygons with an adapted implementation of the GJK algorithm [10], because the primitives have 5

0

a

1 3

2 4

5

Collision b

6

d

stopped. The next detection process resumes the recursion at these nodes. Instead of checking whether a separation node can move up in the recursion tree, we just track the nodes moving down and rebuild the separation list after a while. The check for up-moving nodes is expensive and usually fails anyway, as contacts in cloth simulation often persist for a longer period of some time. Besides the separation list we use the velocity cones built during the hierarchy update to analyze the relative movement of nodes. Whenever two nodes have very similar velocity cones, detection results are taken from the previous time step. Closest points of triangles are stored by their barycentric coordinates, thus they do not need to be recalculated during coherent movements. As errors may accumulate, the results have to be recomputed after a certain period of time depending on the velocities and the εclose –distance.

c e

f

g

f

g

0a 1a

2a 2b

5b

2c 6b

6d

6e

(a) 0 3

4

a

Collision

5

6

d

e

5a

6a

0a 3a

4a 6d

6e

6f

Self-collision In addition to hierarchies the detection process for self-collisions can be accelerated by analyzing the surface curvature. A very exact method to reject possible self-intersections for a certain region was suggested by Volino and MagnenatThalmann [22], where a vector which has positive dot product with all normals of the region is searched. If such a vector exists and the projection of the region onto a plane in direction of the vector does not selfintersect, the region cannot self-intersect either. We prefer Provot’s method [20], which is accurate enough for regions having a sufficiently convex border. The k-DOP regions generated by our hierarchy setup meet this condition, and moreover we are able to extend easily the idea in order to detect selfproximities. For every region a cone is maintained representing a superset of the normal directions. The cone can be calculated during the bottom-up hierarchy update by just a few arithmetic operations. The angle α of the cone represents the curvature of the region, indicating possible intersections if α ≥ π. In order to detect proximities as well, our self-proximity criterion is α ≥ εcloseAngle for an angle εcloseAngle ≤ π depending on εclose . We traverse the hierarchy of a deformable object by first checking whether the surface curvature criterion

6g

(b) Figure 5: Recursion using binary trees (a) and quadtrees respectively (b) not necessarily to be triangles. Since we can stop the hierarchy setup at a certain node size to save memory, the leaves can represent more than one polygon. In order to handle multiple collisions that occur when textiles are clamped between other textiles or body parts, all critical proximities are passed to the collision response to ensure a smooth and accurate response. Detection Process We test two meshes for overlaps by recursively traversing the hierarchies from top to down. Whenever two nodes overlap, all children inside the longest k-DOP are tested against the smaller node. To reduce costs for the hierarchy traversals, we detect frame-to-frame coherence by storing a separation list as proposed by Li and Chen [17] to memorize the node pairs where the recursion 6

indicates proximities. In this case the child regions are recursively checked. Additionally, to detect proximities across the child borders, the child regions have to be recursively tested against each other similarly to the standard detection process. Whereas separation lists cannot be maintained for this case, the velocity cones still are used to benefit from temporal coherence.

6

faces, where the closest points are determined. Contrary to earlier approaches [12, 20] the velocity is not constrained in the normal direction of the close object but in direction of the closest point pair of the close faces. For collisions between smooth surfaces there is no difference between these directions. For collisions between non-smooth surfaces and edges, this approach leads to a more stable collision response, because there are no discontinuities in the constrained direction. If the velocity is constrained it has to be preset with appropriate values. For the collision response it has to be distinguished between two different cases:

Collision Response

For animated scenes an efficient collision response method is crucial. In particular, numerical stability in the context of large time steps has to be preserved.

1. Collisions of two deformable faces: In general only faces moving towards each other are handled. Their velocity is set to assert a minimum distance dmin . This velocity is scaled by γ = min to simulate a resting contact, where vrel vrel / d∆t is the relative velocity of the two faces and ∆t is the current time step.

Approaches to collision response Several approaches have been proposed for collision response. One possibility is relocating the particles involved in a collision to arrive at a consistent state. Although this is the most simple and obvious collision response method, this approach leads to discontinuous trajectories and thus poses a new initial value problem to the numerical solver whenever collisions occur. In addition, the sudden relocation of a particle causes a shock wave travelling through the object and consequently introduces numerical stiffness into the particle system, requiring the step size of the solver to be small. Using force fields around each object that prevent any particle from penetrating that object requires very large potentials acting on a very short range. Hence, this is just a variation of relocating the particles and suffers from the same disadvantages. In our cloth simulation system we refine the very efficient approach presented by Barraff and Witkin [1] that enforces constraints by reducing the dimension of the state space in the solver’s cg-method.

2. Collisions between a deformable and a face of the pre-computed rigid environment: Additionally to the velocity used to assert the minimum distance, the velocity of the rigid object in constraint direction has to be added to the velocity of the deformable object. Therefore, we constrain the velocity of the colliding particles in the direction ns of the closest point pair of the two faces and preset it to ¶ µ 1 (4) γdmin − d + vr , v=π ∆t where π is the projection onto the oriented direction ns , d is the distance between the two faces and vr is the velocity of the rigid object. Since we constrain only one direction of the particle velocity the particle is still free to move according to the forces acting on it in the other directions. Hence it is easy to model stiction by constraining the other degrees of freedom and replacing the projected velocity of the rigid object by the entire velocity of the rigid object in equation (4) such that the cloth moves with the rigid object.

Collision response in animated scenes Our approach for collision detection and response aims at avoiding collisions before they occur. Therefore, not only colliding faces are detected but already proximities, that is faces closer than εclose . In this case the collision detection returns pairs of colliding or close 7

Collision constraints must be released when forces drag the particle away from the collision object. These release forces are estimated from the residuum at the beginning of every integration step.

7

clothing have to be developed and constructed for a prototype in clothing industry. Future work will therefore concentrate on the construction of clothes from CAD garment patterns and the integration of measured material data in our system.

Results 9

In order to demonstrate the capability of our animation system, several sample scenes were designed. The example in figure 6 shows three frames from an animation of a flexible band falling to the ground. This example is a complex test for self-collision detection and response as multiple collisions are involved. In figure 7 a ball flies through a hanging cloth and then slides up and down a half pipe. The cloth collides both with the ball and the suspension. Collisions with the environment as well as self-collisions are detected and handled in this scene. Multiple collisions have to be handled in the example of figure 8, where eight sheets of cloth are dropped on various geometric objects. Although no special treatment is given to ensure the consistency of collisions, the simulation yields feasible results and terminates in a rest state. Finally, we dressed a Poser character, which after dressing starts to walk on a catwalk. The movement was obtained by motion captured data. A sequence from this animation is shown in figure 9.

8

Acknowledgements

This work was supported by the DFG ElastoMedTrain, DFG MoViTex, and bmb+f Virtual Try-On grant. We are grateful to Bernhard Eberhardt for helpful discussions and Robert Kuchar and Timo Schairer for the rendering of our pictures.

References [1] D. Baraff and A. Witkin. Large Steps in Cloth Simulation. In M. Cohen, editor, SIGGRAPH 98 Conference Proceedings, Annual Conference Series, pages 43–54. ACM SIGGRAPH, Addison Wesley, July 1998. [2] D. E. Breen and D. H. House, editors. Cloth Modeling and Animation. A K Peters, 2000. [3] D. E. Breen, D. H. House, and M. J. Wozny. Predicting the drape of woven cloth using interacting particles. In A. Glassner, editor, Proceedings of SIGGRAPH ’94 (Orlando, Florida, July 24–29, 1994), pages 365–372. ACM SIGGRAPH, ACM Press, July 1994.

Conclusions and further work

We have presented a simulation engine for fast and accurate simulation of textiles. With this system motion captured and animated characters, e.g. of Curious Labs’ Poser, can be dressed with clothes. Moreover, the national research project “Virtual TryOn” will be based on the modelling system presented here. This research project focuses on the virtual try-on of clothes in the internet and economic production of made-to-measure wear. A technological basis is created for exploiting the combination of innovative sale of individual clothing and the potential of e-commerce. New techniques and technologies for virtual selection, try-on, and evaluation of individual

[4] M. Desbrun, P. Schr¨oder, and A. Barr. Interactive Animation of Structured Deformable Objects. In Graphics Interface, pages 1–8, June 1999. [5] B. Eberhardt, O. Etzmuß, and M. Hauth. Implicit-Explicit Schemes for Fast Animation with Particle Systems. In N. ThalmanMagnenat, D. Thalman, and B. Arnaldi, editors, Proceedings of the Eurographics Workshop on Computer Animation and Simulation (EGCAS2000), pages 137–154. Springer, 2000. 8

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

Detection Using Bounding Volume Hierarchies of k-DOPs. IEEE Transactions on Visualization and Computer Graphics, 4(1):21–36, 1998. [17] T.-Y. Li and J.-S. Chen. Incremental 3D Collision Detection with Hierarchical Data Structures. In Proceedings of the ACM Symposium on Virtual reality software and technology 1998, 1998.

[7] O. Etzmuß, B. Eberhardt, M. Hauth, and W. Straßer. Collision Adaptive Particle Systems. Proceedings Pacific Graphics 2000, 2000. [8] O. Etzmuss and J. Gross. Cotinuum mechanics based particle systems. submitted for publication, 2001.

[18] M. Lin and S. Gottschalk. Collision Detection between Geometric Models: A Survey. In Proceedings of IMA Conference on Mathematics of Surfaces, 1998.

[9] O. Etzmuß and M. Hauth. Fast Animation of Deformable Objects with Particle Systems. In Proceedings Graphiktag 2000, 2000.

[19] X. Provot. Deformation Constraints in a MassSpring Model to Describe Rigid Cloth Behavior. In W. A. Davis and P. Prusinkiewicz, editors, Graphics Interface ’95, pages 147–154, 1995.

[10] E. G. Gilbert, D. W. Johnson, and S. S. Keerthi. A Fast Procedure for Computing the Distance Between Complex Objects in Three-Dimensional Space. IEEE Journal of Robotics and Automation, 4(2), 1988.

[20] X. Provot. Collision and Self-Collision Handling in Cloth Model Dedicated to Design Garments. In Graphics Interface ’97, pages 177–189. Canadian Information Processing Society, Canadian Human-Computer Communications Society, May 1997.

[11] S. Gottschalk, M. C. Lin, and D. Manocha. OBBTree: A Hierarchical Structure for Rapid Interference Detection. Computer Graphics, 30(Annual Conference Series):171–180, 1996.

[21] G. van den Bergen. Efficient Collision Detection of Complex Deformable Models using AABB Trees. Journal of Graphics Tools, 2(4):1–13, 1997.

[12] M. Hauth and O. Etzmuß. A High Performance Solver for the Animation of Deformable Objects using Advanced Numerical Methods. In Proc. Eurographics 2001, 2001.

[22] P. Volino and N. Magnenat-Thalmann. Efficient Self-Collision Detection on Smoothly Discretized Surface Animations using Geometrical Shape Regularity. In EuroGraphics, volume 13, pages 155–166, 1994.

[13] T. He. Fast Collision Detection Using QuOSPO Trees. Proceedings of the 1999 symposium on Interactive 3D graphics, pages 55–62, 1999. [14] P. M. Hubbard. Approximating Polyhedra with Spheres for Time-Critical Collision Detection. ACM Transactions on Graphics, 15(3):179–210, 1996.

[23] P. Volino and N. Magnenat-Thalmann. Implementing fast Cloth Simulation with Collision Response. In Computer Graphics International Proceedings, 2000.

[15] Y.-M. Kang, J.-H. Choi, H.-G. Cho, D.-H. Lee, and C.-J. Park. Real-time Animation Technique for Flexible and Thin Objects. In WSCG, pages 322–329, Feb. 2000.

[24] G. Zachmann. Rapid Collision Detection by Dynamically Aligned DOP-Trees. Proc. of IEEE, VRAIS’98 Atlanta, 1998. [25] D. Zhang and M. M. Yuen. Collision Detection for Clothed Human Animation. Proceedings of the Pacific Graphics, 2000.

[16] J. T. Klosowski, M. Held, J. S. B. Mitchell, H. Sowizral, and K. Zikan. Efficient Collision 9

Figure 6: A falling piece of cloth.

Figure 7: A ball moving a hanging sheet.

Figure 8: Several falling and interacting sheets.

10

Figure 9: Dress on an animated Poser character.