Search

This paper presents an image-space stroke rendering algorithm that provides temporally coherent placement of lines at particles that are moving with object surfaces. We generate particles in image space and move them according to an image-space velocity field. Consistent image-space density is achieved by a deterministic rejection-based algorithm that uses low-discrepancy series to filter out overpopulated areas and to fill in underpopulated regions. Our line stabilization method can solve the temporal continuity problems of image-space techniques. The multi-pass algorithm is implemented entirely on the GPU using geometry shaders and vertex transform feedback. Our method provides high-quality results and is implemented as an interactive post processing step. We also provide a wide toolset for artists to control the final rendering style and extended the method to process real-life RGBZ footage.

Grass swaying simulation with respect to wind force plays an important role in the outdoor scene design of video games and animations. However, the complex and dynamic interactions between grass and wind largely hinder the existing approaches from generating physically plausible simulation in real-time performance. Therefore, common approaches compromise by either rendering still meadow or simply adopting a procedural method for simulating the grass motion. In this work, we present a simple yet effective grass model that enables the real-time simulation of grass swaying mimicking real-world grass motions under dynamic wind force. We characterize each individual grass using a simple polyline model with four vertices derived from the control knots of a cubic Bezier curve describing the real grass shape. The grass dynamics is modeled by applying a combination of swinging, bending and twisting motions to the polyline model in response to the input wind force. The deformed grass model is then passed to the shader pipeline to synthesize grass blades for the rendering. Experimental results show that our system not only achieves real-time performance in simulation and rendering, but also scales well to large grass field such as a meadow.

Exact order-independent transparency (OIT) techniques capture all fragments during rasterization. The fragments are then sorted per-pixel by depth and composited in order using alpha transparency. The sorting stage is a bottleneck for high depth complexity scenes, taking 70---95 % of the total time for those investigated. In this paper, we show that typical shader-based sorting speed is impacted by local memory latency and occupancy. We present and discuss the use of both registers and an external merge sort in register-based block sort to better use the memory hierarchy of the GPU for improved OIT rendering performance. This approach builds upon backwards memory allocation, achieving an OIT rendering speed up to 1.7 $$\times $$ × that of the best previous method and 6.3 $$\times $$ × that of the common straight forward OIT implementation. In some cases, the sorting stage is reduced to no longer be the dominant OIT component.

Extensive research has been carried out in multiresolution models for many decades. The tendency in recent years has been to harness the potential of GPUs to perform the level-of-detail extraction on graphics hardware. The aim of this work is to present a new level-of-detail scheme based on triangles which is both simple and efficient. In this approach, the extraction process updates vertices instead of indices, thus providing a perfect framework for adapting the algorithms to work completely on GPU shaders. One of the key aspects of our proposal is the need for just a single rendering pass in order to obtain the desired geometry. Moreover, coherence among the different approximations is maximized by means of a symmetric extraction algorithm, which performs the same process when refining and coarsening the mesh. Lastly, we also introduce different uses of the scheme to offer continuous and view-dependent resolution.

Fur is present in most mammals which are common characters in both movies and video-games, and it is important to model and render fur both realistically and quickly. When the objective is real-time performance, fur is usually represented by texture layers (or 3D textures), which limits the dynamic characteristics of fur when compared with methods that use an explicit representation for each fur strand. This paper proposes a method for animating and shaping fur in real-time, adding curling and clumping effects to the existing real-time fur rendering methods on the GPU. Besides fur bending using a mass-spring strand model embedded in the fur texture, we add small scale displacements to layers to represent curls which are suitable for vertex shader implementation, and we also use a fragment shader to compute intra-layer offsets to create fur clumps. With our method, it becomes easy to dynamically add and remove fur curls and clumps, as can be seen in real fur as a result of fur getting wet and drying up.

This paper shows that breaking the barrier of 1 triangle/clock rasterization rate for microtriangles in modern GPU architectures in an efficient way is possible. The fixed throughput of the special purpose culling and triangle setup stages of the classic pipeline limits the GPU scalability to rasterize many triangles in parallel when these cover very few pixels. In contrast, the shader core counts and increasing GFLOPs in modern GPUs clearly suggests parallelizing this computation entirely across multiple shader threads, making use of the powerful wide-ALU instructions. In this paper, we present a very efficient SIMD-like rasterization code targeted at very small triangles that scales very well with the number of shader cores and has higher performance than traditional edge equation based algorithms. We have extended the ATTILA GPU shader ISA (del Barrioet al. in IEEE International Symposium on Performance Analysis of Systems and Software, pp. 231–241, 2006) with two fixed point instructions to meet the rasterization precision requirement. This paper also introduces a novel subpixel Bounding Box size optimization that adjusts the bounds much more finely, which is critical for small triangles, and doubles the 2×2-pixel stamp test efficiency. The proposed shader rasterization program can run on top of the original pixel shader program in such a way that selected fragments are rasterized, attribute interpolated and pixel shaded in the same pass. Our results show that our technique yields better performance than a classic rasterizer at 8 or more shader cores, with speedups as high as 4× for 16 shader cores.

We present a novel hybrid rendering method for diffuse and glossy indirect illumination. A scene is rendered using standard rasterization on a GPU. In a shader, secondary ray queries are used to sample incident light and to compute indirect lighting. We observe that it is more important to cast many rays than to have precise results for each ray. Thus, we approximate secondary rays by intersecting them with precomputed layered depth images of the scene. We achieve interactive to real-time frame rates including indirect diffuse and glossy effects.

For use in real-time applications, we present a fast algorithm for converting a quad mesh to a smooth, piecewise polynomial surface on the Graphics Processing Unit (GPU). The surface has well-defined normals everywhere and closely mimics the shape of Catmull–Clark subdivision surfaces. It consists of bicubic splines wherever possible, and a new class of patches—c-patches—where a vertex has a valence different from 4. The algorithm fits well into parallel streams so that meshes with 12,000 input quads, of which 60% have one or more non-4-valent vertices, are converted, evaluated and rendered with 9×9 resolution per quad at 50 frames per second. The GPU computations are ordered so that evaluation avoids pixel dropout.

We present a novel framework for real-time multi-perspective rendering. While most existing approaches are based on ray-tracing, we present an alternative approach by emulating multi-perspective rasterization on the classical perspective graphics pipeline. To render a general multi-perspective camera, we first decompose the camera into piecewise linear primitive cameras called the general linear cameras or GLCs. We derive the closed-form projection equations for GLCs and show how to rasterize triangles onto GLCs via a two-pass rendering algorithm. In the first pass, we compute the GLC projection coefficients of each scene triangle using a vertex shader. The linear raster on the graphics hardware then interpolates these coefficients at each pixel. Finally, we use these interpolated coefficients to compute the projected pixel coordinates using a fragment shader. In the second pass, we move the pixels to their actual projected positions. To avoid holes, we treat neighboring pixels as triangles and re-render them onto the GLC image plane. We demonstrate our real-time multi-perspective rendering framework in a wide range of applications including synthesizing panoramic and omnidirectional views, rendering reflections on curved mirrors, and creating multi-perspective faux animations. Compared with the GPU-based ray tracing methods, our rasterization approach scales better with scene complexity and it can render scenes with a large number of triangles at interactive frame rates.

This paper presents a hybrid (geometry- and image-based) framework suitable for providing photorealistic walkthroughs of large, complex outdoor scenes, based only on a small set of real images from the scene. To this end, a novel data representation of a 3D scene is proposed, which is called morphable 3D panoramas. Motion is assumed to be taking place along a predefined path of the 3D environment and the input to the system is a sparse set of stereoscopic views at certain positions (key positions) along that path (one view per position). An approximate local 3D model is constructed from each view, capable of capturing the photometric and geometric properties of the scene only locally. Then, during the rendering process, a continuous morphing (both photometric as well as geometric) takes place between successive local 3D models, using what we call a ‘morphable 3D model’. For the estimation of the photometric morphing, a robust algorithm capable of extracting a dense field of 2D correspondences between wide-baseline images is used, whereas, for the geometric morphing, a novel method of computing 3D correspondences between local models is proposed. In this way, a physically valid morphing is always produced, which is thus kept transparent from the user. Moreover, a highly optimized rendering path is used during morphing. Thanks to the use of appropriate pixel and vertex shaders, this rendering path can be run fully in 3D graphics hardware and thus allows for high frame rates. Our system can be extended to handle multiple stereoscopic views (and therefore multiple local models) per key position of the path (related by a camera rotation). In this case, one local 3D panorama (per key position) is constructed, comprising all local 3D models therein, and so a ‘morphable 3D panorama’ is now used during the rendering process. For handling the geometric consistency of each 3D panorama, a technique which is based on solving a partial differential equation is adopted. The effectiveness of our framework is demonstrated by using it for the 3D visual reconstruction of the Samaria Gorge in Crete.

In this paper, we present a new GPU-based particle system. The simulation runs entirely on the GPU, thus eliminating data transfer between CPU and GPU. The proposed system is able to simulate particles in confined environments, including support for inter-particle collisions, constraints, and particle–obstacle collisions. On modern graphics cards, the system simulates up to one million particles at interactive rate. We also propose a flexible approach for modeling the obstacles that define the environment, allowing the creation of different scenes without relying on shader re-coding. A set of computational experiments demonstrates the effectiveness of the proposed system.

This paper addresses the problem of real-time rendering for objects with complex materials under varying all-frequency illumination and changing view. Our approach extends the triple product algorithm by using local-frame parameterization, spherical wavelets, per-pixel shading and visibility textures. Storing BRDFs with local-frame parameterization allows us to handle complex BRDFs and incorporate bump mapping more easily. In addition, it greatly reduces the data size compared to storing BRDFs with respect to the global frame. The use of spherical wavelets avoids uneven sampling and energy normalization of cubical parameterization. Finally, we use per-pixel shading and visibility textures to remove the need for fine tessellations of meshes and shift most computation from vertex shaders to more powerful pixel shaders. The resulting system can render scenes with realistic shadow effects, complex BRDFs, bump mapping and spatially-varying BRDFs under varying complex illumination and changing view at real-time frame rates on modern graphics hardware.

Detecting self-intersections within a triangular mesh model is fundamentally a quadratic problem in terms of its computational complexity, since in principle all triangles must be compared with all others. We reflect the 2D nature of this process by storing the triangles as multiple 1D textures in texture memory, and then exploit the massive parallelism of graphics processing units (GPUs) to perform pairwise comparisons, using a pixel shader. This approach avoids the creation and maintenance of auxiliary geometric structures, such as a bounding volume hierarchy (BVH); but nevertheless we can plug in auxiliary culling schemes, and use stencils to indicate triangle pairs that do not need to be compared. To overcome the readback bottleneck between GPU and CPU, we use a hierarchical encoding scheme. We have applied our technique to detecting self-intersections in extensively deformed models, and we achieve an order of magnitude increase in performance over CPU-based techniques such as [17].