So, how is it that tile-based rendering is so much different from conventional rendering methods that popular products from NVIDIA, ATI and 3dfx utilize? To delve into this complicated topic, let me first explain to you how conventional rendering methods work and then compare that to the KYRO's tile-based rendering; however, before we begin, I must mention that all methods of rendering techniques have one sole purpose: to generate a graphical 3D scene that can be displayed on a 2D screen using millions of mathematical calculations and enormous amounts of computer data. The diagram below shows the task that all video cards essentially perform:

The conventional rendering method that I'm referring here is called "immediate mode rendering" and is currently used by most of today's consumer-level graphics products. The basic process that it follows is this:

The key here is that the accelerator will process the entire scene as a whole and each polygon of the scene individually without knowledge of which goes in front of which. Textures are then applied to every face of each polygon; again, without knowledge of which goes in front of which. Once the entire scene has passed this stage and every bit of each polygon is textured, it is then passed to the "depth test," a stage in the rendering process that utilizes the z-buffer. What is a z-buffer, I hear you all crying? The z-buffer is a portion of the graphics system that is used to store the depth of each pixel in the scene. In immediate mode rendering, a portion of the graphics memory is used for storing the z-buffer. Using the z-buffer, the textured polygons in the scene finally know which is in front of which and this is the stage that the overlapping portions of the polygons are simply discarded. The overlapping aspect is called "overdraw" and will prove important for the improvements that tile-based rendering can bring. The scene is then passed on to the final stage where the textured polygons are blended for transparent polygons and finally drawn and sent to the frame buffer for displaying.

By looking at this method, it seems that there is a lot of work and memory bandwidth being wasted on portions of the image that will eventually be thrown out anyways at the end. That's exactly what the KYRO aims to change with its tile-based rendering method.

The tile-based rendering method allows the KYRO to reorganize the different rendering stages and, essentially, follows this process:

The secret to the tile-based rendering method lies right in the name itself. Instead of rendering the entire scene at one time and each polygon individually, they're grouped together into what are called "display lists" and, because of such, allows the entire scene to be literally cut up into small "tiles," each rendered individually by the KYRO.

The first benefit that arises from rendering each tile individually rather than an entire scene at a time lies in the aforementioned z-buffer. As each tile is rendered individually, the required size for the z-buffer becomes considerably less, thus, allowing the KYRO to have an on-chip z-buffer. Having an on-chip z-buffer eliminates the need for continual memory accesses and, therefore, freeing up the memory for other tasks, such as textures storage.

The rendering of each tile individually instead of each polygon individually now means that the graphics accelerator has knowledge of which polygon is in front of which before it applies the textures to the polygons. This is very important as the depth test, which was the 2nd stage in immediate mode rendering, becomes the very first thing that the graphics accelerator performs on the scene and, therefore, means that it can now discard any pixels that are not going to appear on the final rendered scene before it must go to the video memory for those huge textures that it must apply to each polygon. Doing so will eliminate virtually all overdraw. This saves huge amounts of needed memory bandwidth, as a lot of data has already been discarded before the scene goes through the rest of the rendering pipeline.

The rest of the rendering process is pretty much self-explanatory, as after the depth test, the textures are applied to the remaining pixels and then the final product is sent to be blended (for transparent polygons) and then displayed.

On to: Internal True Color