Fast and Controllable Simulation of the Shattering of Brittle Objects

Volume 20 (2001), number 2 pp. 81–90 COMPUTER GRAPHICS forum

Fast and Controllable Simulation of the Shattering of BrittleObjects

Jeffrey Smith, Andrew Witkin† and David Baraff†

Robotics Institute, Carnegie Mellon University, Pittsburgh, Pennsylvania, USA

AbstractWe present a method for the rapid and controllable simulation of the shattering of brittle objects under impact.An object is represented as a set of point masses connected by distance-preserving linear constraints. This use ofconstraints, rather than stiff springs, gains us a significant advantage in speed while still retaining fine controlover the fracturing behavior. The forces exerted by these constraints during impact are computed using Lagrangemultipliers. These constraint forces are then used to determine when and where the object will break, and tocalculate the velocities of the newly created fragments. We present the details of our technique together withexamples illustrating its use.An earlier version of this paper was presented at Graphics Interface 2000, held in Montreal, Canada.

Keywords: physically based modeling, computer animation, impact, brittle materials

1. Introduction

Realistic animation of breaking objects is difficult to do wellusing the traditional computer animation techniques of handmodeling and key-framing. This difficulty arises from thefact that the breaking of an object typically creates manysmall, interlocking pieces. The complexity and number ofthese fragments makes modeling them by hand all butimpossible, but the distinctive look of a shattered objectprevents the use of simple short-cuts, such as slicing thesurface of an object into faces or the use of RenderManshaders.

Consequently, the simulation of breaking and shatteringhas received some attention within the graphics community.An early attempt at modeling fracture is given inTerzopoulus and Fleischer [1], where they presenteda technique for modeling viscoelastic and plasticdeformations. While not specifically intended to modelthe breaking of brittle objects, their work allowed thesimulation of tearing cloth and paper with techniques thatcould have been applied to this task. In 1991, Nortonet al.

† Now at Pixar Animation Studios.

[2] described a technique specifically for modeling thebreaking of three-dimensional objects wherein the object tobe broken was subdivided into a set of equally sized cubesattached to one another with springs. Unfortunately, theiruse of an elastic network invited massive computationalexpense for large objects.

Most recently, O’Brien and Hodgins [3] used continuummechanics techniques developed in mechanical and civilengineering to model the behavior of brittle fracture,including crack initiation and propagation. Althoughtheir approach did not use an explicit lattice of springsattached to point masses, it was similarly computationallyexpensive. Specifically, their use of Euler and second-orderTaylor integrators restricted the time step of the physicalsimulation to extremely small values. Due to theirre-meshing technique, the timing of the examples presentedin their paper is difficult to directly compare with ourown. As a rough comparison, their “wall #2” mesh, witha final total of 8275 elements, took an average of 1098seconds of computation per simulation second on a 195MHz R10000 processor. Running a similarly sized model(8421 tetrahedra with 16,474 shared faces) with the sameimpact and fragmentation characteristics took roughly 90

c© The Eurographics Association and Blackwell Publishers Ltd2001. Published by Blackwell Publishers, 108 Cowley Road,Oxford OX4 1JF, UK and 350 Main Street, Malden, MA 02148,USA. 81

82 J. Smith et al. / Shattering Brittle Objects

seconds with our technique. Unsurprisingly, the fieldsof condensed-matter physics and materials science haveexamined the topic of brittle fracture more thoroughly.Note that the term “brittle” , as used in materials scienceliterature and this paper, means that a substance does notundergo significant plastic (irreversible) deformation beforebreaking (see, for example, Cherepanov [4]). That is, abrittle object will not bend much under stress, but willeither resist almost completely or break catastrophically.Unfortunately, the simulation methods used in these fieldsare often inappropriate for graphics applications. In general,materials scientists are interested in predicting with greataccuracy how and when an object will shatter, whereas acomputer animator is more concerned with generatingrealistic-looking behavior in a reasonable amount of time.Consequently, the level of physical detail used in materialsscience simulations is much higher, and often of a differentnature, than we require.

One commonly used approach in this field is the latticemodel (Arbabi [5], Chung [6], Donze [7]). This method,similar to that used by Norton et al. [2], models objectsas a lattice of points or point masses connected by stiffsprings. During simulation, the extension of each spring (orsome other potential function of the particle displacements)is computed. Depending on the model, either every springexceeding its extension or potential limit, or only the mostegregious violator, is removed. The state of the system iscleared and the process repeated until the object falls apart,or until no new elements are being broken. A significantdisadvantage of material science lattice solutions is thatthey almost universally use three-dimensional systems ofstiff springs combined with explicit numerical integrationmethods. The step sizes for this type of simulation mustbe on the order of the inverse of the speed of sound inthe material being simulated, and thus the computationalexpense can be high. (Even with the use of implicitintegration methods, the simulation of a lattice of stiffsprings entails a computational cost at least equal to thatof Lagrange multipliers.) For example, in Chung [6], thesimulation (with an explicit integration method) of an objectwith 2701 lattice-links is done in 137 time-steps, each taking86 seconds on a 75 MHz MIPS R8000, for a total of3.5 hours. A comparable simulation with our method on thesame hardware would take roughly 5.5 minutes.

In this paper, we present a fast and controllable methodfor simulating the fracture of brittle objects for animation.This method differs from the majority of the reviewedliterature in that it represents the object as a system ofpoint masses connected by workless, distance-preservingconstraints, rather than as a lattice of stiff springs. Ouruse of rigid constraints follows from an abstraction ofbrittle material properties and allows us to solve for theforces exerted by these elements during impact much morequickly than using explicit methods and an elastic mesh. Wecompute our solution by constructing a large, sparse, linear

system which we solve using a conjugate gradient descentmethod. The constraint forces, once calculated, indicatewhen and where the object will break. This informationis then used to construct the fragments of the brokenobject from the original geometry and to solve for the finallinear and angular velocities of these bodies. In addition toadvantages of speed, our system allows the user to easilycontrol the size, shape and number of fragments while stillyielding realistic-looking output, making it well-suited foruse in animation.

2. Modelling

As mentioned above, our method is roughly based on theelastic networks common in material science literature.However, instead of a three-dimensional mesh of springs weuse a lattice of rigid constraints to connect point masses. Weare motivated in this choice by both speed considerationsand the nature of ideal brittle materials.

Consider the naive system of points and springs. Becausewe are simulating brittle objects, these springs must be verystiff: stiff enough that no visible deformation takes placeduring high-momentum impact. As the brittleness of anobject increases, the stiffness of these springs increase, andthe displacements they undergo during impact decrease. Inthe limit, then, for an ideally brittle material we would beforced to model springs which are infinitely stiff and undergoinfinitesimal displacements.

Instead, we idealize these stiff springs asdistance-preserving constraints and, rather than calculatingdisplacements, calculate the forces that these constraintsexert in response to an applied impulse. Our use ofdistance-preserving constraints allows a faster method ofsolution (discussed in Section 3) than the use of explicitnumeric integration, while retaining both realism and alarge amount of user control.

2.1. Constructing the model

The first step in our simulation is the construction of a solidmodel—consisting of a collection of simple polyhedra—from the initial description of the object to be shattered.Since this initial description is usually a set of vertices andfaces describing only the surface, we first add a numberof well-distributed vertices inside this surface. As a ruleof thumb, we generally add enough vertices (uniformlydistributed) to triple the total number in the model. The usercan vary the number and distribution of these added verticesin order to affect the fracturing behavior of the object bychanging the shape and size of its potential fragments.

After the addition of internal vertices, we would liketo perform a constrained Delaunay tetrahedralization; thatis, one such that exterior faces of exterior tetrahedra

c© The Eurographics Association and Blackwell Publishers Ltd 2001

J. Smith et al. / Shattering Brittle Objects 83

correspond to the faces in the original surface description.However, since constrained tetrahedralization is a verydifficult problem, we cannot always accomplish this goal.If our constrained tetrahedralization fails, we fall backto a non-constrained tetrahedralization (using the freelyavailable package qhull [15]) followed by post-processingto clean up the model. This clean-up is required because anon-constrained tetrahedralization will (unless the object isconvex) result in tetrahedra that extend beyond the surface ofthe original model. We must therefore test every tetrahedronto see if it extends significantly beyond the boundary of theoriginal surface. We accomplish this check using two tests:

(1) We test to see if the centroid of any tetrahedron liesoutside the surface, discarding any which do.

(2) We then test the remaining tetrahedra to see if anyof their faces are outside the surface. Specifically,we test if the center of a face lies too far outsidethe original surface mesh. “Too far” , in this case,is defined as more than one quarter of the smallestdimension of the tetrahedron in question.

After removing all surface-crossing tetrahedra, we trans-form this new, solid model into a lattice representation—ourfinal model. This lattice representation is simply the Voronoicomplement (or “dual” ) of the solid object, which representsthe tetrahedra as point masses and their connections (sharedfaces) as rigid constraints (Figure 2). Each point mass isplaced where the center of the tetrahedron it represents waslocated and the mass of each point is determined by thevolume of the tetrahedron and the density of the object inthat volume.

The rigid constraints connecting these point masseshave an associated ultimate strength which correspondsphysically to the strength of the bond between two“micro-fragments” of the original object. If the tensile orcompressive force across a constraint exceeds this strengththen the bond will be broken. The breaking strengthof a constraint is determined though a combination ofuser-specified functions and a pair of simple heuristicsbased upon the the geometry of the two tetrahedra theconstraint is “gluing” together. In our model, the strengthof a constraint scales with the volume of the connectedtetrahedra and with the area of their shared face. Byrelating the strength of a constraint to the size and shapeof the tetrahedra it connects, the breaking behavior willbe influenced by the geometry of the object, which isnecessary for physically realistic results.

In addition to these simple geometry-based heuristics,the user may add a procedural variation to the constraintstrengths. For example, simple cleaving planes may beadded by systematically reducing the constraint strengthalong a cross-section of the object, or nodes of great strengthmay be created which will result in these regions remainingintact after the rest of the object is shattered. We have also

achieved good results using noise and turbulence functions,as described in Perlin [8]. Much of the flexibility of ourmodel comes from an appropriate choice of the function thatdetermines the constraint strengths.

3. Simulation

Our approach to the simulation of fracture is a simple one,intended to avoid the computational expense and complexityof a full dynamic simulation while preserving physicalrealism. Although the time course of impacts can be as littleas 100 µs, the speed of sound in brittle materials is typicallyseveral thousand meters per second (5100 meters/second incommon glass and between 3500 and 7000 meters/second inhard stone). Given that the objects we wish to shatter are ofmoderate size (usually on the order of 10 cm on a side), thetime to equilibrate internal forces (transmitted at the speedof sound) is on the order of 1 µs. Because the duration ofa typical impact is so much longer than the time it takes theinternal stresses to reach equilibrium, we make a quasi-staticloading approximation, and can safely use global solutionmethods to calculate the forces between elements of thesolid.

3.1. Fundamentals of the simulation

We formulate the problem of calculating the forces beingexerted by the rigid constraints as one of solving forLagrange multipliers in the following simplification of theconstraint force equation (For a derivation of this equation,see Witkin and Baraff [9] or Witkin et al. [10]):

J W J T �λ = −J W Q (1)

where W is the inverse mass matrix and Q is the global forcevector, containing information on what forces are beingexerted on which particles by the impact. The matrix J isdefined as

J = ∂C

∂p

where C is the “constraint vector” : a vector of functions—one for each constraint in the system—whose values are zeroif the constraint is satisfied and non-zero otherwise. If wewish to introduce prior material stresses, the initial constraintvector may be given non-zero entries and Equation (1)becomes

J W J T �λ = −J W Q − kC

where k is some unit-normalizing factor.

Each constraint function is of the form

Ci (pa, pb) = ‖pa − pb‖ − di

where pa and pb are the locations of the two particlesconnected to constraint i , and di is the length of theconstraint.



Figure 1: Glazed ceramic bowl, before (top) and after beingbroken with two different constraint-strength distributions.

The vector �λ, which is found by solving Equation (1),contains the values of the forces being generated by eachdistance-preserving constraint and is used to determinewhich constraints should be broken. Specifically, if aconstraint is found to be exerting a force greater than itsstrength, it is removed. It should be noted that intergranularbonds in brittle materials are eight times stronger undercompression than during tension [11], and this must beaccounted for in our breaking decision-rule.

With �λ in hand, it is a simple matter to calculate Q:

Q = J T �λ (2)

Figure 2: Two tetrahedra and their point/constraintcomplement.

0

0.2

0.4

0.6

0.8

1

0 0.2 0.4 0.6 0.8 1

Impa

ct m

agni

tude

Fraction of impact duration

Figure 3: Impact magnitude versus time.

which is the vector containing the forces being exerted byeach particle in reaction to the applied forces, Q. The valuesof Q are added to this global force vector, giving us the totalforces being experienced by each particle in our simulation.These force values can be used for physical simulation ofthe aftermath of fracture or, if we are using a multiple-stepsolution (see Section 3.3), as the input for another iterationof our algorithm.

3.2. Physically realizable solutions

The system that we are solving:

J W J T λ = b (3)

is under-constrained in the sense that for a given b, thereare any number of �λs which satisfy the equation. However,an arbitrary vector �λ does not necessarily correspond toa physically realizable set of constraint forces betweenconnected particles. Given this fact, how can we be certainthat our solution to Equation (1) is the physically realizableone?



Figure 4: Top view of broken plank, showing cracks betweentetrahedra.

Figure 5: Broken plank, showing fragments resulting fromimpact with no crack growth.

Figure 6: Top view of broken plank, showing moderate crackgrowth.

First we note that those solutions which are physicallymeaningful have a particular structure. Consider again theconnections between particles to be stiff springs. In thiscase, the only internal forces that can arise are those thathave been generated due to some displacement δp of theparticles. These displacements in turn correspond to a vectorof spring tensions �λ = Jδp. We can therefore see that allphysically realizable �λs can be written as �λ = Jδp for

Figure 7: Broken plank, showing fragments resulting fromimpact with moderate crack growth.

Figure 8: Top view of broken block, showing dramatic crackgrowth.

Figure 9: Broken plank, showing fragments resulting fromimpact with major crack growth.

some displacement δp. (We could parameterize by δp, butour solution would still have to satisfy Equation (3) and oursystem would be more complex.) Stated a different way, anyphysically realizable �λ must lie within the column-space ofJ and thus also in the column-space of J W J T (regardlessof J s rank; see Strang [12] for details).



Note, though, that any solution �λ of Equation (3) thatlies in the column space of J W J T is a minimum-normsolution. Thus, physically realizable solutions are equivalentto minimum-norm solutions, and since the minimum-normsolution to a linear equation is unique (Strang [12]), sois the physically realizable solution. Therefore, a solutionmethod that finds a minimum-norm solution of Equation (3)is guaranteed to give us the unique physically realizablesolution �λ.

We use the conjugate gradient descent method to solve forthe minimum-norm solution of our system. Not only will itgive us the correct solution, as shown above, but it exploitsthe sparsity of the J W J T matrix to give us fast solutiontimes [13].

3.3. Multiple-step solutions

It would appear that the simulation of an impact couldbe done with a single-step solution for Q. However, ouruse of a global solution method would permit constraintsto “ transmit” forces of arbitrary strength before beingremoved, whereas we desire the constraints to be able totransmit no more force than their breaking strength wouldallow. Visually, a single-iteration solution results in thepulverization of a large volume surrounding the impactwithout the distinctive shards and fragments we desire.

Instead of a single iteration, however, we can solve forQ in multiple steps, increasing the impact force with eachiteration. In this way we can slowly ramp up the magnitudeof the impact so that we are certain that no constrainttransmits a force greater, to within some ε, than its breakingstrength. By gradually increasing the magnitude of theimpact force, we are imposing a pseudo time-course uponour simulation. That is, rather than simulating an impact asa single, zero-time impulse, we are creating a more realisticimpact history. For all examples given in this paper, we usedthe simple piecewise linear function shown in Figure 3 asour impact schedule.

The time to equilibrate the forces within a brittle objectis much less than the duration of the impact. Therefore, wecan safely chop this duration into smaller segments withoutlosing the ability to solve with a global method. In practice,we have found that between 10 and 50 iterations of this loopyields acceptable results. Increasing the number of iterationsbrings little or no change in the fracturing behavior.

3.4. Crack growth

Another important feature of brittle fracture that we wouldlike to capture in our simulation is the growth of cracks. Inbrittle materials, the energy required to start a new crackof length l is significantly higher than the energy requiredto lengthen an existing crack by the same distance (see, for

example, Lawn [14]). This behavior is the major reason whyglass—despite its material homogeneity—breaks into large,polygonal shards under impact rather than turning into acloud of tiny fragments.

In order to encourage the growth of pre-existing cracks,we modify our multi-step algorithm. When we remove anewly broken constraint, we weaken the constraints aroundit that correspond to faces which adjoin the just-brokenconstraint. Thus, in the next iteration it is more likely thatthese constraints will break than constraints with an equalinitial breaking-strength that are not connected to a pre-existing crack. Specifying the form of this function allowsthe user to control the desirability of creating new cracksversus spreading existing flaws.

To illustrate this effect, three examples were generatedusing the same model—a simple rectangular plank—theonly difference between the simulations being the crackgrowth function used. The model used contained 3962tetrahedra with 7096 shared faces. Constraint strengthsvaried between 90.2 and 541.0, having been generated witha combination of a turbulence function and the geometricheuristics described in Section 2.1. Although these objectsall have the same initial geometry and constraint valuesand are broken with the same impact, significantly differentresults were produced. Figure 4 shows (from above) theaftermath of this test solid being fractured with no crackgrowth function. Here, dark lines show the edges of thetop-facing tetrahedral faces and white lines indicate crackboundaries. We can see from this picture that the crackswhich resulted in the fragmentation of this object have notspread far beyond the immediate impact location (the tip ofthe triangle). This object is shown in 3D in Figure 5, withthe different fragments assigned varying colors.

Figures 6 and 7 show the results of the same test, but witha crack growth function that reduces constraint strengths byup to a factor of two. Specifically, the function

sinew = si

old

(1.0 − sin

(2θ + π

2

))

where θ is the angle (between −π2 and π

2 ) betweensome constraint broken in the previous time-step and theneighboring constraint i . The values si

old and sinew are the old

and new constraint strengths respectively. We can see thatthis crack growth function has encouraged the creation ofmore fragments, and has permitted parts of the object furtherfrom the impact site to break.

Finally, Figures 8 and 9 show the results of our test objectbeing broken again, but with a more extreme crack growthfunction. This function reduces constraint strengths by up toa factor of 1000:

sinew = si

old

(0.5005 − 0.4995 sin

(4θ + π

2

)). (4)



Not surprisingly, cracks have propagated deeply into thesolid and have caused it to break into many more pieces. Ascan be seen from these three examples, even simple changesin the crack growth function can significantly alter ourresults, allowing the user further control over the materialproperties of the object.

3.5. Using the results

The simulation outlined above produces as output a newpoint/constraint model, consisting of the same point massesas in the input, but with fewer constraints. Using a region-coloring algorithm, it is a simple matter to determine theconnectivity of this new model, and to label the separatefragments. Since each point mass in this model correspondsto a tetrahedron in the original solid model, we can theneasily construct the set of solids (made of tetrahedra) whichare the fragments of the original object.

At this point we may have, in addition to large piecesof the broken object, many hundreds (or thousands, if themodel is large enough or the impact violent enough) of frag-ments that consist of only one tetrahedron. These tiny frag-ments, which we refer to as “dust” , are generally discardedin order to speed up the physical simulation of the aftermathof the impact. Specifically, we calculate the volume of eachfragment and discard those that consist of only one tetra-hedron and whose volume is below some threshold. Thisclean-up can be done with minimal impact on the realismof the final solution, since individual tetrahedra should bequite small in comparison to the size of the original object.

The final step in our algorithm is to calculate the velocities(both linear and angular) of the remaining fragments. The fi-nal forces exerted on each point mass in the point/constraintmodel reside in Q, calculated by Equation (2). The forces onpoint masses correspond to forces on the centroids of eachtetrahedra in the solid. Thus, given more than two tetrahedrain a fragment, we can easily calculate the linear and angularvelocities of that solid.

Given a point i , we know that

pi = vi + ωi × pi

where pi is the velocity of the point, vi is the strictlylinear velocity, ωi is the angular velocity and pi is itsposition. Thus, if we have a solid comprised of three or moretetrahedra with centroids p0, p1 and p2, we can separatevsolid from ωsolid by solving the following simultaneousequation:

I −p∗0

I −p∗1

I −p∗2

[

vsolidωsolid

]=

p0

p1p2

where I is the 3 by 3 identity matrix and p∗ is the dual (or

Figure 10: Original and fractally subdivided tetrahedra.

“cross” ) matrix: 0 −pz py

pz 0 −px−py px 0

.

With these velocities in hand, we can perform a dynamicphysical simulation to produce an animation of the aftermathof shattering.

3.6. Display issues

As noted earlier, a significant problem with the display offractured objects is that the underlying polyhedral mesh (inour case, tetrahedra) can be distractingly apparent. The sim-plest solution to this problem, of course, is to more denselysample the initial object, creating a larger number of smallertetrahedra. Unfortunately, using a higher resolution tetrahe-dralization quickly increases the computational expense (seeFigures 12 and 13). However, there is no need to use pre-cisely the same data for the physical simulation and for thedisplay. Similar to Norton et al. [2], wherein the cubic na-ture of the solid “cells” was partially masked using splines,we can add visual detail to our fracture surfaces by frac-tally subdividing the display geometry (see Figure 10). Thissubdivision process is done on a shared geometry databaseso that “ touching” faces on different fragments will still fittogether properly. A better technique, and one that we planto investigate in the future, would be a multi-resolution sim-ulation combined with re-meshing, such as that described inO’Brien and Hodgins [3].

4. Results and discussion

We have described a simple, physically motivated modelfor the rapid simulation of brittle fracture. The followingexamples illustrate the output of our work and demonstratesome of the different fracturing behaviors and materialproperties that can be simulated.

4.1. Wine glass

The examples shown in Figure 11 were generated from thesame geometric data: a wine glass modeled as 3422 tetra-



Figure 11: Three broken wine glasses, demonstratingdifferent fracture behavior.

hedra with 6447 shared faces. Differences in fracturing be-havior were produced by changing the function that deter-mined the strengths of the constraints. More specifically, theconstraint strengths were determined by a combination of athresholded turbulence function and the geometric heuristicsoutlined in Section 2.1. Each glass was broken with a singleimpact at the point where it struck the floor after falling.

4.2. Clay pot

Figure 1 shows before and after images of a pot, made fromglazed earthenware. This model was constructed from 6902

0

2

4

6

8

10

12

0 2 4 6 8 10 12 14 16 18 20 22

Tim

e (s

econ

ds)

Number of constraints (x1000)

Figure 12: Time per impact step versus total number ofconstraints.

020406080

100120140160180200

0 2 4 6 8 10 12 14 16 18 20 22

Tim

e (s

econ

ds)

Number of constraints (x1000)

Figure 13: Time required to construct fragments versus totalnumber of constraints.

tetrahedra, with 13,150 shared faces. In the middle image,the initially homogeneous constraints were alternatelystrengthened and weakened along the vertical axis. Thisvariation yields the characteristic breaking behavior ofpottery created without a wheel out of a single coil of clay.The lower image shows the same geometric model, but withconstraints modified only by our geometric heuristics and amild turbulence function, which yields a very different setof fragments.

4.3. Glass table

Figure 14 shows a sequence of four images of a ceramicbowl, sitting on a thick glass table, broken by the impactof a falling bowling ball. For this example, the strength ofthe constraints in both broken objects (the bowl and thetable-top) were initially homogeneous and modified only by



Figure 14: A bowling ball is dropped onto a ceramic bowl that is sitting on a thick glass table.

Figure 15: A close-up of the breaking table and bowl.

our simple geometric heuristics. The crack growth functionused in the table was that described in Equation (4) whichcontributed to the formation of the long, narrow glass-likefragments.

4.4. Timing

Two major steps are involved in the destruction and subse-quent animation of a shattered object: the impact calcula-tion, and the reconstruction of the new fragments’ surfacesafterwards. Figure 12 shows the amount of time required foreach impact step calculation as a function of the number ofconstraints (shared faces) in the lattice model. (All timingwas done on a 195 MHz R10000 SGI Octane.)

As can be seen, even for relatively large objects the impactsimulation is computationally inexpensive. Since we arerepeatedly solving a sparse linear system with the conjugategradient method, our computational cost is O(m

√k), where

m is the number of non-zero entries in J W J T , and k is theratio of the largest to the smallest eigenvalues of this matrix[13].

Reconstruction of the fragments after impact requiressimilarly few resources. Figure 13 shows the time requiredto construct the surfaces and velocities of the new fragmentsafter impact. These times could be significantly reducedby the use of a more efficient algorithm for separating thefragments from one another. Even with this inefficiency,however, the total time required to break and reconstructmodels of moderate size (several thousand constraints) isonly a few minutes.

5. Conclusion

We have presented a fast and controllable method for thesimulation of the shattering of brittle objects. By framing theproblem in terms of distance-preserving constraints ratherthan stiff springs, we have avoided expensive explicit so-lution methods while retaining physical accuracy. Further-more, our method allows simple control over the ultimatenumber, size and shape of the fragments by adjusting thestrength of the constraints throughout the body or by chang-ing the nature of crack growth within the material. Com-bined with speed and accuracy, this controllability makes ourmethod useful for the otherwise difficult task of animatingcomplex, realistic shattering.

References

1. D. Terzopoulos and K. Fleischer. Modeling inelas-tic deformation: Viscoelasticity, plasticity, fracture.SIGGRAPH 88 Conference Proceedings, 22:287–296,1988.

2. A. Norton, G. Turk, B. Bacon, J. Gerth and P. Sweeney.Animation of fracture by physical modeling. VisualComputing, 7(4):210–219, 1991.

3. J. O’Brien and J. Hodgins. Graphical modeling andanimation of brittle fracture. SIGGRAPH 99 ConferenceProceedings, 33:287–296, 1999.

4. G. P. Cherepanov. Mechanics of Brittle Fracture.McGraw-Hill, New York, 1979.



5. S. Arbabi and M. Sahimi. Elastic properties of three-dimensional percolation networks with stretching andbond-bending forces. Physical Review B, 38(10):7173–7176, 1988.

6. J. W. Chung, A. Roos and J. Th. M. De Hosson. Fractureof disordered three-dimensional spring networks: acomputer simulation methodology. Physical Review B,54:15094–15100,21.

7. F. Donze and S.-A. Magnier. Formulation of a 3-d numerical model of brittle behavior. GeophysicalJournal International, 122(3):709–802, 1995.

8. K. Perlin. An image synthesizer. SIGGRAPH 85Conference Proceedings, 19(3):287–296, 1985.

9. A. Witkin and D. Baraff. Physically Based Mod-eling: Principles and Practice. Chapter: Physicallybased modeling. SIGGRAPH Course Notes. ACMSIGGRAPH, 1997.

10. A. Witkin, M. Gleicher and W. Welch. Interactivedynamics. In Proceedings of the 1990 Symposium onInteractive 3D Graphics, vol. 24. pp. 11–21. 1990.

11. A. A. Griffith. The theory of rupture. The Proceedingsof The First International Congress of Applied Mechan-ics. 1924.

12. G. Strang. Linear Algebra and its Applications.Harcourt Brace Jovanovich, New York, 1988.

13. Jonathan R. Shewchuk. An introduction to the conjugategradient method without the agonizing pain, TechnicalReport CMU-CS-94-125, 1994.

14. B. Lawn. Fracture of Brittle Solids. Chapter 1:The Griffith concept. Cambridge University Press,Cambridge, 1993.

15. C. B. Barber, D. P. Dobkin and H. T. Huhdanpaa.The quickhull algorithm for convex hulls. In ACMTransactions on Mathematical Software. 1996.


Documents

Fast and Controllable Simulation of the Shattering of Brittle Objects