The Visual Computer manuscript No.(will be inserted by the editor)

Jinwook Kim · Soojae Kim · Heedong Ko · Demetri Terzopoulos

Fast GPU Computation of the Mass Properties of aGeneral Shape and its Application to Buoyancy Simulation

Abstract To simulate solid dynamics, we must com-pute the mass, the center of mass, and the products ofinertia about the axes of the body of interest. Thesemass property computations must be continuously re-peated for certain simulations with rigid bodies or asthe shape of the body changes. We introduce a GPU-friendly algorithm to approximate the mass propertiesfor an arbitrarily shaped body. Our algorithm convertsthe necessary volume integrals into surface integrals ona projected plane. It then maps the plane into a frame-buffer in order to perform the surface integrals rapidlyon the GPU. To deal with non-convex shapes, we use adepth-peeling algorithm. Our approach is image-based;hence, it is not restricted by the mathematical or geo-metric representation of the body, which means that itcan efficiently compute the mass properties of any ob-ject that can be rendered on the graphics hardware. Wecompare the speed and accuracy of our algorithm with ananalytic algorithm, and demonstrate it in a hydrostaticbuoyancy simulation for real-time applications, such asinteractive games.

Keywords General-purpose computation on GPUs ·Mass property computation · Physics-based animation ·Rigid-body dynamics · Buoyancy simulation

J. Kim, S. Kim, H. KoImaging Media Research CenterKorea Institute of Science and Technology39-1 Hawolgok-dong, Seongbuk-gu, Seoul, 136-791, KoreaE-mail: {jwkim, lono, ko}@imrc.kist.re.kr

D. TerzopoulosDepartment of Computer ScienceUniversity of CaliforniaLos Angeles, CA 90095, USAE-mail: dt@cs.ucla.edu

1 Introduction

The fast calculation of mass properties, including themass, center of mass, and products of inertia, is neces-sary for the dynamic simulation of solids. In rigid bodydynamics, the mass properties are usually assumed tobe constant during the simulation. Therefore, the com-putation can be performed in an initialization step andthe computed values are used in the subsequent simu-lation. Hence, the computational cost to calculate massproperties is often negligible. In certain important cases,however, the mass properties can change during the sim-ulation and complex geometric shapes may require ex-pensive mass property computations.

Among these cases is the simulation of hydrostaticbuoyancy. Buoyancy is a natural phenomenon resultingfrom the interplay between a fluid system and a floatingrigid body system. If we assume a hydrostatic pressurecondition for the fluid system, then we can simulate themotion of the rigid body floating in the fluid by applyinga buoyant force to the center of mass of the instanta-neous submerged volume, which is known as the centerof buoyancy. The buoyant force itself is proportional tothe instantaneous submerged volume. A problem here,of course, is that the submerged volume changes contin-uously. Consequently, the computation of its mass prop-erties can be a major bottleneck of the simulation.

Most of the research in computing the mass proper-ties of solid shapes can be applied only to specific solidrepresentation schemes and, therefore, it may involve anexpensive representation conversion process [11]. Gon-zalez et al. [6] combined a polynomial free-form surfacerepresentation with the Gauss divergence theorem to ef-ficiently calculate the moments of the enclosed object.However, their approach allows only piecewise polyno-mial surface patches. Mirtich [13] proposed an efficientmethod to compute the center of mass and higher-ordermoments for polyhedral objects. The proposed algorithmis based upon a three step reduction of the volume in-tegrals to successively simpler integrals. The final stepof the algorithm computes the required integrals over a

2 Jinwook Kim et al.

face from the coordinates of the projected vertices. Thismeans that the computation is done by algebraic oper-ations with vertex coordinate values. Even though thismethod is computationally efficient for fixed polyhedralobjects, its efficiency can suffer if the geometric struc-ture changes frequently as it may require an expensivereconstruction of a set of vertices and faces. Unfortu-nately, the typical situation in buoyancy simulations re-quires repeated updates of vertex coordinates and evenof the number of relevant vertices. This is because thesubmerged volume is defined as the intersection of a ge-ometric object representing the fluid system with a geo-metric object representing the floating rigid body.

In this paper, we propose a GPU-friendly algorithmto compute the mass properties determined by generalgeometries. Our approach is essentially image-based. Be-cause of this, it is not restricted by the mathematical orgeometric representation of rigid bodies. Regardless ofthe geometric representations employed, whether they bepolyhedral approximation, free-form surfaces, construc-tive solid geometry, etc., if it is possible to render anobject of interest on the GPU, then our algorithm canapproximate the object’s mass properties, exploiting theefficiency of the GPU.

Recent advances in the programmability of graph-ics hardware have enabled its use for general purposecomputation, not restricted to rendering [16]. Variousproblems in scientific computation, including fluid dy-namic simulation, the solution of linear systems of al-gebraic equations, nonlinear optimization, and volumerendering, have been addressed by taking advantage ofthe parallelism and programmability of GPUs [1,7–9,14,17]. Moreover, programmable GPUs are getting fasterand cheaper. Our algorithm accrues these benefits byexploiting the GPU to calculate mass properties. It firstcomputes the mass, the center of mass, and the productsof inertia by reducing volume integrals into surface inte-grals. It projects surfaces of the rigid body onto a planethat corresponds to the frame buffer of a rendering pro-cess. Next, it computes the integrands on the GPU. Fi-nally, it performs a summation operation using a bufferreduction to obtain the desired result.

To perform the required integral operations over allthe surfaces representing the non-convex geometric ob-ject, we use a depth-peeling algorithm to obtain each ofthe surface patches regardless of convexity. The depth-peeling is a fragment level depth sorting algorithm, whichachieves a correct rendering of transparent objects thatare located order independently [4,12]. The objectiveof the method is to find the fragments of geometry ina systematic manner. We focus our attention on thismethod because it can access all the fragments represent-ing the geometry regardless of its convexity. We modifythe original depth peeling algorithm to obtain surfacepeels, which are surface patches beneath the fluid in ourbuoyancy simulation, as well as the intersection surfacebetween the fluid and the rigid body.

The remainder of the paper is organized as follows:Section 2 reviews rigid body mass properties and derivesthem in the form of surface integrals over the projectedplane. Section 3 introduces our GPU-friendly algorithmfor computing the mass properties determined by non-convex geometry. Section 4 presents an error and perfor-mance analysis of our approach compared to the analyticmethod proposed by Mirtich [13]. Section 5 modifies anoriginal depth-peeling algorithm to deal with hydrostaticbuoyancy simulation and shows an example of interactiverigid body dynamics simulation under buoyancy. Finally,Section 6 draws conclusions from our work.

2 Rigid body mass properties

2.1 Computing mass properties with volume integrals

The mass of a rigid body is given by

m =∫

V

ρ(x, y, z) dV, (1)

where ρ(x, y, z) is the mass distribution function of thebody and V is its volume. If we assume ρ(x, y, z) to beconstant over the volume, the expression for the masssimplifies to m = ρV . In this paper, the mass distri-bution function will be considered a constant value forsimplicity.

The center of mass r and the inertia tensor I aregiven by

r =1V

∫V

x

yz

dV,

I = ρ

∫V

(y2 + z2) −xy −xz

−yx (z2 + x2) −yz−zx −zy (x2 + y2)

dV.

(2)

2.2 Reduction to surface integrals on a projected plane

To calculate the mass properties of a rigid body effi-ciently, we exploit the divergence theorem as suggestedby Gonzalez et al. [6]. According to the divergence theo-rem, an integral over the three-dimensional volume canbe transformed into an integral over its boundary surfaceas follows:∫

V

∇ · f dV =∫

∂V

f · n dA, (3)

where f is a continuously differentiable vector field de-fined on a neighborhood of V , where n = [nx, ny, nz]′denotes the exterior normal vector of V along its bound-ary ∂V, and where dA is the infinitesimal surface areaof the boundary. When the volume is represented by abounding polyhedron, its boundary is the set of planar

Fast GPU Computation of the Mass Properties of a General Shape and its Application to Buoyancy Simulation 3

polygons comprising its faces. If we set f = [0, 0, z]′, thenwe obtain the volume as V =

∫∂V

znz dA. Similarly,setting f in turn to [0, 0, xz]′, [0, 0, yz]′, and [0, 0, 1

2z2]′

yields∫

Vx dV =

∫∂V

xznz dA,∫

Vy dV =

∫∂V

yznz dA,and

∫V

z dV =∫

∂V12z2nz dA, respectively.

Now, we slightly modify (3) by projecting the bound-ary surface area element dA onto the xy plane. From Fig-ure 1, we see that the relationship between the infinitesi-mal surface area dA and the projected surface area dx dyis dx dy = |nz| dA if the surface normal vector has unitlength.

Fig. 1 Projection of the infinitesimal surface area element.

Finally, we obtain the volume V and the center ofmass r = [rx, ry, rz]′ as follows:

V =∫

∂V

sgn(nz)z dx dy,

rx =1V

∫∂V

sgn(nz)xz dx dy,

ry =1V

∫∂V

sgn(nz)yz dx dy,

rz =1

2V

∫∂V

sgn(nz)z2 dx dy,

(4)

where sgn(x) denotes the signum function which extractsthe sign of a real number x. Note that the integrals arecomputed on the planar surface area, which is achievedby projecting the surface boundary onto the xy plane.When the surface area element dA is projected on the xyplane, it will be singular if nz = 0. Hence, an improperchoice of f (e.g., f = [x, 0, 0]′ to compute the volume)can lead to a singularity at the boundary of a projectedsurface, where it would require division by a very smallnumber. Our proposed fs, however, only require multipli-cation by sgn(nz), thus avoiding the singularity problemat the boundaries.

The inertia tensor I is

I = ρ

Ixx −Ixy −Ixz

−Ixy Iyy −Iyz

−Ixz −Iyz Izz

, (5)

where the moments and products of inertia are similarlygiven as follows:

Ixx =∫

∂V

sgn(nz)x2z dx dy,

Ixy =∫

∂V

sgn(nz)xyz dx dy,

Iyy =∫

∂V

sgn(nz)y2z dx dy,

Ixz =12

∫∂V

sgn(nz)xz2 dx dy,

Iyz =12

∫∂V

sgn(nz)yz2 dx dy,

Izz =13

∫∂V

sgn(nz)z3 dx dy.

(6)

3 Computing mass properties on the GPU

3.1 Shader implementation

The programmability of recent graphics hardware andthe various choices of precision and formats of frame-buffers enable us to implement mass property compu-tations on GPUs in an easy and flexible way. The in-tegrands in equations (4) and (6) can be evaluated dis-cretely at each pixel in a framebuffer by GPU program-ming. The process is straightforward:

1. Render the geometry with an orthographic projectiononto the xy plane;

2. Evaluate the integrands on a fragment shader;3. Encode the evaluated values at the output buffers.

The number of parameters that must be computedis 10 in total, including 1 for volume, 3 for the center ofmass, and 6 for the moments and products of inertia. Tostore these parameters, we use three framebuffers, eachof which can contain four values in the red, green, blueand alpha channel. This can be efficiently implementedusing the “multiple render target” capability of recentgraphics hardware, which enables the fragment shaderto save per-pixel data in multiple buffers.

Hence, we obtain color buffers containing the valuesof integrands in equations (4) and (6). Furthermore, theintegration of the values over the projected plane areacan be performed by reading back fragment color valuesof the framebuffers and summing them up, or by usinga buffer reduction algorithm as will be explained in thenext section. A fragment shader can be implemented inthe OpenGL Shading Language [15] very easily, as fol-lows:

4 Jinwook Kim et al.

// homogeneous coordinate of a point on the surfacevarying vec4 p;

// z component of the surface normalvarying float n_z;

void main(void){

float c = sign(n_z) * p.z;

// (rx, ry, rz, V)gl_FragData[0] = c * p;

// (Ixx, Ixy, Ixz, .)gl_FragData[1] = p.x * gl_FragData[0];

// (Iyy, Iyz, Izz, .)gl_FragData[2] = c * vec4(p.y * p.y, p.y * p.z, p.z * p.z, 0);

}

Note that the fourth components of gl FragData[1] andgl FragData[2] are not used.

A potential problem is how to generate color bufferscovering all the surface fragments of the geometric shape.Consider the case of a sphere. The surface of a spherecan be divided into two patches—the north and southhemispheres—according to the direction of surface nor-mals. If we look at the sphere from the negative z view-ing direction, the line of sight will intersect the spheretwice. That is, the typical rendering pipelines will ren-der two fragments from those two surface patches onone pixel in the framebuffer and, therefore, the resultingcolor buffer will contain only one of the fragments fromthe two surface patches regardless of the choice of thedepth test function. To resolve this problem, we use thedepth-peeling algorithm discussed in the next section.

3.2 Depth-peeling

Using the standard depth test function of the 3D graph-ics API, we can obtain the nearest surface fragment fromthe eye at each pixel. Although the second nearest orother fragments may be required in some areas, there isno straightforward way to obtain the nth nearest frag-ment. One possible solution is to use a depth-peelingalgorithm, which is a fragment-level depth sorting tech-nique [12]. Depth-peeling can be implemented as a multi-pass algorithm. In the first rendering pass, the geometriesare rendered using a normal “less-than” depth function.This will yield a depth buffer containing the depth valuesof the nearest surface of the geometry. In the next ren-dering pass, only the fragment for which depth is greaterthan the depth values in the buffer from the previouspass are rendered. Then the depth buffer will contain thedepth values of the next nearest surface of the geometry,and so on. The process repeats until the depth values ofall the surface fragments are found. The depth-peelingtechnique introduced by Everitt [4] requires a shadowbuffer to peel away the surfaces by comparing depthvalues. However, since recent GPUs and APIs support“render-to-texture” capabilities and the direct manipula-tion of pixel values on fragment processors using shading

languages, depth-peeling can be implemented using pro-grammable GPUs and the modification of the algorithmis even easier.

For our objective of computing mass properties, wecan apply the standard depth-peeling algorithm with theshader developed in the previous section. As a result, weobtain n textures containing the enumerated integrandvalues in equations (4) and (6), where n is a total numberof peels.

3.3 Two-dimensional integrals over the projected areausing buffer reduction

Using the textures obtained in the previous section, wecompute the two-dimensional integrals over the projectedsurfaces in order to obtain mass properties. A straight-forward way to perform the integration is to read allevaluated integrands from framebuffers and sum them.Given current graphic memory interfaces, however, read-ing back a texture memory directly into system memorycan yield significant latency. To tackle this problem, weuse buffer reduction [2]. To summarize the buffer reduc-tion technique, a fragment program reads two or morevalues from the buffer and computes a new value usingthe reduction operator, which in our case is an additionoperation. These passes continue until the output is re-duced to a single value, the sum. In general, this processtakes O(log n) passes, where n is the number of elementsto reduce. Figure 2 illustrates a reduction operation tocalculate the sum.

2 3 4 15 6 23 24 15

14 4 3 2 3 16 13 17

12 6 5 3 8 4 12 17

3 9 8 6 14 13 15 26

5 8 9 11 8 16 18 21

11 14 12 27 24 12 23 16

23 3 6 17 24 16 5 18

19 15 13 15 4 17 24 9

23 24 48 69

30 22 39 70

38 59 60 78

60 51 61 56

8X8 4X4 2X2 1X1

Fig. 2 Summation reduction procedure.

4 Performance

In this section, we compare our algorithm in terms of ac-curacy and speed with the analytic method developed byMirtich [13]. Since the analytic method used in this testis restricted only to polyhedra, we use shapes approxi-mated by polyhedra as test objects. Figure 3 illustratessome of these objects. It is important to note, however,that our algorithm can be applied to any model that canbe rendered on graphics hardware. All the tests were runon a 2.53GHz Pentium 4 CPU with an NVidia GeForce7800 GTX GPU. 32-bit floating point textures were usedfor framebuffers. Table 1 lists all the geometric test ob-jects and the number of peels for each test object.

Fast GPU Computation of the Mass Properties of a General Shape and its Application to Buoyancy Simulation 5

knot bunny pipe

Fig. 3 Some polyhedral test objects.

object vertices faces peels

cube 8 12 2sphere 422 840 2teapot 821 1628 6torus 1024 1922 4knot 1440 2880 8

bunny 2557 5110 6pipe 4626 9252 6

Table 1 Geometric information for the test objects.

4.1 Error analysis

We measured the relative error of the mass and the mo-ments of inertia Ixx, Iyy, and Izz at various framebufferresolutions. The other mass property values are verysmall for our test objects, because the shapes are approx-imately symmetric along axes. Our approach computesintegrands for each fragment on the GPU, where we usetexture memories as framebuffers. Hence, the resolutionsof the framebuffers are critical for accurate results. Asshown in Figure 4, a resolution of 32×32 was sufficientto compute the mass properties within a 5% error bound.

4.2 Performance analysis

We now compare the performance of our algorithm andthe analytic method. If we assume that the cost of ver-tex processing on the GPU is negligible compared to thecost of fragment processing, the complexity of our algo-rithm is approximately O(kn2), where k is the numberof rendering passes for the depth-peeling and n is theframebuffer resolution along its width or height. On theother hand, the complexity of the analytic method isO(m), where m represents the number of faces of thepolyhedron. Figure 5 shows a comparison of the compu-tation times for the analytic method and our GPU-basedmethod at three different framebuffer resolutions.

We observed that our GPU-based approach is compa-rable to the analytic method in terms of computationalcost. At 64×64 resolution, our algorithm outperforms theanalytic method for moderately complex shapes such asthe bunny or the pipe. However it also shows the down-side of quadratic complexity for a resolution of 128×128or more. For example, it is obvious that the analyticmethod is preferable to our GPU-based method for low-polygon-count models such as a cube. The computational

cube mass cube Ixx cube Iyycube Izz sphere mass sphere Ixxsphere Iyy sphere Izz teapot massteapot Ixx teapot Iyy teapot Izz

16

64

256

32

128

torus mass torus Ixx torus Iyy torus Izzknot mass knot Ixx knot Iyy knot Izzbunny mass bunny Ixx bunny Iyy bunny Izzpipe mass pipe Ixx pipe Iyy pipe Izz

6432

128256

16

Fig. 4 Relative error comparisons.

Fig. 5 Computational time comparison of analytic methodand GPU-based method.

6 Jinwook Kim et al.

cost of the analytic method for the cube is so small thatwe could not distinguishably display it in the graph.

5 Case study: Buoyancy simulation

The beauty of our image-based approach is that it is notrestricted to any particular mathematical or geometricshape representation. It can efficiently compute the massproperties of arbitrary objects, so long as they can berendered efficiently on graphics hardware. As an exampleapplication of our algorithm, we will now demonstrate aninteractive, hydrostatic buoyancy simulation.

5.1 Hydrostatic buoyancy

One of the most popular simplifications of fluid motionis the shallow water model [10] which assumes zero vis-cosity and considers only two-dimensional motions. Aninteresting fact of the shallow water model is that thepressure field is characterized by the hydrostatic equilib-rium condition:

p = ρgh, (7)

where g is the gravitational acceleration and h is thedepth of the fluid. This very simple pressure model workswell with the shallow water model, and it correspondsexactly to the observation of Archimedes.

According to Archimedes’ principle, a body immersedin a fluid experiences a vertical buoyant force equal to theweight of the fluid that it displaces. The buoyant forceacts on the center of mass of the submerged volume.Figure 6 illustrates a rigid body partially immersed in afluid. Assuming a stationary fluid system, two forces areacting on the body at this instant. The first is the forceof gravity that acts downwards at the center of gravityC, while the second is a buoyant force which acts up-wards at the center of buoyancy B, which is the centerof mass of the immersed part of the rigid body (assum-ing that the immersed portion consisted of fluid). Themagnitude of the buoyant force is proportional to theweight of the submerged volume of fluid. The imbalancebetween gravity and the buoyant force induces a torquethat will rotate the body to restore a static equilibrium.

The simulation of fluid motion is out of the scope ofour work.1 Instead we focus on the rigid body motion ofan object floating on fluid due to the hydrostatic buoy-ant force. To simulate hydrostatic buoyancy, we computethe volume and the center of mass of the submerged part

1 Foster and Metaxas [5] demonstrate a simplified schemefor coupling buoyant objects to the results of a Navier-Stokesfluid simulation. Carlson et al. [3] simulate the interplay be-tween rigid bodies and viscous incompressible fluid.

Fig. 6 Buoyant force and gravity acting on a partially sub-merged rigid body.

of the body at every simulation time instant. If the ge-ometries of a fluid body and a rigid body are compli-cated, calculating their intersection requires a consider-able amount of computation and can become a bottle-neck in the simulation process. In the following section,we tackle this problem by modifying the depth-peelingalgorithm.

5.2 Boundary surfaces of an intersection volume of anonconvex geometry and a fluid surface

We improve the original depth-peeling technique to ac-count for all the projected fragments of the geometry be-low the fluid surface. For simplicity, let us assume thatthe signs of the z components of the fluid surface normalvectors do not change. Our algorithm considers surfacesfrom the rigid body and the fluid surface intersecting thegeometry separately. The multi-pass rendering procedureto handle the surfaces of a submerged volume is as fol-lows (note that an orthographic projection is applied torender the scene with the negative z viewing direction asshown in Figure 7):

Fig. 7 Multi-pass rendering to obtain all surface patches.

Fast GPU Computation of the Mass Properties of a General Shape and its Application to Buoyancy Simulation 7

Pass 0: Render the surface of the fluid, storing its depthvalues into a texture Tdw as a reference.

Pass 1: Render the object geometry to a texture T1. Inour fragment shader, the integrands in equation (4)—i.e., sgn(nz)xz, sgn(nz)yz, sgn(nz)z2, and sgn(nz)z—are evaluated and the output color is composed oftheir values. Also, the depth values are stored in atexture Td1. During this rendering pass, the frag-ments whose depth value is less than the fluid sur-face depth are discarded to inhibit the operation.The texture Tdw generated in rendering Pass 0, isused to lookup the depth value of the fluid surface.In Figure 7, the solid black lines correspond to thefragments.

Pass 2: Render the geometry to a texture T2. As in theprevious rendering pass, the integrands are evaluatedand their values are assigned to the output color.Here, only the fragments whose depth value is greaterthan the fluid surface depth and the depth value ofTd1 are accepted in order to peel away the surfacepatch obtained in the previous rendering pass. InFigure 7, the dashed lines indicate peeled away frag-ments. A depth texture Td2 is initialized with Td1 andoverwritten with the depth values of the currentlyprocessed fragments.

Pass n: Repeat the same process as in rendering Pass2 until all the object fragments are found and evalu-ated.

Thus, we obtain n textures, and the texture Tn containsthe evaluated integrand values of the nth surface patch.

Now, the only remaining surface patch is the fluidsurface intersecting with the rigid body geometry. Asillustrated in Figure 8, the surface patches of renderingPass 1 consist of upward and downward faces. The fluidsurface intersecting with the rigid body geometry canbe obtained by drawing the fluid surface only for thosefragments having a downward normal in rendering Pass1. Note that a more efficient implementation results if thefragment shader can write a stencil bit into the outputframebuffer in rendering Pass 1. Finally, we evaluate theintegrand for the fluid surface patch intersecting the rigidbody geometry and write the value in a texture Tw.

In summary, our algorithm requires a total of n + 2rendering passes to cover all the surface patches of apartially submerged rigid body geometry, where n rep-resents the maximum number of intersection points ofthe submerged part of the geometry with the z axis. Thefirst rendering pass generates a reference depth texturefrom the fluid surface. In the next n rendering passes, in-tegrands are evaluated for each fragment of the geometrysurface and the resulting values are stored in textures Ti.The final rendering pass evaluates the integrand for thefluid surface patch that intersects the rigid body geome-try and stores the values in a texture Tw.

Finally, we apply the summation reduction proceduredescribed in Section 3.3 to evaluate the integral expres-sions for the volume of the immersed portion of the ob-

Fig. 8 Intersecting the surface of the fluid body with a rigidbody.

ject and the center of buoyancy in order to evaluate thebuoyant force and its point of application in the object.

5.3 Simulation example

Fig. 9 Interactive simulation of 50 rigid bodies floating inwater.

Figure 9 shows a typical scene from our interactivesimulations of buoyant objects. Ten spheres, 10 rectan-gular boxes, 10 tori, 10 teapots, and 10 Stanford bun-nies were tested. Boxes with density higher than thatof the water were observed to sink as expected. We alsomodeled a viscous drag force acting at the center of buoy-ancy with magnitude proportional to the submerged vol-ume and the square of the body velocity. The simulationruns on the CPU of a 2.56GHz Pentium 4 PC employ-ing an NVIDIA GeForce 7800 GTX GPU. The averageframe rate of the example shown in the figure was 16frames/sec. Over 90% of the computational resourceswere consumed in calculating the buoyant force.

For spherical and rectangular bodies, depth-peelingwas applied twice to compute the submerged volumeof the object geometries. For the teapot and Stanford

8 Jinwook Kim et al.

bunny bodies, depth-peeling was applied a maximum of6 times, but in most cases 3 or 4 peels sufficed to coverthe submerged volume. The framebuffer resolution usedin this example was 32×32, allowing at most 5% approx-imation error. The leftmost images in Figure 10 show thegravity force (downward blue arrow) and buoyant force(upward yellow arrow) acting on a bunny, a torus, anda teapot. The remaining images are color buffers thatencode the integrands for each peel, as described in theprevious section. Since the framebuffers use a floatingpoint texture format that cannot be illustrated properly,we have transformed the values so that they map to acolor range of [0,1].

Fig. 10 Color encoded integrands of each peel for the buoy-ant bunny, torus, and teapot (left).

6 Conclusion

We have proposed a GPU-friendly algorithm for com-puting the mass properties of a rigid body representedby a general geometry. We formulated the mass prop-erties as surface integrals on a projected plane, avoid-ing singularities at the boundaries. We also showed thatdepth-peeling techniques can be exploited to tackle non-convex geometries. Our approach is essentially image-based. Consequently, it can efficiently compute mass prop-erties as long as the geometries can be rendered usinggraphics hardware.

We applied our algorithm to simulate rigid body mo-tion in a real-time hydrostatic buoyancy simulation. Themass properties of the submerged volume were efficientlycomputed without an explicit reconstruction of the in-tersecting geometry between the fluid and the rigid bod-ies. Our algorithm approximates mass properties fairlyaccurately, even using low resolution framebuffers. Ourinteractive simulation demonstrates that the proposedalgorithm can be applied to animate floating rigid bod-

ies on a stationary fluid system in a fast and plausibleway.

Acknowledgements The material presented herein is basedupon work supported by the Information and Telecommuni-cation National Scholarship Program supervised by IITA andthe Ministry of Information and Communication, Republic ofKorea.

References

1. Bolz, J., Farmer, I., Grinspun, E., Schrooder, P.: Sparsematrix solvers on the GPU: conjugate gradients andmultigrid. ACM Trans. Graph. 22(3), 917–924 (2003)

2. Buck, I., Purcell, T.: GPU Gems 2, chap. A toolkit forcomputation on GPUs. Addison-Wesley (2004)

3. Carlson, M., Mucha, P.J., Turk, G.: Rigid fluid: Animat-ing the interplay between rigid bodies and fluid. ACMTransactions on Graphics 23(3), 377–384 (2004)

4. Everitt, C.: Interactive order-independent transparency(2001). URL citeseer.ist.psu.edu/everitt01interactive.html

5. Foster, N., Metaxas, D.: Realistic animation of liquids.Graphical Models and Image Processing 58(5), 471–483(1996)

6. Gonzalez-Ochoa, C., McCammon, S., Peters, J.: Comput-ing moments of objects enclosed by piecewise polynomialsurfaces. ACM Transactions on Graphics 17, 143–157(1998)

7. Hillesland, K.E., Molinov, S., Grzeszczuk, R.: Nonlin-ear optimization framework for image-based modeling onprogrammable graphics hardware. ACM Transactions onGraphics 22(3), 925–934 (2003)

8. Kruger, J., Westermann, R.: Acceleration techniques forGPU-based volume rendering. In: VIS ’03: Proceedings ofthe 14th IEEE Visualization 2003 (VIS’03), p. 38. IEEEComputer Society, Washington, DC, USA (2003)

9. Kruger, J., Westermann, R.: Linear algebra operatorsfor GPU implementation of numerical algorithms. ACMTransactions on Graphics (TOG) 22(3), 908–916 (2003)

10. Layton, A.T., van de Panne, M.: A numerically efficientand stable algorithm for animating water waves. TheVisual Computer 18(1), 41–53 (2002)

11. Lee, Y.T., Requicha, A.A.: Algorithms for computing thevolume and other integral properties of solids. I. Knownmethods and open issues. Communications of the ACM25(9), 635–641 (1982)

12. Mammen, A.: Transparency and antialiasing algorithmsimplemented with the virtual pixel maps technique.IEEE Computer Graphics and Applications 9(4), 43–55(1989)

13. Mirtich, B.: Fast and accurate computation of polyhedralmass properties. Journal of Graphics Tools 1(2), 31–50(1996)

14. Moreland, K., Angel, E.: The FFT on a GPU. In: HWWS’03: Proceedings of the ACM SIGGRAPH/EurographicsConference on Graphics Hardware, pp. 112–119. Euro-graphics Association, Aire-la-Ville, Switzerland (2003)

15. Rost, R.J.: OpenGL Shading Language. Addison-WesleyLongman, Redwood City, CA (2004)

16. Thompson, C.J., Hahn, S., Oskin, M.: Using moderngraphics architectures for general purpose computing:A framework and analysis. In: Proceedings of theACM/IEEE International Symposium on Microarchitec-ture, pp. 306–317 (2002)

17. Wu, E., Liu, Y., Liu, X.: An improved study of real-time fluid simulation on GPU. Computer Animation andVirtual Worlds 15(3–4), 139–146 (2004)

Fast GPU Computation of the Mass Properties of a General Shape and its Application to Buoyancy Simulation 9

Jinwook Kim received theBS degree in Mechanical De-sign and Production Engineer-ing from Seoul National Uni-versity in 1995 and the MSand PhD degrees in Mechani-cal and Aerospace Engineeringfrom Seoul National Universityin 1997 and 2002, respectively.He was at New York Universityand at the University of Cali-fornia, Los Angeles, as a post-doctoral researcher and is cur-rently a senior research scien-tist at Korea Institute of Sci-ence and Technology in Seoul,Korea. His research interests

include real-time physics-based simulation, general-purposecomputation on GPUs, and simulation-based human motiongeneration.

Soojae Kim has developed3D graphics rendering enginesfor various game titles since2000. He is scheduled to grad-uate both in Computer Scienceand Business Administrationfrom Yonsei University in 2007.His research interests includereal-time global illuminationmethods and general-purposecomputation on GPUs.

Heedong Ko is a principalresearch scientist and head ofthe Imaging Media ResearchCenter at the Korea Instituteof Science and Technology inSeoul, Korea. His research in-terests include semantic vir-tual environments, context-aware multimodal interaction,and tangible space interaction.He received the PhD in Com-puter Science from the Uni-versity of Illinois at Urbana-Champaign in the USA.

Demetri Terzopoulos (PhD’84 MIT) is the Chancellor’sProfessor of Computer Scienceat the University of California,Los Angeles. An IEEE Fellowand a member of the Euro-pean Academy of Sciences, heis the recipient of an AcademyAward for Technical Achieve-ment from the Academy ofMotion Picture Arts and Sci-ences. Among his many otherhonors are computer graph-ics awards from Ars Electron-ica, NICOGRAPH, Computersand Graphics, and the Interna-tional Digital Media Founda-

tion. The author or co-author of approximately 300 researchpublications, Terzopoulos is one of the most highly-cited engi-neers and computer scientists in the world. He was a plenaryspeaker at PG’95 and a program chair of PG’04.