Ray-tracing Procedural Displacement Shaders
Wolfgang Heidrich and Hans-Peter Seidel Computer Graphics Group University of Erlangen {heidrich,seidel}@informatik.uni-erlangen.de
Abstract displacement shaders are resolution independent and
Displacement maps and procedural displacement storage e cient. shaders are a widely used approach of specifying geo- metric detail and increasing the visual complexity of a scene. While it is relatively straightforward to handle displacement shaders in pipeline based rendering systems such as the Reyes-architecture, it is much harder to e ciently integrate displacement-mapped surfaces in ray-tracers. Many commercial ray-tracers tessellate the surface into a multitude of small trian- Figure 1: A simple displacement shader showing a gles. This introduces a series of problems such as wave function with exponential decay. The underly- excessive memory consumption and possibly unde- ing geometry used for this image is a planar polygon. tected surface detail. In this paper we describe a novel way of ray-tracing Unfortunately, because displacement shaders mod- procedural displacement shaders directly, that is, ify the geometry, their use in many rendering systems without introducing intermediate geometry. A ne is limited. Since ray-tracers cannot handle proce- arithmetic is used to compute bounding boxes for dural displacements directly, many commercial ray- the shader over any range in the parameter domain. tracing systems, such as Alias [1], tessellate geomet- The method is comparable to the direct ray-tracing ric objects with displacement shaders into a mul- of B ezier surfaces and implicit surfaces using B ezier titude of small triangles. Unlike in pipeline-based clipping and interval methods, respectively. renderers, such as the Reyes-architecture [17], these Keywords: ray-tracing, displacement-mapping, pro- triangles have to be kept around, and cannot be ren- cedural shaders, affine arithmetic dered independently. This approach, however, defeats two of the reasons 1 Motivation for using procedural displacements in the rst place: Procedural displacement shaders [7] are an impor- resolution independence and storage e ciency. The tant means of specifying geometric detail and surface storage requirements for representing a large number imperfections in synthetic scenes, which increases the of polygons (often hundreds of thousands or more), realism of computer generated images. Small surface as well as the spatial subdivision hierarchy required features, which would be tedious to model explic- for speeding up the intersection tests (often octrees) itly using a geometric modeling system, can often can be excessive, even for relatively simple shaders. be described by a few lines of code in a dedicated But tessellation-based methods also bear other, shading language, such as the RenderMan Shading more fundamental problems. Because the shader can Language [20, 10, 24]. only be evaluated at a discrete set of points, the ver- In contrast to simple surface shaders and bump tices of the output polygons, it is possible to miss maps [4], displacement shaders actually change the narrow features. This is particularly disturbing if geometry of the underlying surface. This allows for the displacements of those features are large. Most e ects like self-occlusion and self-shadowing, and re- existing systems either disallow long and skinny dis- sults in more realistically looking images, in partic- placements, or require the user to explicitly specify ular in silhouette regions (see Figure 1). Procedural bounding volumes for them. As a nal problem, numerical errors may oc- surface potentially passes through the cell, and the cur in intersection tests with many small polygons. cell is subdivided in an octree fashion, unless it is al- These can result in cracks between adjacent poly- ready small enough. Unlike Lipschitz bounds, inter- gons, which are di cult to avoid in implementations. val bounds can be automatically computed by spe- Given the potential bene ts of displacement ci c implementations of the basic library functions. shaders, and the shortcomings of tessellation-based Comba and Stol [5] and Figueiredo and Stol [9] implementations, the question is whether there is a used a similar algorithm, but replaced interval arith- way to directly ray-trace procedural displacements. metic with a ne arithmetic, which they developed Such an algorithm should work directly on the proce- for this purpose. They showed that a ne arithmetic dural description, without generating any intermedi- produces signi cantly tighter bounds than interval ate geometry. This would prevent cracking and pre- arithmetic, although at a higher cost. serve resolution independence. The method should In [12], we used a ne arithmetic to obtain con- also guarantee intersections, in the sense that if an servative bounds for the value of procedural surface intersection exists, it will be found, no matter how shaders over a given parameter interval. This can ne the feature is. Since intersections with procedu- be used to drive a hierarchical sampling process, for ral displacements cannot be determined analytically, example in hierarchical radiosity. the algorithm should use a numerical method to iter- In this paper we extend the above ideas to ray- atively compute the closest intersection along a ray. tracing displacement shaders. We use a ne arith- metic to hierarchically enumerate the geometry gen- 2 Prior Work erated by procedural shaders. In Section 3 we de- Several related algorithms for nding intersections scribe the basic algorithm. In Section 4 we then with a variety of di erent geometric objects have brie y review a ne arithmetic, and discuss the is- been published. Nishita et al. [16] developed B ezier sues involved when applying it to procedural shaders. clipping to compute ray intersections with (ratio- Sections 5 and 6 contain re nements of the basic al- nal) B ezier patches. The algorithm rst determines gorithm. Finally, in Section 7, we present experi- parameter regions that cannot contain intersection mental results obtained with our method. points. The surface is the re-parameterized over the remaining parameter range. This process is recur- sively repeated until the intersection point has been 3 Direct Ray-tracing of Displacement determined with a given precision. Shaders Barr [2, 3] computed ray intersections with de- Our iterative method for intersection tests with dis- formed objects by solving an initial value problem. placement shaders is based on the idea of hierarchi- This method works for both parametric and implicit cally subdividing the parameter domain of the sur- surfaces, but only for relatively simple global defor- face. Parameter regions, in which intersections might mations such as twists. It does not directly translate occur, are identi ed, and those regions in which in- to complex procedural deformations. tersections are not possible are discarded. Parameter Later, Kalra and Barr [13] developed a method ranges containing potential intersections are recur- for nding guaranteed intersections with implicit sur- sively re ned, until the intersection has been deter- faces. Lipschitz bounds (global bounds on the deriva- mined within a pre-de ned accuracy. The pseudo- tive of the implicit function) are used to spatially code in Figure 2 summarizes this algorithm. subdivide 3-space into cells, each of which contains at In order to detect potential intersections in a given most one intersection of the surface with the ray. The parameter range, we compute a bounding box for the exact intersection point is then found using the New- value of the displacement shader over this range. The ton method or regula falsi. Unfortunately, the com- recursion is terminated if the bounding box is small putation of Lipschitz bounds cannot be automated, enough. For primary rays this means that the projec- and thus the use of this algorithm is limited to cases tion of the box onto the screen is smaller than some where it is acceptable for the user to specify them. fraction of a pixel. As we will show in Section 3.1, Snyder [22, 23] and Du [6] used interval arith- the bounding boxes can be obtained with the help of metic to recursively enumerate implicit surfaces with a ne arithmetic. a hierarchical data structure. For each cell, the im- Figure 3 shows an example of this method. On plicit function is evaluated using interval arithmetic. the left side, you see the hierarchically subdivided This yields bounds for the value of the function in parameter domain for the intersection of a ray with this cell. If these bounds include the value zero, the the simple shader from Figure 1. On the right side, intersect(ray,shader,u1,u2,v1,v2) The displacement shader communicates with two { other parts of the rendering system, the geometry bBox= computeBBox(shader,u1,u2,v1,v2); processing stage and a surface shading stage. The if( intersects(ray,bBox) ) data ow between those parts is depicted in Figure 4. if( isSmallEnough(bBox) ) return bBox; u,v,du,dv implicit implicit params params else Geometry Displacement Surface { Processing Shader Shader ll= intersect(ray,shader, u1,(u1+u2)/2,v1,(v1+v2)/2); Figure 4: The data ow between selected parts of lr= intersect(ray,shader, the rendering system. (u1+u2)/2,u2,v1,(v1+v2)/2); ul= intersect(ray,shader, Given a parametric position (u, v) and sampling u1,(u1+u2)/2,(v1+v2)/2,v2); rate (du, dv), the geometry processing stage com- ur= intersect(ray,shader, putes a set of purely geometric terms for a given (u1+u2)/2,u2,(v1+v2)/2,v2); parametric surface. This includes the point in 3- return closest(ll,lr,ul,ur); space, as well as the geometric and the shading nor- } return NONE; mal in this point. } This set of geometric terms is then passed on to the displacement shader, which is allowed to change the Figure 2: The basic intersection algorithm. position of the point, as well as the shading normal. The most important parameters of a displacement shader are listed in Table 1. The shader does not have direct access to the underlying geometry of the surface.
Variable Description P Position in 3-space N Shading normal in point P Figure 3: The hierarchically subdivided parameter Ng Surface normal in point P domain, and the resulting bounding boxes for the E Eye point intersection of one ray with the wave shader from u, v Surface parameters Figure 1. du, dv Change of surface parameters you see the displaced surface with the resulting hier- Table 1: The most important implicit parameters of archy of bounding boxes. displacement shaders. P and N can be modi ed by the shader. 3.1 Bounding Box Computation To understand how the bounding boxes can be com- The perturbed point and normal, together with puted, we rst describe how displacement shaders information from other parts of the system, such as can be conceptually integrated into the rendering incoming light directions and intensities, are then system. passed to the surface shader. There, they are used Displacement shaders are procedures that describe to determine the intensity of the point. perturbations of points in 3-space. For the pur- The data ow for the three modules shows the dif- poses of this paper, we assume that this process is culty of ray-tracing procedural displacements: in strictly separated from other parts of the renderer, in order to evaluate the shader, we require a parametric particular geometry processing and surface shading. position (u, v). This position, however, is not known Displacement shaders use a well-de ned interface to before the intersection has been determined. This il- communicate with other parts of the system. An lustrates the necessity to iterate the rst two stages example for such an interface is de ned by the Ren- of Figure 4 in order to nd both the intersection, and derMan Shading Language [20, 10], on which we base the parametric position of it. our discussion. Both the parametric function of the surface and the procedural displacement can usually be eval- f(x) on real numbers with an adequate operation uated only at discrete points in parameter space. f ∗(1, . . . , n) := f(x^) on a ne forms. However, in order to compute a bounding box for If f is itself an a ne function of its arguments, a speci c parameter range, we have to compute con- normal polynomial arithmetic yields the correspond- servative bounds for the value of the shader over that ing operation f ∗. For example, we get range. This can be done using an automated range analysis method such as a ne arithmetic. x^ + y^ = x0 + y0 + (x1 + y1)1 + · · · + (xn + yn)n,
Using a ne arithmetic instead of normal oating x^ + α = (x0 + α) + x11 + · · · + xnn, point arithmetic for the evaluation of the respective αx^ = αx0 + αx11 + · · · + αx parametric formulas for the geometry, we obtain con- n n servative bounds for parameters of the displacement for a ne forms x,^ y^ and real values α. shader, such as the surface point and the normal. If f is not an a ne operation, the function Conservative bounds for the displaced point and nor- f ∗(1, . . . , n) cannot be exactly represented as a lin- mal can then be computed by evaluating the shader, ear polynomial in the i. In this case, it is nec- again using a ne- instead of oating point arith- a essary to nd an a ne function f (1, . . . , n) = metic. The ranges of the x, y, and z components z0 +z11 +· · ·+znn that approximates f ∗(1, . . . , n) of the resulting point are at the same time bound- as well as possible over Un. An additional new noise ing boxes for the geometry after the displacement. symbol n+1 has to be added to represent the error In the following we give a brief overview of a ne introduced by this approximation. This yields the arithmetic, and describe in more detail how it can following a ne form for the operation z = f(x): be applied to procedural shaders. a z^ = f (1, . . . , ) 4 A ne Arithmetic n A ne arithmetic, rst introduced in [5], is an exten- = z0 + z11 + · · · + znn + zn+1n+1 sion of interval arithmetic [14]. It has been success- fully applied to several problems for which interval The coe cient xn+1 of the newly introduced noise symbol n+1 has to be an upper bound for the error arithmetic had been used before [15, 22, 23]. This a includes the adaptive enumeration of implicit sur- introduced by the approximation of f ∗ with f . a faces [9]. The process of generating a ne approximations f Like interval arithmetic, a ne arithmetic can be for arbitrary functions f is described in detail in [5], used for manipulating imprecise values, and for eval- [8] and [9]. This process is relatively straightforward uating functions over intervals. It is also possible for most library functions. Once all library functions to keep track of truncation and round-o errors. In have been implemented using a ne arithmetic, they contrast to interval arithmetic, a ne arithmetic also can be used to compute conservative bounds for any maintains dependencies between the sources of error, expression that only uses functions from this library. and thus manages to compute signi cantly tighter error bounds. 4.1 A ne Arithmetic and Procedural A ne arithmetic operates on quantities known as Shaders affine forms, given as polynomials of degree one in a In addition to the functions found in typical math li- set of noise symbols i. braries, shading languages often provide speci c ad- ditional functionality. This includes a set of problem- x^ = x0 + x11 + x22 + · · · + xnn speci c functions, as well as derivatives of arbitrary expressions, and, of course, control structures like if- The coe cients xi are known real values, while the values of the noise symbols are unknown, but limited statements and for-loops. In [12], we have shown to the interval U := [−1, 1]. Thus, if all noise sym- how the feature set of the RenderMan Shading Lan- bols can independently vary between −1 and 1, the guage can be implemented with a ne arithmetic. In range of possible values of an a ne form x^ is the following, we will brie y review some of these results. n Derivatives of arbitrary expressions are frequently [x^] = [x0 − ξ, x0 + ξ], ξ = |xi|. used in procedural shaders. In displacement shaders Xi=1 they can be used to compute the normal vector Computing with a ne forms is a matter of replac- in a displaced point: the derivatives of the point ing each elementary operation and library function with respect to the parametric directions u and v yields two tangent vectors of the surface. The de- ponents x^, y^, and z^ give us an axis aligned bounding sired normal is the crossproduct of the two. In the box for the displacement shader. RenderMan Shading Language, the built-in function Note that, in general, the region P^ is smaller calculatenormal() uses this method to generate than the complete bounding box, because usually the normals. a ne forms x^, y^, and z^ will depend on common noise The RenderMan standard [20] de nes derivatives symbols. This means that the values of the compo- with the help of divided di erences: Du(f(u)) := nents are not independent. More precisely, P^ is a (f(u + du) − f(u))/du. In this context, du is the projection of the n-dimensional unit cube: sampling rate in u-direction, which is provided to x0 x1 · · · x 1 the shader as an implicit parameter (see Table 1). n ^ . Derivatives with respect to arbitrary expressions P = y0 + y1 · · · yn · . are computed using the chain rule: Deriv(f, g) := z0 z1 · · · zn n Du(f)/Du(g) + Dv(f)/Dv(g). Using a ne arith- metic, we can evaluate these formulas, and thereby This dependency is ignored by evaluating the obtain conservative bounds for the value of expres- ranges of the components separately. However, di- sions as de ned by the RenderMan standard. If rectly dealing with the projection of n-dimensional bounds for the true mathematical value of derivatives unit cubes is expensive (there are 2n vertices), and are desired, we can use automatic di erentiation [21]. so the axis aligned bounding box is preferable for In this case, we store the triple (x^, ∂x/∂^ u, ∂x^/∂v) for intersection tests in ray-tracing applications. each expression x. The partial derivatives for each operation f(x) is then computed using the chain rule: 5 Handling Discontinuities In the form presented in Section 3, the hierarchical ∂x^ ∂x^ ∂x^ ∂x^ subdivision is terminated when the projection of the f x,^ , = f(x^), f 0(x^) , f 0(x^) . ∂u ∂v ∂u ∂v corresponding bounding box is small enough. This works in continuous areas of the shader, because the Like most programming languages, shading lan- region represented by P^ converges to a single point guages also have control statements like for-loops as the parameter range is subdivided. In discontinu- and if-then-else. These statements are challeng- ous areas, however, the region converges to a higher- ing to deal with, because the correct execution path dimensional structure, typically a line segment. As is selected at runtime, based on a number of compar- a consequence, the axis-aligned bounding box does isons (typically inequalities when dealing with oat- not, in general, converge to zero around discontinu- ing point values). Unfortunately, two a ne forms ities of the shader. can have overlapping ranges, in which case compar- Thus, it is necessary to detect discontinuities of the isons between the two are neither true nor false. It shader during the subdivision process, and to termi- is then necessary to execute both possible execution nate the recursion appropriately. Discontinuities can paths, and merge the resulting ranges into a single be caused either by discontinuous library functions, a ne form. like the step() function, or by the use of control A simple way of determining whether both paths statements that cause di erent execution paths for or only one of them has to be executed, is to replace adjacent points on the surface. Both cases can be all inequalities with a step function, for which an dealt with by adding a ag to the implementation a ne approximation can be found easily. For exam- of a ne forms. The ag is set whenever a library ple x < y becomes step(y − x) where step(x) := 0 function causes a discontinuity, or the results of two for x < 0 and step(x) := 1 otherwise. Boolean ex- di erent execution paths are merged into one a ne pressions can then be replaced by arithmetic expres- form. sions: x1 < y1 and x2 < y2 becomes step(x1 − y1) · The recursive subdivision is then terminated when step(x2 − y2). the bounding box is small enough OR the surface is discontinuous AND the size of the bounding box did 4.2 A ne Arithmetic and Displacement not change signi cantly during the last subdivision. Shaders Having detected discontinuities, the question is, Applied to displacement shaders, a ne arithmetic whether or not intersections with their bounding allows us to compute a region P^ = (x^, y^, z^) that en- boxes should be reported as surface intersections. closes the displaced surface for a given parameter Both alternatives are possible and yield di erent se- range (u ± du/2, v ± dv/2). The ranges of the com- mantics. If the intersection is not reported, discon- tinuities will result in holes or disconnected surface We do this by storing the bounding boxes in a parts. If they are reported, this gives the shader au- quadtree. Each node of the tree corresponds to a thor a convenient way of specifying vertical surfaces. certain range of the hierarchically subdivided param- The latter approach is consistent with RenderMan, eter domain. In each node we only need to store the and has been used for rendering Figure 5. The gure axis aligned bounding box itself (six oating point shows a simple displacement shader, which, applied values), as well as one pointer to each of the four chil- to a disk, results in a nail-like surface. Besides the dren of the node. The parameter range represented handling of discontinuities, this gure also illustrates by a quadtree node is implicitly available through that the algorithm is capable of naturally dealing the path from the root to the node. All other pa- with rather extreme displacements. rameters, which are only required for some of the leaf nodes anyway, can be obtained by evaluating the shader. This results in a fairly storage e cient data struc- ture. Each node requires 40 to 80 Bytes, depending on whether we use single or double precision oats and 32 or 64 bit pointers. The total size of the tree can still be extremely large, especially for large image resolutions, which require more levels of subdivision. Thus, it is necessary to remove parts of the tree that
displacement are not likely to be required again soon. In our implementation of the ray-tracer, which uses a normal scanline traversal order for the pix- els, we allocate a certain amount of memory for the nodes in the tree. If the memory requirements ex- ceed this limit, we traverse the tree, deleting every node except the ones used by the previous ray. radius If we allow arbitrary pixel traversal orders it is Figure 5: A simple nail shader applied to a small disk easy to think of other methods for limiting memory at the base of the nail. This illustrates the ability usage. For example, the screen could be subdivided of the algorithm to handle discontinuous and rather into rectangular tiles, each of which is rendered sepa- extreme displacements. rately, or a space lling curve could be used as in [18]. An even more promising approach would be the use Note that, if divided di erences are used to com- of a ray cache as in [19]. However, these alternatives pute derivatives, the normal vectors for the discon- have not been explored yet. tinuous parts automatically converge to the desired Another improvement of the algorithm, both in result. performance and in memory requirements, can be achieved by adapting the traversal order of the sub- trees. In ray-tracing, often only the rst intersection 6 Caching and Memory Considerations of a ray with an object is required. The algorithm With the above modi cations to the basic algorithm, from Section 3 nds all intersections, and therefore we are able to ray-trace arbitrary procedural shaders. Unfortunately, the algorithm as presented in Sec- tion 3 is relatively slow, since it computes a hierarchy of bounding boxes for each ray. Obviously, there is a lot of coherence between adjacent pixels, and the cor- responding rays produce largely identical hierarchies of bounding boxes. Depending on the complexity of the displacement shader, its evaluation is signi cantly more expensive than an intersection test of a ray with an axis aligned bounding box. It is therefore desirable to trade mem- Figure 6: With the modi ed traversal order, the al- ory for computation time by caching some of the gorithm only nds the closest intersection. This re- bounding boxes already computed for future use. sults in a reduced number of shader evaluations. has to re ne the bounding box hierarchy in areas The loss of performance is particularly dramatic for which are not relevant to nding the closest intersec- the nail shader, in which the bounding boxes for the tion point. discontinuous portion can be reused over a large area In an improved version of the algorithm, the of the image. If the cache is too small, these boxes branches whose bounding boxes are closest to the have to be recomputed over and over again. A more origin of the ray are re ned rst. Branches for which sophisticated caching scheme would certainly help in the bounding boxes are further away than already this case. known intersections do not need to be traversed. Fig- ure 6 shows how this method reduces the number of 7.1 A ne Arithmetic and Interval Arith- bounding boxes compared to Figure 3. metic In this paper we use a ne arithmetic to obtain con- 7 Results servative bounds for shader values over a parameter We have timed our method with several shaders and range. In principle, we could also use any other range cache sizes. As shaders we used the wave and nail analysis method for this purpose. It is, however, shaders from above, as well as the \UFO"-shader important that the method generates tight, conser- depicted in Figure 7. The cache sizes were 40, 400 vative bounds, because this reduces the number of and 4000 KBytes, corresponding to 1000, 10000, and bounding boxes to be generated, and therefore im- 100000 quadtree nodes with a size of 40 Bytes. The proves both performance and memory requirements. resulting timings are listed in Table 2. The resolution In this sense, interval arithmetic performs worse for the wave shader was 512×256, for the nail shader than a ne arithmetic for this application. It pro- 256×512, and for the UFO shader 256×256. For the duces much wider bounds than a ne arithmetic UFO shader, we always computed all intersections, when applied to procedural shaders. Figure 8 shows whereas for the other two, we only computed the a comparison of the subdivisions generated for the closest one. UFO shader by a single ray. For interv al arithmetic, 1450 bounding boxes had to be generated, for a ne arithmetic this number was only 174. The more so- phisticated shaders are used, the worse interval arith- metic performs. These measurements are consistent with the results presented in [5], [9], and [8], as well as our own results for surface shaders [12].
Figure 7: The \UFO" displacement shader applied to a sphere. The surface shader is the RenderMan wood shader.
Shader 40KB 400KB 4MB unlimited Wave 122.3 71.1 66.7 66.2 Nail 380.7 33.2 32.6 32.6 Ufo 121.4 89.5 82.5 82.2
Table 2: Timings (in seconds) for several shaders and cache sizes on a SGI O2 with 175MHz R10000 Figure 8: A comparison of a ne arithmetic (left) and processor. interval arithmetic (right). A ne arithmetic pro- duced 174 bounding boxes, interval arithmetic 1450. The numbers show that, even for our simple A magni ed portion is showed on the bottom. caching scheme and the moderate cache size of 400 KB, the performance penalty is below 10 percent compared to unlimited cache space. As with any 8 Conclusions and Future Research caching scheme, the performance drops dramatically In this paper we have presented a new iterative for small cache sizes, that cannot hold the working method for computing intersections of rays with pro- set of the application. In our case this corresponds to cedural displacement shaders. The method directly the number of nodes required for a complete scanline. operates on the procedural description of the shader, without introducing any approximate geometry. As [9] Luiz Henrique Figueiredo and Jorge Stolfi. Adaptive a consequence, the method is resolution independent enumeration of implicit surfaces with affine arith- and storage e cient, and is guaranteed to nd ev- metic. Computer Graphics Forum, 15(5):287–296, ery intersection of the ray with the surface. Com- 1996. putation time can be traded for memory in order to [10] Pat Hanrahan and Jim Lawson. A language for improve performance. shading and lighting calculations. In Computer We already mentioned that more sophisticated Graphics (SIGGRAPH ’90 Proceedings), pages 289– caching schemes like the one in [19] are likely to fur- 298, August 1990. ther improve performance. This is something to be [11] Wolfgang Heidrich. A compilation of affine approx- explored in the future. imations for math library functions. Technical Re- port TR-1997-3, University of Erlangen Computer Another interesting area of research is the paral- Graphics Group, 1997. lelization of the this method for loosely coupled dis- [12] Wolfgang Heidrich, Philipp Slusallek, and Hans- tributed systems and rendering farms. The proce- Peter Seidel. Sampling procedural shaders using dural shaders that have to be distributed across the affine arithmetic. ACM Transactions on Graphics, network are extremely small. From this data, every 1998. host is able to compute its own cache for bounding [13] Devendra Kalra and Alan H. Barr. Guaranteed ray boxes, instead of having to share large amounts of intersections with implicit surfaces. In Computer tessellated geometry with other hosts. Graphics (SIGGRAPH ’89 Proceedings), pages 297– Last but not least, the design of a renderer that 306, July 1989. is completely based on range analysis methods such [14] Ramon E. Moore. Interval Analysis. Prentice Hall, as a ne arithmetic is a promising area of future re- Englewood Cliffs, New Jersey, 1966. search. The combination of work mentioned in Sec- [15] F. Kenton Musgrave, Craig E. Kolb, and Robert S. tion 2, together with the work presented in this pa- Mace. The synthesis and rendering of eroded fractal per, allows for guaranteed intersection tests with al- terrains. In Computer Graphics (SIGGRAPH ’89 most any kind of commonly used geometric descrip- Proceedings), pages 41–50, July 1989. tion. [16] Tomoyuki Nishita, Thomas W. Sederberg, and Masanori Kakimoto. Ray tracing trimmed ratio- References nal surface patches. In Computer Graphics (SIG- [1] Alias/Wavefront. OpenAlias Manual, 1996. GRAPH ’90 Proceedings), pages 337–345, August [2] Alan H. Barr. Global and local deformations of solid 1990. primitives. In Computer Graphics (SIGGRAPH ’84 [17] Ken Perlin. An image synthesizer. In Computer Proceedings), pages 21–30, August 1984. Graphics (SIGGRAPH ’85 Proceedings), pages 287– [3] Alan H. Barr. Ray tracing deformed surfaces. In 296, July 1985. Computer Graphics (SIGGRAPH ’86 Proceedings), [18] Matt Pharr and Pat Hanrahan. Geometry caching pages 287–296, August 1986. for ray-tracing displacement maps. In Eurographics Rendering Workshop 1996, pages 31–40, June 1996. [4] James F. Blinn. Simulation of wrinkled surfaces. In Computer Graphics (SIGGRAPH ’78 Proceedings), [19] Matt Pharr, Craig Kolb, Reid Gerhbein, and Pat pages 286–292, August 1978. Hanrahan. Rendering complex scenes with memory- coherent ray tracing. In Computer Graphics (SIG- [5] Jo˜ao L. D. Comba and Jorge Stolfi. Affine arithmetic GRAPH ’97 Proceedings), pages 101–108, aug 1997. and its applications to computer graphics. In Anais do VII Sibgrapi, pages 9–18, 1993. Available from [20] Pixar. The RenderMan Interface. Pixar, San Rafael, http://www.dcc.unicamp.br/˜stolfi. CA, Sep 1989. [21] Louis B. Rall. Automatic Differentiation, Tech- [6] Tom Duff. Interval arithmetic and recursive subdi- niques and Applications. Number 120 in Lecture vision for implicit functions and constructive solid notes in computer science. Springer, 1981. geometry. In Computer Graphics (SIGGRAPH ’92 Proceedings), pages 131–138, July 1992. [22] John M. Snyder. Generative Modeling for Computer graphics and CAD: Symbolic Shape Design Using In- [7] David Ebert, Kent Musgrave, Darwyn Peachey, Ken terval Analysis. Academic Press, 1992. Perlin, and Steve Worley. Texturing and Modeling: A Procedural Approach. Academic Press, October [23] John M. Snyder. Interval analysis for computer 1994. graphics. In Computer Graphics (SIGGRAPH ’92 Proceedings), pages 121–130, July 1992. [8] Luiz Henrique Figueiredo. Surface intersection using [24] Steve Upstill. The RenderMan Companion. Addison affine arithmetic. In Graphics Interface ’96, pages Wesley, 1990. 168–175, 1996.
Figure 9: A more complex scene with multiple objects. The underlying geometry of each object is a sphere.