it gives the image of a smoothed line because the pixelx are of a gradually different color until it matches to the background color/image. fragment aa. not as good imho.
"Multi-Sampling Explained
Multi-Sampling algorithms share many characteristics of super-sampling. Both render a scene to a high-resolution buffer and filter down to achieve the anti-aliasing effect. Yet, that is where the similarities end.
For this consideration, we will assume 4x anti-aliasing is being used. While multi-sampling can be implemented in several different fashions, we will only consider one such method.
Displaying the final image
The first step in multi-sampling is to consider the scene theoretically double in size in both the horizontal and vertical (thus, the picture is a total of four times larger). A triangle edge mask is used to locate those pixels that fall along each triangle edge. Edge pixels take a unique color sample for every sub-pixel, writing four separate color and Z values to their respective buffers. On the other hand, pixels not located on a triangle edge will all share the same original color value, writing four identical color values to the color buffer. Every depth (Z) value will be independently calculated.
On finalizing the scene the image is down-sampled, often using a run-of-the-mill bilinear filter. The four color values are averaged into a single pixel, resulting in the displayed pixel. With the edge pixels having had each sub-pixel uniquely sampled, the filtered value will be an average of the four samples that fell along the edge, creating a more accurate, and anti-aliased value. With this completed for the entire frame, the buffer is flipped and the image is displayed.
This, of course, is just a general overview of one multi-sampling implementation. The actual process is slightly more complex, but for our purposes here, this level of understanding will suffice.
The advantages of multi-sampling over super-sampling are two fold. Multi-sampling requires little additional fill-rate in the implementation we discussed, while in other implementations it can require no greater fill-rate at all. Additionally, with all internal pixels requiring only a single pixel sampling (i.e. A bilinear filtered pixel requires 4 samples, where a super-sampled bilinear filtered pixel requires 16 samples), the result is just a slight increase in texture reads.
On the negative side, buffer storage requirements are extensive, as is bandwidth consumption. Just as with super-sampling, color and z-buffers because four times larger than at the selected resolution. A linear increase in bandwidth consumption takes place, with larger buffers requiring greater bandwidth.
Fragment Level Algorithms
Fragment level algorithms do not work on a sub-pixel level, but rather on a fragment level. A sub-pixel is effectively an entire pixel of its own, whereas a fragment is simply a segment of a complete pixel. A sub-pixel will store a full color and Z value, where a fragment will only store information regarding a segment of a complete pixel.
Buffer sizes do not increase with fragment level algorithms, as the number of pixels dealt with is exclusively dependant on the selected resolution. A variation in storage is only found in that the fragment data must be stored in a separate buffer. This storage requirement is notably less than with multi-sampling, as similar anti-aliasing levels can be achieved with relatively few fragments.
When rendering a scene while using fragment level anti-aliasing (such as that used by Matrox Parhelia-512) one basically performs all operations normally. The scene is rendered and all is well. The variation occurs in that an additional stage is added to the pixel pipeline. This stage uses a coverage mask on each pixel, with each section of the mask being a fragment. When laid over an edge pixel, it is determined as to whether or not each fragment falls within the triangle in question. If the fragment is found inside the triangle, it is assigned a value of one, where if the fragment is outside of the edge, the assign value is zero.
With the fragment level data having been determined for a pixel, this data is carried along the pipeline as the pixel is rendered. When the pixel is completed, it is written as a normal pixel, without any anti-aliasing. The fragment data is written to a fragment buffer and stored for later use.
Filtering must take place after completion of the scene and this is where the fragment data comes into play. With numerous filter types existing, the exact method used is entirely up to the engineers designing the system. Any filter shape can be used, such as a box, X, or crossed shape, or even the ever popular quincunx pattern.
The filtering process takes place by making note of what percentage of the pixel is within the triangle and what percentage is outside of it. The side(s) of the pixel that are in and out of the triangle must be considered as well to properly filter.
With the filtering information available, the pixel in question is blended with neighboring pixels. While technically blurring, and thus not ideal, one might consider this a ?smart blur? in that it only does so along edges so as not to distort the image and blurs at a calculated level with the pixels that are calculated to be used for such. We will discuss the level of quality actually delivered later in this article.
Performance
Fragment level algorithms hold a key advantage in performance over multi-sampling and super-sampling algorithms. Where super-sampling requires 75% more fill-rate and bandwidth and multi-sampling requires nearly the same level of bandwidth, fragment level algorithms require no additional fill-rate, nor do they consume such relatively high levels of bandwidth.
For example, with super-sampling and multi-sampling, Z and Color buffers increase in size by 300% each. So, for example, if you have a 1MB color buffer without anti-aliasing, super and multi-sampling will increase this to 4MB each. Thus, with Z and color buffer, a 2 MB storage requirement is increase to 8 MB. Yet, in the same situation with a fragment level algorithm, one must simply store an additional 1 MB buffer. Storage requirements then would increase from 2 MB to 3 MB.
We can thus see that performance is minimally impacted with fragment level algorithms, with no fill-rate reduction and minimal bandwidth increases. The only performance loss that will then be associated with such an algorithm are from any potential pipeline stalls, as well has having to filter the final image.
Quality
Examining the quality of a fragment level algorithm is rather tricky. Super-sampling?s quality increase is very linear in that if you set an anti-aliasing level you know exactly what to expect. On the other hand, fragment level algorithms can provide a variety of different results.
On a typical edge, such as that of a wall, a fragment level algorithm is going to provide a very high quality result. It will often be noticeably superior to that of both super and multi-sampling for the pixel in question has been more accurately calculated and a greater blend is produced. However, as potentially with multi-sampling, certain edges will receive no anti-aliasing. These edges include alpha blended surfaces where algorithms typically are unable to detect the edges, as well as surface that are simulated by textures (such as leaves on trees). Additionally, fragment level algorithms are unable to anti-alias triangle intersections. While more often than not, this is not an issue, it is something that the trained eye will notice. Consider the following two images to get an idea of the level of quality provided by a fragment algorithm. The first is of Bitboys? MatrixAA and the second is that of Matrox?s FAA implementation.
Finally, the last obstacle of fragment level algorithms is that of blurring. While generally not a problem, it can become one when near pixel size triangles are used. For example, if a group of 1-2 pixel triangles are joined together and the filter is used over all of them, texture detail will be lost to do each pixel being an edge and thus requiring filtering.
Final Thoughts
The two approaches being used at present are multi-sampling and fragment level algorithms. Certain low-end parts continue to provide super-sampling exclusively as it requires no additional hardware, but with the next generation of graphics processors we can expect this to likely phase out, with all parts adopting multi-sampling or fragment level algorithms.
With any algorithm there will obviously be tradeoffs. Super-sampling requires very high levels of fill-rate; multi-sampling alleviates this requirement but also requires the use of high levels of bandwidth (though this is getting better by means of data compression). Fragment algorithms alleviate any performance issue and often deliver high quality levels, though certain surfaces will not achieve the desired anti-aliasing result.
Matrox is the big pusher of fragment level anti-aliasing today. At present, they still have some issues with their implementation, yet rumors have it that this will be corrected in their next-generation part (though recent reports indicate this part will never even see the light of day). If so, it is certainly a worthwhile feature.
As for Bitboys, we are aware that they have a fragment level anti-aliasing algorithm called MatrixAA, yet no information has been provided as to the exact functionality. Due to this, it is difficult to even speculate on how they operate internally.
Whether or not one decides to go the fragment route, it is certainly an interesting alternative to have available. Even if not used as the primary anti-aliasing method, there is nothing to stop fragment anti-aliasing from being left as a low-cost alternative for the most demanding applications, or even allowing it to be used in conjunction with other techniques. Without question, this approach is a viable alternative worth consideration by all."
from firing squad article
http://www.firingsquad.com/print_articl...rent_section=Guides&fs_article_id=1157
of course, with fragment aa, image quality is no where as good as fsaa
Facebook
Twitter