We present an efficient algorithm to compute image histograms entirely on the GPU. Unlike previous implementations that use a gather approach, we take advantage of scattering data through the vertex shader and of high-precision blending available on modern GPUs. This results in fewer operations executed per pixel and speeds up the computation.Our approach allows us to create histograms with arbitrary numbers of buckets in a single rendering pass, and avoids the need for any communication from the GPU back to the CPU: The histogram stays in GPU memory and is immediately available for further processing.We discuss solutions to dealing with the challenges of implementing our algorithm on GPUs that have limited computational and storage precision. Finally, we provide examples of the kinds of graphics algorithms that benefit from the high performance of our histogram generation approach.

We introduce a technique that uses summed-area tables to dynamically compute image-based lighting from highdynamic-range environment maps. A combination of first order and second order summed-area tables are used to approximate various BRDFs such as the Phong BRDF. A key feature of the approach is “offsetting” of the original image with respect to its mean, in order to significantly increase the precision of our computation. On current graphics hardware, we are able to render at over 40 frames per second while still re-computing all necessary summed-area tables on the fly to allow for dynamic lighting. When the environment map is static, we are able to render at over 130 frames per second, but still allow for dynamic, spatially varying filtering of the static environment map.

We introduce a technique to rapidly generate summed-area tables using graphics hardware. Summed area tables, originally introduced by Crow, provide a way to filter arbitrarily large rectangular regions of an image in a constant amount of time. Our algorithm for generating summed-area tables, similar to a technique used in scientific computing called recursive doubling, allows the generation of a summed-area table in O(log n) time. We also describe a technique to mitigate the precision requirements of summed-area tables. The ability to calculate and use summed-area tables at interactive rates enables numerous interesting rendering effects. We present several possible applications. First, the use of summed-area tables allows real-time rendering of interactive, glossy environmental reflections. Second, we present glossy planar reflections with varying blurriness dependent on a reflected object's distance to the reflector. Third, we show a technique that uses a summed-area table to render glossy transparent objects. The final application demonstrates an interactive depth-of-field effect using summed-area tables.

There are many applications in computer graphics where spatially varying filters are useful. One example is the rendering of glossy reflections. Unlike perfectly reflective materials, which only require a single radiance sample in the direction of the reflection vector, glossy materials require integration over a solid angle. Blurring by filtering the reflected image with a support dependent on the surface‘s BRDF can approximate this effect. This is currently done by pre-filtering off-line, which limits the technique to static environments. Crow [1984] introduced summed-area tables to enable more general texture filtering than was possible with mip maps. Once generated, a summed-area table provides a means to evaluate a spatially varying box filter with a constant number of texture reads.

We present a real-time algorithm for hair rendering using a polygon model, which was used in the real-time animation Ruby: The Double Cross, appearing in this year’s SIGGRAPH animation festival. The hair shading model is based on the Kajiya-Kay model, and adds a real-time approximation of realistic specular highlights as observed by Marschner et al. We also describe a simple technique to render the semi-transparent hair model in approximate back-to-front order. Instead of executing a spatial sorting step on the CPU at run-time, we render the opaque and transparent hair regions in separate passes to resolve visibility.

This paper presents a physically-based, visually-realistic interactive cloud simulation. Clouds in our system are modeled using partial differential equations describing fluid motion, thermodynamic processes, buoyant forces, and water phase transitions. We also simulate the interaction of clouds with light, including self-shadowing and light scattering.We implement both simulations - dynamic and radiometric - entirely on programmable floating-point graphics hardware. We use "flat 3D textures" - 3D data laid out as slices tiled in a 2D texture - to implement 3D simulations on the GPU. This has scalability advantages over the use of traditional 3D textures. We exploit the relatively slow evolution of clouds in calm skies to enable interactive visualization of the simulation. The work required to simulate a single time step is automatically spread over many frames while the user views the results of the previous time step. This technique enables the incorporation of our simulation into real applications without sacrificing interactivity.

A common metric of VE quality is presence --- the degree to which the user feels like they are in the virtual scene as opposed to the real world. Presence is important for many VE applications [Hodges et al. 1994]. Since presence is a subjective condition, it is most commonly measured by self-reporting, either during the VE experience or immediately afterwards by questionnaires. There is vigorous debate in the literature as to how to best measure presence [Meehan 2001].

In this paper, we present a method for real-time visual simulation of diverse dynamic phenomena using programmable graphics hardware. The simulations we implement use an extension of cellular automata known as the coupled map lattice (CML). CML represents the state of a dynamic system as continuous values on a discrete lattice. In our implementation we store the lattice values in a texture, and use pixel-level programming to implement simple next-state computations on lattice nodes and their neighbors. We apply these computations successively to produce interactive visual simulations of convection, reaction-diffusion, and boiling. We have built an interactive framework for building and experimenting with CML simulations running on graphics hardware, and have integrated them into interactive 3D graphics applications.

Thorsten Scheuermann COMP 242 Spring ’02