Atomic primitive mode (gPipelineMode(G_PM_1PRIMITIVE)) is intended to avoid span buffer coherency problems which can be caused by successive primitives with overlapping spans during "read-modify-write" modes (Z-buffered or blended modes). The 1PRIMITIVE mode inserts a delay into the pipeline between each primitive to make sure there are no overlaps.
In reality, the overlap case is very rare, and would be hard to see unless you were looking for it. In the worst case, the lost cycles between primitives can add up to about 1-1.5Mpixels/sec of lost fill rate.
To disable the atomic primitive mode, use the following command.
gPipelineMode(G_PM_NPRIMITIVE)
A "partial sorting" of objects being drawn can accelerate rendering when using Z-buffering. The Z-buffer test is a conditional write, so if objects are drawn in roughly front-to-back order, this test will often prevent the write to update the Z-buffer value.
Z-buffer causes major penalty in fill rate. Antialiasing also causes some performance loss in fill rate. We have included a simple performance tool (blockmonkey) in the release to give you a feel for geometry and fill rate performance.
There are many visibility sorting algorithms available and even more hybrids of these algorithms. There are also properties of particular games that impart valuable information about depth order. If a game can use these techniques and avoid Z-buffering, performance will improve.
If a group of objects are all convex, a centroid or bounding volume sort and back-face rejection will give the proper rendering order.
Many meshed objects have a small number of mesh traversal orders which are correct sorts at arbitrary orientation, even though they are concave. Meshed objects are topologically 2D, for example, a torus, a terrain height field, building corridors, etc. With one batch of vertex points, one of several polygon descriptor display lists could be selected by view location. For example, the polygons in a terrain mesh might have four orders across the mesh, S+T+, S-T+, S+T-, S-T-. The two sides of the mesh then closest to the view point select the order.
Cells are simply a higher level of mesh, where the cell draw order can be determined from view.
Often layers of data are known never to be behind another (buildings on a landscape, furniture in a room). then the layers can be drawn in this order, with only a sort within each layer.
Attractive since data need only be accessed once. A linked list of buckets can avoid local overflow without excessive memory usage. The bucket can be a display list, for example, of calls to clamps.
Clamps of polygons in which NO sort order is correct (three long triangles arranged in a triangle in which at each corner a different triangle is in front) have no visibility solution without subdivision.
Many game situations provide implied visibility order between objects or even within objects. Consider a jet fighter flight simulator game: The player is always moving "toward" (in general) and targets attack from a limited number of directions. This could allow you to model the targets carefully and achieve correct surface visibility determination, even if they are not strictly convex.
Turning off antialiasing can help increase fill rate. To minimize the aliasing effects, you can increase the horizontal resolution of the framebuffer. Performance tests (blockmonkey) show that 512x240 "no AA no ZB" is faster than 320x240 "AA no ZB" on large polygons. In some cases, this is better than a 25% gain, in exchange for an increase in framebuffer size.
On smaller polygons, you will pay a 5% to 10% fixed overhead due to additional video bandwidth. Both antialiasing and dither filter video hardware require fetching 3 scan lines and filter down to produce a single scan line of video.
Reduced Aliasing refers to a blender mode (see the G_RM_RA* macros in gbi.h) in which the color and the pixel coverage are only written instead of the normal read/modify /write cycle. In this mode silhouette edges will be antialiased, but internal edges of an object will not be antialiased. This mode works with and without Z-buffering.
Silouettes can also have artifacts in this mode when displayed on top of a surface which has edges through it, such as a tessellated background, which has also been rendered in this mode. This is because the edges in the background will be partial, rather than fully covered. In this case, the pixel will have multiple partial fragments, and the antialiasing on the silhouette will look wrong. A possible work around for this problem is to render the background in non-antialiased mode, which will write full coverage to the framebuffer. Then render the foreground characters using this reduced antialiasing mode.