SPARP: a single pass antialiased rasterization processor

Abstract

We present a rasterization processor architecture named SPARP (single-pass antialiased rasterization processor), which exploits antialiased rendering in a single pass. Our architecture is basically based on the A-buffer (Carpenter, Computer graphics 1985;19:69–78) algorithm. We have modified the A-buffer algorithm to enhance the efficiency of hardware implementation and quality of the image rendered, such as the data structure of pixel storage elements, the merging scheme of partial-coverage pixels, and the blending of partial-coverage or non-opaque pixels. For the scan conversion and generation of subpixel masks, we use the representation of edges that was proposed by Schilling (Computer graphics 1991;25:131–41). We represent partial-coverage pixels for a pixel location by a front-to-back sorted list as in the A-buffer and dynamically manage the list storage. We have devised a dynamic memory management scheme that extremely simplifies the memory managing overheads so that we can build it by hard-wired logic circuitry. In our architecture we can render an antialiased scene with the same rendering context of Z-buffer method. Depending on the scene complexity, proposed architecture requires rasterization time 1.4–1.7 times as much as a Z-buffer rasterizer does. The buffer memory requirements can vary depending on the scene complexity; the average storage requirement is 2.75 times that of the Z-buffer for our example scenes. Our architecture can be used with most rendering algorithms to produce high-quality antialiased images at the minimally increased rendering time and buffer memory cost, but due to the improvements in semiconductor technology we can expect that antialiased rasterization processors will be widely adopted in the near future.

Introduction

There has been a great deal of work in graphics on antialiased rendering. To reduce aliasing artifacts of the Z-buffer resulting from point sampling, many rendering algorithms have been proposed, such as supersampling, stochastic sampling [1], and the A-buffer [2]. Supersampling reduces aliasing artifacts by increasing the frequency of the sampling grid. Stochastic sampling is a method that makes higher frequency components of an image noise rather than aliases by irregular sampling. These techniques sample an image at multiple points and apply filtering to a sampled image to get a final rendered image. Supersampling and stochastic sampling require multiple rendering passes or massive parallel hardware renderers, so they are inadequate for real-time image generation at moderate hardware cost.

As a continuous image domain filtering for antialiasing, Catmull [3] proposed an algorithm that performs subpixel geometry for polygons but approximates the intensity of a polygon as a constant value. It computes the intensity by using visible subpixel fragments as weights in an intensity sum. This is equivalent to convolving the image with a box filter. Despite an approximation of the intensity, it is extremely expensive to calculate precise coverage areas over pixels and filter extents. To approximate the process of calculating of coverage areas, Carpenter [2] uses bit-masks to area sample subpixel fragments, developing a technique known as the A-buffer. Coverage and area weighting is accomplished by using bit-wise logical operators between masks representing polygon fragments, and the processing per pixel square will depend only on the number of visible fragments. In the A-buffer, the contribution of surfaces that cover partially are arranged in a list that is sorted front-to-back. Two z-values are stored for each fragment, z_min and z_max, and these values are used for the determination of the visible area of the fragment. When all fragments have been added to the list, the intensity is calculated in a process called packing. As pointed out by Schilling [4], the method of calculating the visible area using two z-values per fragments will fail very often. Schilling proposed an algorithm to resolve the visible area determination of two intersecting fragments within a pixel using a subpixel mask, which is called priority mask. The priority mask indicates which part of the pixel belongs to which object. If two fragments intersect within a pixel and subpixel masks of those fragments are overlapped, the priority mask must be calculated. For the calculation of the priority mask, z and z increment values in the x and y direction are stored for each fragment. The equation for the intersection line can be built using those z values of two intersecting fragments. After normalizing the equation, the line parameters can be used to look up the resulting priority mask. As in the case of the A-buffer, partial fragments are arranged in a depth-sorted list. For list processing, a pipeline of processors was introduced. Each processor, called list processor, can only handle one additional object per pixel. If there is more than one object that are concerned with the pixel, only one object is processed and the other objects are sent to the next list processor. It can resolve all objects by pipelining these processors and cycle through the pipeline if necessary. In this algorithm and architecture the priority mask calculation requires division operations, requiring relatively high hardware cost.

Recently, a few rendering schemes for the hardware-assisted antialiased rendering have been proposed such as chunking [5] and edge tracing. The chunking scheme requires some amount of overheads in the object clipping and the edge tracing scheme is not rendering order independent.

To generate antialiased images in real time, a hardware-assisted rendering technique is substantial. Presented in this paper is a rasterization processor architecture for single-pass antialiased rendering, called SPARP (single-pass antialiased rasterization processor). The goals of the SPARP are:

• To use the same programming model for antialiased rendering as used in the Z-buffer.

• To provide an architecture which does the antialiased rendering in a single pass for the interactive works.

• To render transparent objects.

• To provide an efficient partial-pixel handling method.

In polygonal objects rendering, we have been accustomed to rendering images using a programming model like the Z-buffer method. After a scene is built in virtual space, polygons that construct the scene are fed into the rendering pipeline to render the scene. There is no order to render those polygons in the Z-buffer method. In the SPARP, the major goal is to use the same programming model for properly antialiased image rendering and transparent objects rendering. We have modified the data structure of the A-buffer, and partitioned the rendering pipeline into two phases — the rasterization phase and the post-processing phase. During the rasterization phase, objects are rasterized and stored to the buffer memory in two categories. One is the full pixel that needs no more processing and the other is the partial pixel that requires a procedure to handle it. Partial pixels are produced at the boundary of polygons during the rasterization process. A partial-pixel handler creates a new linked list for a new partial pixel at the given pixel location or inserts the partial pixel into the present list. During the inserting operation, partial pixels can be merged if they meet the merging criteria. The merging operation is important in reducing the storage requirement of partial pixels during the rasterization phase. We must find the merging schemes that minimize the storage requirement for partial pixels with minimized artifacts in the rendered image. By our merging algorithm, we eliminate most of the intermediate partial pixels during the rasterization phase. To manage the dynamic storage allocation of partial pixel storage, we have developed a simple and efficient new memory-managing scheme that recycles the storage of deallocated elements. The main issue of the managing scheme of the partial pixel storage is the simplicity that can be implemented effectively by hardware. In the post-processing phase, partial pixels are blended at the subpixel level and averaged to construct the final color value.

The rasterization and the post-processing phase can be pipelined using two sets of buffer memories as in double buffering. The total amount of processing time for the post processing phase is less than that of the rasterization phase in most of our rendering experiments.