17 results
Search Results
Now showing 1 - 10 of 17
Item Real-Time Bump Map Synthesis(The Eurographics Association, 2001) Kautz, Jan; Heidrich, Wolfgang; Seidel, Hans-Peter; Kurt Akeley and Ulrich NeumannIn this paper we present a method that automatically synthesizes bump maps at arbitrary levels of detail in real-time. The only input data we require is a normal density function; the bump map is generated according to that function. It is also used to shade the generated bump map. The technique allows to infinitely zoom into the surface, because more (consistent) detail can be created on the fly. The shading of such a surface is consistent when displayed at different distances to the viewer (assuming that the surface structure is self-similar). The bump map generation and the shading algorithm can also be used separately.Item Polygon Rendering on a Stream Architecture(The Eurographics Association, 2000) Owens, John D.; Dally, William J.; Kapasi, Ujval J.; Rixner, Scott; Mattson, Peter; Mowery, Ben; I. Buck and G. Humphreys and P. HanrahanThe use of a programmable stream architecture in polygon rendering provides a powerful mechanism to address the high performance needs of today s complex scenes as well as the need for flexibility and programmability in the polygon rendering pipeline. We describe how a polygon rendering pipeline maps into data streams and kernels that operate on streams, and how this mapping is used to implement the polygon rendering pipeline on Imagine, a programmable stream processor. We compare our results on a cycleaccurate simulation of Imagine to representative hardware and software renderers.Item Prefiltered Antialiased Lines Using Half-Plane Distance Functions(The Eurographics Association, 2000) McNamara, Robert; McCormack, Joel; Jouppi, Norman P.; I. Buck and G. Humphreys and P. HanrahanWe describe a method to compute high-quality antialiased lines by adding a modest amount of hardware to a fragment generator based upon half-plane edge functions. (A fragment contains the information needed to paint one pixel of a line or a polygon.) We surround an antialiased line with four edge functions to create a long, thin, rectangle. We scale the edge functions so that they compute signed distances from the four edges. At each fragment within the antialiased line, the four distances to the fragment are combined and the result indexes an intensity table. The table is computed by convolving a filter kernel with a prototypical line at various distances from the line s edge. Because the convolutions aren t performed in hardware, we can use wider, more complex filters with better high-frequency rejection than the narrow box filter common to supersampling antialiasing hardware. The result is smoother antialiased lines. Our algorithm is parameterized by the line width and filter radius. These parameters do not affect the rendering algorithm, but only the setup of the edge functions. Our algorithm antialiases line endpoints without special handling. We exploit this to paint small blurry squares as approximations to small antialiased round points. We do not need a different fragment generator for antialiased lines, and so can take advantage of all optimizations introduced in the existing fragment generator.Item Interactive Rendering of Atmospheric Scattering Effects Using Graphics Hardware(The Eurographics Association, 2002) Dobashi, Yoshinori; Yamamoto, Tsuyoshi; Nishita, Tomoyuki; Thomas Ertl and Wolfgang Heidrich and Michael DoggettTo create realistic images using computer graphics, an important element to consider is atmospheric scattering, that is, the phenomenon by which light is scattered by small particles in the air. This effect is the cause of the light beams produced by spotlights, shafts of light, foggy scenes, the bluish appearance of the earth s atmosphere, and so on. This paper proposes a fast method for rendering the atmospheric scattering effects based on actual physical phenomena. In the proposed method, look-up tables are prepared to store the intensities of the scattered light, and these are then used as textures. Realistic images are then created at interactive rates by making use of graphics hardware.Item Efficient Partitioning of Fragment Shaders for Multipass Rendering on Programmable Graphics Hardware(The Eurographics Association, 2002) Chan, Eric; Ng, Ren; Sen, Pradeep; Proudfoot, Kekoa; Hanrahan, Pat; Thomas Ertl and Wolfgang Heidrich and Michael DoggettReal-time programmable graphics hardware has resource constraints that prevent complex shaders from rendering in a single pass. One way to virtualize these resources is to partition shading computations into multiple passes, each of which satisfies the given constraints. Many such partitions exist for a shader, but it is important to find one that renders efficiently. We present Recursive Dominator Split (RDS), a polynomial-time algorithm that uses a cost model to find near-optimal partitions of arbitrarily complex shaders. Using a simulator, we analyze partitions for architectures with different resource constraints and show that RDS performs well on different graphics architectures. We also demonstrate that shader partitions computed by RDS can run efficiently on programmable graphics hardware available today.Item High-Quality Unstructured Volume Rendering on the PC Platform(The Eurographics Association, 2002) Guthe, Stefan; Roettger, Stefan; Schieber, Andreas; Strasser, Wolfgang; Ertl, Thomas; Thomas Ertl and Wolfgang Heidrich and Michael DoggettFor the visualization of volume data the application of transfer functions is used widely. In this area the preintegration technique allows high quality visualizations and the application of arbitrary transfer functions. For regular grids, this approach leads to a two-dimensional pre-integration table which easily fits into texture memory. In contrast to this, unstructured meshes require a three-dimensional pre-integration table. As a consequence, the available texture memory limits the resolution of the pre-integration table and the maximum local derivative of the transfer function. Discontinuity artifacts arise if the resolution of the pre-integration table is too low. This paper presents a novel approach for accurate rendering of unstructured grids using the multi-texturing capabilities of commodity PC graphics hardware. Our approach achieves high quality by reconstructing the colors and opacities of the pre-integration table using the high internal precision of the pixel shader. Since we are using standard 2D multi-texturing we are not limited in the size of the pre-integration table. By combining this approach with a hardware-accelerated calculation of the pre-integration table, we achieve both high quality visualizations and interactive classification updates.Item Towards Hardware Implementation Of Loop Subdivision(The Eurographics Association, 2000) Bischoff, Stephan; Kobbelt, Leif P.; Seidel, Hans-Peter; I. Buck and G. Humphreys and P. HanrahanWe present a novel algorithm to evaluate and render Loop subdivision surfaces. The algorithm exploits the fact that Loop subdivision surfaces are piecewise polynomial and uses the forward difference technique for efficiently computing uniform samples on the limit surface. The main advantage of our algorithm is that it only requires a small and constant amount of memory that does not depend on the subdivision depth. The simple structure of the algorithm enables a scalable degree of hardware implementation. By low-level parallelization of the computations, we can reduce the critical computation costs to a theoretical minimum of about one float[3]- operation per triangle.Item Adaptive View Dependent Tessellation of Displacement Maps(The Eurographics Association, 2000) Doggett, Michael; Hirche, Johannes; I. Buck and G. Humphreys and P. HanrahanDisplacement Mapping is an effective technique for encoding the high levels of detail found in today s triangle based surface models. Extending the hardware rendering pipeline to be capable of handling displacement maps as geometric primitives, will allow highly detailed models to be constructed without requiring large numbers of triangles to be passed from the CPU to the graphics pipeline. We present a new approach based on recursive tessellation that adapts to the surface complexity described by the displacement map. We also ensure that the resolution of the displaced mesh is tessellated with respect to the current view point. Our tessellation scheme performs all tests only on triangle edges to avoid generating cracks on the displaced surface. The main decision for vertex insertion is based on two comparisons involving the average height surrounding the vertices and the normals at the vertices. Individually, the tests will fail to tessellate a mesh satisfactorily, but their combination achieves good results. We propose several additions to the typical hardware rendering pipeline in order to achieve displacement map rendering in hardware. The mesh tessellation is placed within the rendering pipeline so that we can take advantage of the pre-existing vertex transformation units to perform the setup calculations for our view dependent test. Our method adds only simple arithmetic and comparison operations to the graphics pipeline and makes use of existing units for calculations wherever possible.Item Tiled Polygon Traversal Using Half-Plane Edge Functions(The Eurographics Association, 2000) McCormack, Joel; McNamara, Robert; I. Buck and G. Humphreys and P. HanrahanExisting techniques for traversing a polygon generate fragments one (or more) rows or columns at a time. (A fragment is all the information needed to paint one pixel of the polygon.) This order is non-optimal for many operations. For example, most frame buffers are tiled into rectangular pages, and there is a cost associated with accessing a different page. Pixel processing is more efficient if all fragments of a polygon on one page are generated before any fragments on a different page. Similarly, texture caches have reduced miss rates if fragments are generated in tiles (and even tiles of tiles) whose size depends upon the cache organization. We describe a polygon traversal algorithm that generates fragments in a tiled fashion. That is, it generates all fragments of a polygon within a rectangle (tile) before generating any fragments in another rectangle. For a single level of tiling, our algorithm requires one additional saved context (the values of all interpolator accumulators, such as Z depth, Red, Green, Blue, etc.) over a traditional traversal algorithm based upon half-plane edge functions. An additional level of tiling requires another saved context for the special case of rectangle copies, or three more for the general case. We describe how to use this algorithm to generate fragments in an optimal order for several common scenarios.Item Hardware-Accelerated Free-Form Deformation(The Eurographics Association, 2000) Chua, Clint; Neumann, Ulrich; I. Buck and G. Humphreys and P. HanrahanHardware-acceleration for geometric deformation is developed in the framework of an extension to the OpenGL specification. The method requires an addition to the front-end of the OpenGL rendering pipeline and an appropriate OpenGL primitive. Our approach is to implement general geometric deformations so the system supports additional layers of abstraction, including physically based simulations. This approach would support a wide range of users with an accelerated implementation of a wellunderstood deformation method, reducing the need for software deformation engines and the execution time penalty associated with them.