Graphics pipeline stages relevant in the context of multisampling.
In order to understand where we can reduce processing rate, let’s look at the relevant graphics pipeline stages and resources: This enables multisampling to achieve better overall performance-to-quality ratio than naive supersampling. Multisampling is essentially a performance optimization to supersampling where certain operations within the graphics pipeline that don’t have significant (or sometimes any) effect on aliasing are allowed to operate at a reduced rate. The main problem with naive supersampling is that the performance and memory usage cost is also increased by the same ratio. the ratio of the resolution at which the rendering pipeline was evaluated and the resolution at which the results are displayed. The quality improvement is roughly proportional to the number of samples evaluated per pixel, i.e. Obviously, supersampling doesn’t completely eliminate aliasing, really nothing can in a discrete processing pipeline, however it can significantly reduce its effect. Illustration of single-sampled rendering (left) and 4x supersampled rendering with resolve (right).įrom a terminology perspective this leads us to the notion of sample whereas we refer to the collection of values in the supersampled image contributing to a particular value in the final target image as pixels, and we call the individual values within those collections as the samples of the pixel. This downsampling process is called a resolve operation. twice the width and height to achieve 4x supersampling) and then downsampling the produced image to the target resolution, usually with a simple box filter.
The simplest way to implement supersampling is to render at a higher resolution than the final target (e.g. Supersampling improves this by increasing the sampling resolution of the entire rendering pipeline.
In general, any sort of screen-space aliasing is the result of the very nature of evaluating rendering functions at discrete units (typically per-pixel, at pixel centers) hence producing noticeable under-sampling induced artifacts. Hence familiarity with the behavior and configuration parameters available in modern multisampling hardware implementations comes handy in a wide set of rendering problems.
While it’s quite common nowadays for renderers to use other, lower cost and often less intrusive techniques to reduce screen-space aliasing like temporal anti-aliasing or various morphological techniques, multisampling remains prevalent as a standard go-to technique to perform anti-aliasing, is often used in conjunction with the aforementioned alternatives, and sometimes (ab)used to aid more complex rendering algorithms like checkerboard rendering to achieve better perceived resolution, quality, and/or performance. In this article we present the behavior of basic multisampling and explore a set of controls that enable us to tune performance/quality trade-offs and open doors for more advanced rendering techniques. Multisampling is a well-understood technique used in computer graphics that enables applications to efficiently reduce geometry aliasing, yet not everybody is familiar with the entire toolset offered by modern GPU hardware to control multisampling behavior.