Subpixel Reconstruction Antialiasing (SRAA) combines single-pixel (1x) shading with subpixel visibility to create antialiased images without increasing the shading cost. SRAA targets deferred-shading renderers, which cannot use multisample antialiasing. SRAA operates as a post-process on a rendered image with superresolution depth and normal buffers, so it can be incorporated into an existing renderer without modifying the shaders. In this way SRAA resembles Morphological Antialiasing (MLAA), but the new algorithm can better respect geometric boundaries and has fixed runtime independent of scene and image complexity. SRAA benefits shading-bound applications. For example, our implementation evaluates SRAA in 1.8 ms (1280x720) to yield antialiasing quality comparable to 4-16x shading. Thus SRAA would produce a net speedup over supersampling for applications that spend 1 ms or more on shading; for comparison, most modern games spend 5-10 ms shading. We also describe simplifications that increase performance by reducing quality.

High Quality Elliptical Texture Filtering on GPU


http://www.pmavridis.com/ewa.html

Abstract

The quality of the available hardware texture filtering, even on state of the art graphics hardware, suffers from several aliasing artifacts, in both spatial and temporal domain. Those artifacts are mostly evident in extreme conditions, such as grazing viewing angles, highly warped texture coordinates, or extreme perspective and become especially annoying when animation is involved.

In this paper we introduce a method to perform high quality texture filtering on GPU, based on the theory behind the Elliptical Weighted Average (EWA) filter. Our method uses the underlying anisotropic filtering hardware of the GPU to construct a filter that closely matches the shape and the properties of the EWA filter, offering vast improvements in the quality of texture mapping while maintaining high performance. Targeting real-time applications, we also introduce a novel spatial and temporal sample distribution scheme that distributes samples in space and time, permitting the human eye to perceive a higher image quality, while using less samples on each frame. Those characteristics make our method practical for use in games and other interactive applications. For cases where quality is more important than speed, like GPU renderers and image manipulation programs, we also present an exact implementation of the EWA filter that smartly uses the underlying bilinear filtering hardware to gain a significant speedup.
Paper (Soon)
Video (Soon)
Slides (Soon)

High Quality Elliptical Texture Filtering on GPU
http://www.pmavridis.com/ewa.html

We present a new antialiasing algorithm which exploits subpixel geometry
information to reconstruct subpixel shading for antialiasing.
SRAA runs in a few milliseconds on today’s GPUs, which makes
it practical for real-time rendering applications. It will also scale to
take advantage of increased bandwidth and computation on future
GPUs. The algorithm can work with any underlying sampling pattern
and number of shading samples. For example, it scales with
more geometric samples (as seen in Figure 11) and shading samples.
Unlike MLAA, the algorithm’s time and space cost is independent
of the scene, except for rendering the G-Buffers where the
time increases with scene complexity.
We believe the next step is to combine ideas from SRAA and
MLAA. SRAA uses relatively inexpensive geometric information
to improve expensive shading results and is able to produce very
good edge antialiasing. MLAA’s heuristics often produce overblurring
(Figure 2), but it is able to resolve shading edges that
SRAA cannot. These include texture, shadow, and specular highlight
boundaries. An algorithm that combines heuristic shading
weights with accurate geometric weights may be able to achieve
higher quality than either alone in practice.

Deferred lighting and multisample antialiasing (MSAA) are powerful techniques for real-time rendering that both work by separating the computation of the shading of triangles from the computation of how many samples they cover. Deferred lighting uses deferred shading [SaitoandTakahashi1990] to scale complex illumination algorithms up to large scenes. MSAA resolves edges by shading multiple samples per pixel; unlike SSAA each primitive is shaded at most once. Unfortunately, these two techniques are incompatible (see Section2),so developers must currently choose between high quality lighting and high quality antialiasing.