Graphics processor with deferred shading

• US 6,597,363 B1
• Filed: 08/20/1999
• Issued: 07/22/2003
• Est. Priority Date: 08/20/1998
• Status: Expired due to Term

• Current Assignee: Apple Inc.
• Original Assignee: Apple Computer Incorporated (Apple Inc.)
• Inventors: Papakipos, Matthew N., Duluk, Jerome F. Jr., Bratt, Joseph P., Fang, Emerson S., Redgrave, Jason R., Dodgen, Stephen L., Li, Sidong, Ng, Sam, Gong, Zhaoyu, Tuck, Nathan D., Cuan, George, Hessel, Richard E., Hsu, Hengwei, Benkual, Jack, Trivedi, Sushma S., Arnold, Vaughn T., Ho, Thomas Y.
• Primary Examiner(s): Bella, Matthew C.
• Assistant Examiner(s): Monestime, Mackly
• Application Number:
  US09/378,637
• Time in Patent Office: 1,432 Days
• Field of Search: 345/506, 345/419, 345/420, 345/421, 345/422, 345/545, 345/563, 345/427, 345/582, 345/653, 345/654, 345/664, 345/665, 345/622, 345/623
• US Class Current: 345/506
• CPC Class Codes: G06T 11/40 Filling a planar surface by adding surface attributes, e.g. colour or texture
• CPC Class Codes: G06T 15/005 General purpose rendering architectures
• CPC Class Codes: G06T 15/04 Texture mapping
• CPC Class Codes: G06T 15/20 Perspective computation
• CPC Class Codes: G06T 15/30 Clipping
• CPC Class Codes: G06T 15/405 using Z-buffer
• CPC Class Codes: G06T 15/50 Lighting effects
• CPC Class Codes: G06T 15/83 Phong shading

Abstract

Graphics processors and methods are described that encompass numerous substructures including specialized subsystems, subprocessors, devices, architectures, and corresponding procedures. Embodiments of the invention may include one or more of deferred shading, a bled frame buffer, and multiple-stage hidden surface removal processing, as well as other structures and/or procedures. Embodiments of the present invention are designed to provide high-performance 3D graphics with Phong shading, subpixel anti-aliasing, and texture- and bump-mappings.

Claims

1. A graphics rendering system for forming a rendered image from graphics primitives, the rendered image stored in a frame buffer, the graphics rendering device comprising:

(A) a host processor;

(B) a system memory;

(C) a frame buffer storing pixels;

(D) a device for receiving commands comprising;

(1) a 2D command queue memory receiving and storing first direct memory access commands and first commands to perform two-dimensional graphics operations;

(2) a 3D command queue memory receiving and storing second direct memory access commands and second commands to perform three-dimensional graphics operations, the second commands comprising;

some of the graphics primitives; and

part of a pipeline state;

(3) a 2D response queue memory receiving and storing third commands to perform two-dimensional graphics operations;

(4) a 3D response queue memory receiving and storing fourth commands to perform three-dimensional graphics operations, the fourth commands comprising;

some of the graphics primitives; and

part of the pipeline state; and

(5) a direct memory access controller coupled to the 2D command queue memory and the 3D command queue memory, the direct memory access controller comprising;

(a) logic receiving the stored first direct memory access commands and performing the first direct memory access commands by reading the third commands from the system memory and writing the read third commands into the 2D response queue; and

(b) logic receiving the stored second direct memory access commands and performing the second direct memory access commands by reading the fourth commands from the system memory and writing the read fourth commands into the 3D response queue.

(E) a geometry unit comprising;

(1) logic transforming the graphics primitives;

(2) logic clip testing the graphics primitives to determine if the graphics primitives are at least partially contained in a view volume;

(3) logic performing face determination to discard any of the graphics primitives that are facing away from a viewing point;

(F) a sort memory storing;

(1) the part of the pipeline state needed for hidden surface removal; and

(2) the part of the graphics primitives needed for hidden surface removal, comprising vertex locations;

(G) a state memory storing;

(1) the graphics primitives for a frame with attributes of the graphics primitives; and

(2) the part of the graphics primitives not needed for hidden surface removal, comprising vertex colors and texture coordinates;

(H) a sort unit comprising;

(1) logic sorting the graphics primitives according to tile areas within the image;

(2) logic reading the sorted graphics primitives from the sort memory according to tile;

(I) a setup unit computing derivatives for the sorted graphics primitives;

(J) a cull unit performing hidden surface removal to determine which portions of the graphics primitives stored in the scene memory affect the final color of the pixels in the frame buffer;

(K) one or more computational units generating fragment color for each sample or group of samples within each of the pixels, the generation of color values for each of the pixels being done only for the portions of the graphics primitives that are determined to affect the pixels, the computational units comprising;

(1) a device for interpolating data associated with the graphics primitives, the device comprising;

(a) a memory storing cache fill polygon color data, the color data comprising vertex coordinates, w coordinates, and texture coordinates;

(b) logic computing barycentric coefficients for each of the graphics primitives from the vertex coordinates and the w coordinates;

(c) a cache memory storing a plurality of data cache entries corresponding to a plurality of the graphics primitives, the cached data comprising barycentric coefficients and texture coordinates;

(d) a register receiving a fragment of one of the graphics primitives, the fragment comprising fragment coordinates and a sample mask, the sample mask indicating sample locations within the pixel covered by the fragment;

(e) a lookup table determining lower bits of an interpolation location, an input of the lookup table comprising the sample mask, the interpolation location having sub-pixel accuracy;

(f) logic selecting and reading one of the stored data cache entries corresponding to the received fragment;

(g) logic computing interpolation coefficients from the barycentric coefficients and the interpolation location; and

(h) logic interpolating the texture coordinates using the computed interpolation coefficients, generating texture coordinates at the interpolation location;

(2) a device for interpolating vertex surface normals comprising;

(a) logic decomposing each of the vertex surface normals into a vertex magnitude vector and a vertex direction vector;

(b) logic computing an interpolated magnitude vector from a plurality of the vertex magnitude vectors and the computed interpolation coefficients;

(c) logic computing an interpolated direction vector from a plurality of the vertex direction vectors and the computed interpolation coefficients; and

(d) logic combining the interpolated magnitude vector and the interpolated direction vector to generate an interpolated surface normal.

(L) a pixel unit comprising;

(1) logic blending the fragment colors together to generate per-pixel color values; and

(2) logic storing the generated per-pixel color values into the frame buffer;

(M) a status monitoring device comprising;

(1) logic associating object tags with the three-dimensional objects as the three-dimensional objects are processed by the graphics rendering system;

(2) logic testing the three-dimensional objects with one or more visibility criteria as the three-dimensional objects are processed in the graphics rendering system;

(3) a status register comprising a plurality of bits;

(4) logic selecting one of the bits in the status register according to one of the object tags;

(5) logic setting the value of the selected bit in the status register according to response of the corresponding one of the three-dimensional objects to the testing with the visibility criteria; and

(6) logic reading and transmitting the status register contents to the host processor, the host processor determining which of the three-dimensional objects are at least partially visible;

(N) a device for storing a digital image into the frame buffer comprising;

(1) a first memory storing a window identifier map, the window identifier map comprising a window identifier for each of the pixels in the frame buffer;

(2) a second memory storing a plurality of bounding box descriptions, each of the bounding box descriptions comprising maximum and minimum pixel coordinates of the corresponding bounding box and a bounding box window identifier;

(3) a register storing a programmatically assigned image identifier associated with the digital image;

(4) logic selecting an image pixel from the digital image;

(5) pixel ownership logic operating on the selected image pixel, the pixel ownership logic comprising;

(a) window identifier map test logic enabled by a programmatically set control bit, the window identifier map test logic comprising;

(i) logic reading the window identifier from the first memory that corresponds to the selected image pixel;

(ii) a comparator circuit comparing the assigned image identifier to the read window identifier; and

(iii) logic discarding the selected image pixel if the assigned image identifier does not match the read window identifier; and

(b) bounding box test logic enabled by a programmatically set control bit, the bounding box test logic comprising;

(i) logic selecting a first one of the bounding box descriptions such that the selected pixel is within the maximum and minimum pixel coordinates of the selected first bounding box description;

(ii) a comparator circuit comparing the assigned image identifier to the bounding box window identifier of the first bounding box description; and

(iii) logic discarding the selected image pixel if the assigned image identifier does not match the bounding box window identifier of the first bounding box; and

(c) logic writing the selected image pixel to the frame buffer if the selected image pixel was not discarded.

(O) a scanout device comprising;

(1) logic generating a histogram of the pixel values in the rendered image as the pixel values are stored into the frame buffer;

(2) logic computing a transformation function, based on the histogram, to adjust the scale and dynamic range of the pixel values so as to match the digital-to-analog converter;

(3) logic reading the pixel values from the frame buffer in a raster line order;

(4) logic transforming the read pixel values according to the computed transformation function; and

(5) logic inputting the transformed pixel values to the digital-to-analog converter.

(P) a scanout device comprising;

(1) a memory storing programmatically downloaded interpolation coefficients;

(2) a register storing a programmatically selected one of a plurality of fixed zoom ratios;

(3) a register storing a programmatically selected location of a zoom bounding box within the computer display;

(4) a register storing a programmatically assigned a window identifier associated with the zoom bounding box;

(5) logic reading a first pixel color from the frame buffer;

(6) logic reading a plurality of second pixel colors from the frame buffer;

(7) logic computing a zoomed pixel color from the plurality of second pixel colors and the downloaded interpolation coefficients;

(8) logic reading a pixel window identifier from the frame buffer;

(9) logic sending the computed zoomed pixel color to the digital-to-analog converter if the display pixel is within the zoom bounding box and the pixel window identifier equals the window identifier assigned to the zoom bounding box; and

(10) logic sending the read first pixel color to the digital-to-analog converter if the display pixel is not within the zoom bounding box or the pixel window identifier does not equal the window identifier assigned to the zoom bounding box.

2. A graphics rendering method for forming a rendered image in a frame buffer from graphics objects, the graphics objects comprising a plurality of graphics primitives, the method comprising the steps:

assigning tags to the objects;

testing the objects with one or more visibility criteria as the objects are processed in the graphics rendering pipeline, the testing of each of the objects comprising the testing of the primitives within the object;

setting bits in a status word indicating the response of the tagged objects to the testing with the visibility criteria; and

reading the status word to determine which of the objects are at least partially visible.

3. The graphics rendering method of claim 2, the method further comprising the steps:

the step of inputting graphics objects comprising the inputting of the graphics primitives so as to approximate bounding volumes of the objects;

reading the status word to determine the visibility of the bounding volumes;

discarding the objects when the corresponding bounding volume is determined to be not visible receiving the graphics objects;

accumulating a plurality of the objects by storing the graphics primitives in a memory;

processing the accumulated objects to divide the primitives into stamp portions, remove portions of the primitives that are guaranteed to not affect the final results in the frame buffer, and identify other potions of the primitives as visible stamp portions; and

performing the step of processing the accumulated objects on a plurality of the objects before performing the step of reading the status word, the status word then being used to determine the visibility of each of the plurality of the accumulated objects.

4. A graphics rendering method for forming a rendered image stored in a frame buffer, the graphics rendering method comprising the steps:

receiving graphics primitives;

transforming the graphics primitives;

clip testing the graphics primitives to determine if the graphics primitives are at least partially contained in a view volume;

face determination to discard any of the graphics primitives that are facing away from a viewing point;

performing setup for incremental render for the graphics primitives, comprising the computing of derivatives;

storing, in a spatial memory;

(1) the part of the pipeline state needed for hidden surface removal; and

(2) the part of the graphics primitives needed for hidden surface removal, comprising vertex locations and spatial derivatives;

storing, in a polygon memory;

(1) the part of the pipeline state not needed for hidden surface removal; and

(2) the part of the graphics primitives not needed for hidden surface removal, comprising vertex colors, texture coordinates, and color derivatives;

hidden surface removal to determine which portions of the graphics primitives stored in the spatial memory affect the final color of pixels in the frame buffer;

fragment coloring to generate color values for each fragment, each fragment comprising a sample or a group of samples within one of the pixels, the generation of color values for each of the fragments being done only for the portions of the graphics primitives that are determined to affect the final color of pixels in the frame buffer;

blending the fragment colors together to generate a single color value per pixel; and

storing the generated per-pixel color values into the frame buffer.

5. A graphics rendering method for forming a rendered image stored in a frame buffer, the graphics rendering method comprising the steps:

receiving graphics primitives;

transforming the graphics primitives;

clip testing the graphics primitives to determine if the graphics primitives are at least partially contained in a view volume;

face determination to discard any of the graphics primitives that are facing away from a viewing point;

sorting the graphics primitives according to tile areas within the image;

storing, in a sort memory;

(1) the part of the pipeline state needed for hidden surface removal; and

(2) the part of the graphics primitives needed for hidden surface removal, comprising vertex locations;

storing, in a state memory;

(1) the part of the pipeline state not needed for hidden surface removal; and

(2) the part of the graphics primitives not needed for hidden surface removal, comprising vertex colors and texture coordinates;

reading the sorted graphics primitives from the sort memory according to tile;

performing setup for incremental render on the sorted graphics primitives read from the sort memory, comprising the computing of derivatives;

hidden surface removal to determine which portions of the sorted graphics primitives affect the final color of pixels in the frame buffer;

fragment coloring to generate color values for each fragment, each fragment comprising a sample or a group of samples within one of the pixels, the generation of color values for each of the fragments being done only for the portions of the graphics primitives that are determined to affect the final color of pixels in the frame buffer;

blending the fragment colors together to generate a single color value per pixel; and

storing the generated per-pixel color values into the frame buffer.

6. A method for displaying a graphics image within a window on a computer display, the method comprising the steps:

storing an image in a frame buffer;

downloading interpolation coefficients;

selecting one of a plurality of fixed zoom ratios;

locating a zoom bounding box within the computer display;

assigning a window identifier to the zoom bounding box;

for a display pixel within the computer display, sending pixel data to a digital-to-analog converter, further comprising the steps;

reading a first pixel color from the frame buffer;

reading a plurality of second pixel colors from the frame buffer;

computing a zoomed pixel color from the plurality of second pixel colors and the downloaded interpolation coefficients;

reading a pixel window identifier from the frame buffer;

if the display pixel is within the zoom bounding box and the pixel window identifier equals the window identifier assigned to the zoom bounding box, sending the computed zoomed pixel color to the digital-to-analog converter; and

if the display pixel is not within the zoom bounding box or the pixel window identifier does not equal the window identifier assigned to the zoom bounding box, sending the read first pixel color to the digital-to-analog converter.

7. A method for storing a digital image into a frame buffer, the frame buffer comprising an array of pixels, the method comprising the steps:

storing a window identifier map, the window identifier map comprising a window identifier for each of the pixels in the frame buffer;

storing a plurality of bounding box descriptions, each of the bounding box descriptions comprising maximum and minimum pixel coordinates of the corresponding bounding box and a bounding box window identifier;

assigning an image identifier to the digital image;

selecting an image pixel from the digital image;

ownership testing the selected image pixel, the ownership test comprising the steps;

if a window identifier map test is enabled, the window identifier map test is performed, comprising the steps;

reading the window identifier from the window identifier map that corresponds to the selected image pixel;

comparing the assigned image identifier to the read window identifier; and

if the assigned image identifier does not match the read window identifier, the selected pixel is discarded and not written to the frame buffer; and

if a bounding box test is enabled, the bounding box test is performed, comprising the steps;

selecting a first one of the bounding box descriptions such that the selected pixel is within the maximum and minimum pixel coordinates of the first bounding box description;

comparing the assigned image identifier to the bounding box window identifier of the first bounding box description; and

if the assigned image identifier does not match the bounding box window identifier of the first bounding box description, the selected pixel is discarded and not written to the frame buffer; and

writing the selected image pixel to the frame buffer if the selected image pixel was not discarded.

8. The method for storing a digital image into a frame buffer of claim 7, further comprising the step:

storing the window identifier map in the frame buffer.

9. The method for storing a digital image into a frame buffer of claim 7, wherein the step of ownership testing is performed on a plurality of pixels in parallel.

10. A device for receiving commands in a computer graphics processor, the device comprising:

a 2D command queue memory receiving and storing first direct memory access commands and first commands to perform two-dimensional graphics operations;

a 3D command queue memory receiving and storing second direct memory access commands and second commands to perform three-dimensional graphics operations;

a 2D response queue memory receiving and storing third commands to perform two-dimensional graphics operations;

a 3D response queue memory receiving and storing fourth commands to perform three-dimensional graphics operations; and

a direct memory access controller coupled to the 2D command queue memory and the 3D command queue memory, the direct memory access controller comprising;

(1) first logic receiving the stored first direct memory access commands and performing the first direct memory access commands by reading the third commands from a memory external to the computer graphics pipeline and writing the read third commands into the 2D response queue; and

(2) second logic receiving the stored second direct memory access commands and performing the second direct memory access commands by reading the fourth commands from the memory external to the computer graphics pipeline and writing the read fourth commands into the 3D response queue.

11. The device for receiving commands in a computer graphics processor of claim 10, the device further comprising:

a programmable 2D high water mark register storing the number of entries allowed in the 2D command queue memory;

logic generating an interrupt when the number of entries in the 2D command queue memory is greater than the number stored in the 2D high water mark register;

a programmable 2D low water mark register storing the maximum number of entries in the 2D command queue memory before writing to the 2D command queue is allowed; and

logic generating an interrupt when the number of entries in the 2D command queue memory is less than the number stored in the 2D high water mark register;

a programmable 3D high water mark register storing the number of entries allowed in the 3D command queue memory;

logic generating an interrupt when the number of entries in the 3D command queue memory is greater than the number stored in the 3D high water mark register; and

a programmable 3D low water mark register storing the maximum number of entries in the 3D command queue memory before writing to the 3D command queue is allowed; and

logic generating an interrupt when the number of entries in the 3D command queue memory is less than the number stored in the 3D high water mark register.

12. A method of interpolating data associated with graphics primitives in a computer graphics pipeline, comprising the steps:

receiving color data, the color data comprising vertex coordinates, w coordinates, and texture coordinates;

computing barycentric coefficients for each of the graphics primitives;

storing a plurality of data cache entries corresponding to a plurality of the graphics primitives, the cached data comprising barycentric coefficients and texture coordinates;

receiving a graphics primitives fragment comprising fragment coordinates;

selecting and reading one of the stored data cache entries corresponding to the received graphics primitives fragment;

computing interpolation coefficients from the barycentric coefficients and the fragment coordinates; and

interpolating the texture coordinates using the computed interpolation coefficients.

13. A method of interpolating texture coordinates in a computer graphics pipeline, comprising the steps:

receiving a graphics primitive comprising vertex coordinates, w coordinates, and texture coordinates;

receiving a fragment of the graphics primitive, the fragment comprising a sample mask, the sample mask indicating sample locations within a pixel covered by the fragment;

determining interpolation coordinates within the pixel by inputting the sample mask into a programmable lookup table, the interpolation coordinates having sub-pixel accuracy;

computing interpolation coefficients using the interpolation coordinates, the vertex coordinates, and the w coordinates; and

interpolating the texture coordinates using the computed interpolation coefficients, generating texture coordinates at the interpolation coordinates.

14. A method of interpolating surface normals in a computer graphics pipeline, comprising the steps:

receiving a graphics primitive comprising vertex coordinates, w coordinates, and vertex surface normals;

receiving a fragment of the graphics primitive, the fragment being a part of the graphics primitive within a single pixel;

determining interpolation coordinates within the pixel;

computing interpolation coefficients using the interpolation coordinates, the vertex coordinates, and the w coordinates;

decomposing each of the vertex surface normals into a vertex magnitude vector and a vertex direction vector;

computing an interpolated magnitude vector from a plurality of the vertex magnitude vectors and the computed interpolation coefficients;

computing an interpolated direction vector from a plurality of the vertex direction vectors and the computed interpolation coefficients; and

combining the interpolated magnitude vector and the interpolated direction vector to generate an interpolated surface normal.

15. A status monitoring device for a computer graphics pipeline, the computer graphics pipeline forming a rendered image in a frame buffer by processing a plurality of three-dimensional objects, the three-dimensional objects each comprised of graphics primitives, the status monitoring device comprising:

logic associating object tags with the three-dimensional objects as the three-dimensional objects are processed by the computer graphics pipeline;

logic testing the three-dimensional objects with one or more visibility criteria as the three-dimensional objects are processed in the graphics rendering pipeline;

a status register comprising a plurality of bits;

logic selecting one of the bits in the status register according to one of the object tags;

logic setting the value of the selected bit in the status register according to response of the corresponding one of the three-dimensional objects to the testing with the visibility criteria; and

logic reading and transmitting the status register contents to a host CPU, the CPU determining which of the three-dimensional objects are at least partially visible.

16. The status monitoring device of claim 15, further comprising:

logic generating graphics primitives representing bounding volumes of the three-dimensional objects;

logic reading and transmitting the status register contents to a host CPU, the host CPU determining which of the bounding volumes are at least partially visible and discarding the objects from further processing that are not determined to be at least partially visible.

17. The status monitoring device of claim 15, further comprising:

a memory accumulating a plurality of the three-dimensional objects;

logic dividing primitives into stamp portions, removing portions of the graphics primitives from the computer graphics pipeline that are guaranteed to not affect the rendered image in the frame buffer, and identifying other portions of the primitives as visible stamp portions; and

logic simultaneously associating a plurality of the object tags on a one-to-one basis with a plurality of the three-dimensional objects as the three-dimensional objects are processed by the computer graphics pipeline, the status register then being used to determine the visibility of each of the accumulated objects.

18. A graphics rendering device for forming a rendered image from graphics primitives, the rendered image stored in a frame buffer, the graphics rendering device comprising:

(a) a geometry unit comprising;

(1) logic transforming the graphics primitives;

(2) logic clip testing the graphics primitives to determine if the graphics primitives are at least partially contained in the view volume;

(3) logic performing face determination to discard any of the graphics primitives that are facing away from the viewing point;

(b) a setup unit computing derivatives;

(c) a scene memory storing;

(1 ) the graphics primitives for a frame with attributes of the graphics primitives; and

(2) the various settings of pipeline state throughout the frame;

(d) a cull unit performing hidden surface removal to determine which portions of the graphics primitives stored in the scene memory affect the final color of pixels in the frame buffer;

(e) one or more computational units generating fragment color values for each sample or group of samples within each of the pixels, the generation of color values for each of the pixels being done only for the portions of the graphics primitives that are determined to affect the pixels;

(f) a pixel unit comprising;

(1) logic blending the fragment colors together to generate per-pixel color values; and

(2) logic storing the generated per-pixel color values into the frame buffer.

19. A graphics rendering device for forming a rendered image from graphics primitives, the rendered image stored in a frame buffer, the graphics rendering device comprising:

(a) a geometry unit comprising;

(1) logic transforming the graphics primitives;

(2) logic clip testing the graphics primitives to determine if the graphics primitives are at least partially contained in the view volume;

(3) logic performing face determination to discard any of the graphics primitives that are facing away from the viewing point;

(b) a setup unit computing derivatives, the derivatives comprising spatial derivatives and color derivatives;

(c) a spatial memory storing;

(1) the part of a pipeline state needed for hidden surface removal; and

(2) the part of the graphics primitives needed for hidden surface removal, comprising vertex locations and the spatial derivatives;

(d) a polygon memory storing;

(1) the part of a pipeline state not needed for hidden surface removal; and

(2) the part of the graphics primitives not needed for hidden surface removal, comprising vertex colors, texture coordinates, and the color derivatives;

(e) a cull unit performing hidden surface removal to determine which portions of the graphics primitives stored in the scene memory affect the final color of pixels in the frame buffer;

(f) one or more computational units generating fragment color values for each sample or group of samples within each of the pixels, the generation of color values for each of the pixels being done only for the portions of the graphics primitives that are determined to affect the pixels;

(g) a pixel unit comprising;

(1) logic blending the fragment colors together to generate per-pixel color values; and

(2) logic storing the generated per-pixel color values into the frame buffer.

20. A graphics rendering device for forming a rendered image from graphics primitives, the rendered image stored in a frame buffer, the graphics rendering device comprising:

(a) a geometry unit comprising;

(1) logic transforming the graphics primitives;

(2) logic clip testing the graphics primitives to determine if the graphics primitives are at least partially contained in the view volume;

(3) logic performing face determination to discard any of the graphics primitives that are facing away from the viewing point;

(b) a sort memory storing;

(1) the part of the pipeline state needed for hidden surface removal; and

(2) the part of the graphics primitives needed for hidden surface removal, comprising vertex locations;

(c) a state memory storing;

(1) the graphics primitives for a frame with attributes of the graphics primitives; and

(2) the part of the graphics primitives not needed for hidden surface removal, comprising vertex colors and texture coordinates;

(d) a sort unit comprising;

(1) logic sorting the graphics primitives according to tile areas within the image;

(2) logic reading the sorted graphics primitives from the sort memory according to tile;

(e) a setup unit computing derivatives for the sorted graphics primitives;

(f) a cull unit performing hidden surface removal to determine which portions of the graphics primitives stored in the scene memory affect the final color of pixels in the frame buffer;

(g) one or more computational units generating fragment color values for each sample or group of samples within each of the pixels, the generation of color values for each of the pixels being done only for the portions of the graphics primitives that are determined to affect the pixels;

(h) a pixel unit comprising;

(1) logic blending the fragment colors together to generate per-pixel color values; and

(2) logic storing the generated per-pixel color values into the frame buffer.

21. A scanout device for a computer graphics pipeline, the pipeline storing a rendered image of pixel values into a frame buffer, the computer graphics pipeline comprising a computer display, the scanout device comprising:

a memory storing programmatically downloaded interpolation coefficients;

a register storing a programmatically selected one of a plurality of zoom ratios;

a register storing a programmatically selected location of a zoom bounding box within the computer display;

a register storing a programmatically assigned a window identifier associated with the zoom bounding box;

logic reading a first pixel color from the frame buffer;

logic reading a plurality of second pixel colors from the frame buffer;

logic computing a zoomed pixel color from the plurality of second pixel colors and the downloaded interpolation coefficients;

logic reading a pixel window identifier from the frame buffer;

logic sending the computed zoomed pixel color to the digital-to-analog converter if the display pixel is within the zoom bounding box and the pixel window identifier equals the window identifier assigned to the zoom bounding box; and

logic sending the read first pixel color to the digital-to-analog converter if the display pixel is not within the zoom bounding box or the pixel window identifier does not equal the window identifier assigned to the zoom bounding box.

22. A device for storing a digital image into a frame buffer, the frame buffer comprising an array of pixels, the device comprising:

a first memory storing a window identifier map, the window identifier map comprising a window identifier for each of the pixels in the frame buffer;

a second memory storing a plurality of bounding box descriptions, each of the bounding box descriptions comprising maximum and minimum pixel coordinates of the corresponding bounding box and a bounding box window identifier;

a register storing a programmatically assigned image identifier associated with the digital image;

logic selecting an image pixel from the digital image;

pixel ownership logic operating on the selected image pixel, the pixel ownership logic comprising;

(1) window identifier map test logic enabled by a programmatically set control bit, the window identifier map test logic comprising;

(a) logic reading the window identifier from the first memory that corresponds to the selected image pixel;

(b) a comparator circuit comparing the assigned image identifier to the read window identifier; and

(c) logic discarding the selected image pixel if the assigned image identifier does not match the read window identifier; and

(2) bounding box test logic enabled by a programmatically set control bit, the bounding box test logic comprising;

(a) logic selecting a first one of the bounding box descriptions such that the selected pixel is within the maximum and minimum pixel coordinates of the selected first bounding box description;

(b) a comparator circuit comparing the assigned image identifier to the bounding box window identifier of the first bounding box description; and

(c) logic discarding the selected image pixel if the assigned image identifier does not match the bounding box window identifier of the first bounding box ; and

(3) logic writing the selected image pixel to the frame buffer if the selected image pixel was not discarded.

23. A computing system for 3D graphics rendering, the system comprising:

a host processor;

a system memory; and

a computer graphics pipeline coupled to host processor;

the computer graphics pipeline comprising;

(1) a 2D command queue memory receiving and storing first direct memory access commands and first commands to perform two-dimensional graphics operations;

(2) a 3D command queue memory receiving and storing second direct memory access commands and second commands to perform three-dimensional graphics operations;

(3) a 2D response queue memory receiving and storing third commands to perform two-dimensional graphics operations;

(4) a 3D response queue memory receiving and storing fourth commands to perform three-dimensional graphics operations; and

(5) a direct memory access controller coupled to the 2D command queue memory and the 3D command queue memory, the direct memory access controller comprising;

(a) first logic receiving the stored first direct memory access commands and performing the first direct memory access commands by reading the third commands from the system memory and writing the read third commands into the 2D response queue; and

(b) second logic receiving the stored second direct memory access commands and performing the second direct memory access commands by reading the fourth commands from the system memory and writing the read fourth commands into the 3D response queue.

24. A device for interpolating data associated with graphics primitives in a computer graphics pipeline, the device comprising:

a memory storing color data, the color data comprising vertex coordinates, w coordinates, and texture coordinates;

logic computing barycentric coefficients for each of the graphics primitives from the vertex coordinates and the w coordinates;

a cache memory storing a plurality of data cache entries corresponding to a plurality of the graphics primitives, the cached data comprising barycentric coefficients and texture coordinates;

logic selecting and reading one of the stored data cache entries corresponding to a received graphics primitive fragment, the graphics primitive fragment comprising fragment coordinates;

logic computing interpolation coefficients from the barycentric coefficients and the fragment coordinates; and

logic interpolating the texture coordinates using the computed interpolation coefficients.

25. A device for interpolating texture coordinates in a computer graphics pipeline, the device comprising:

a memory storing data associated with graphics primitives, the stored data comprising vertex coordinates, w coordinates, and texture coordinates;

a register receiving a fragment of the graphics primitive, the fragment comprising a sample mask, the sample mask indicating sample locations within a pixel covered by the fragment;

a lookup table determining lower bits of an interpolation location, the lookup table input comprising the sample mask, the interpolation location having sub-pixel accuracy;

logic computing interpolation coefficients using the interpolation location, the vertex coordinates, and the w coordinates; and

logic interpolating the texture coordinates using the computed interpolation coefficients, generating texture coordinates at the interpolation location.

26. A device for interpolating vertex surface normals in a computer graphics pipeline, the device comprising:

a memory storing a graphics primitive, the graphics primitive comprising vertex coordinates, w coordinates, and vertex surface normals;

a register storing a fragment of the graphics primitive, the fragment being a part of the graphics primitive within a single pixel;

logic determining interpolation coordinates within the pixel;

logic computing interpolation coefficients using the interpolation coordinates, the vertex coordinates, and the w coordinates;

logic decomposing each of the vertex surface normals into a vertex magnitude vector and a vertex direction vector;

logic computing an interpolated magnitude vector from a plurality of the vertex magnitude vectors and the computed interpolation coefficients;

logic computing an interpolated direction vector from a plurality of the vertex direction vectors and the computed interpolation coefficients; and

logic combining the interpolated magnitude vector and the interpolated direction vector to generate an interpolated surface normal.

27. A computing system for three-dimensional (3D) graphics rendering, generating an image stored in a frame buffer, the system comprising:

a host processor;

a system memory coupled to the host processor; and

a computer graphics pipeline coupled to host processor;

the computer graphics pipeline comprising;

logic associating object tags with three-dimensional objects as the three-dimensional objects are processed by the computer graphics pipeline;

logic testing the three-dimensional objects with one or more visibility criteria as the three-dimensional objects are processed in the graphics rendering pipeline;

a status register comprising a plurality of bits, the status register able to be read by the host processor;

logic selecting one of the bits in the status register according to one of the object tags; and

logic setting the value of the selected bit in the status register according to response of the corresponding one of the three-dimensional objects to the testing with the visibility criteria.

28. A computing system for three-dimensional (3D) graphics rendering, generating an image stored in a frame buffer, the system comprising:

a host processor;

a system memory coupled to the host processor;

a computer graphics pipeline coupled to host processor;

the computer graphics pipeline comprising;

logic associating object tags with three-dimensional objects as the three-dimensional objects are processed by the computer graphics pipeline;

logic testing the three-dimensional objects with one or more visibility criteria as the three-dimensional objects are processed in the graphics rendering pipeline;

a status register comprising a plurality of bits, the status register able to be read by the host processor;

logic selecting one of the bits in the status register according to one of the object tags; and

logic setting the value of the selected bit in the status register according to response of the corresponding one of the three-dimensional objects to the testing with the visibility criteria;

the host processor executing a program module that directs the rendering of the image, to function in a specified manner, the program module including instructions for;

receiving one of the three-dimensional objects represented by non-renderable graphics primitives, the non-renderable graphics primitives defining a bounding volumes of the one of the three-dimensional objects;

inputting the one of the three-dimensional objects into the computer graphics pipeline by inputting the non-renderable graphics primitives; and

reading the status register contents to determine if the object corresponding to the non-renderable graphics primitives is hidden.

29. The system of claim 31, wherein:

the computer graphics pipeline further comprising;

a memory accumulating a plurality of the three-dimensional objects, each represented by a corresponding set of the non-rendered primitives; and

logic performing hidden surface removal to cull out parts of the primitives that definitely do not contribute to the final rendered image, the hidden surface removal being done for an area of the image before color data is generated for the graphics primitives in the area of the image, thereby reducing the amount of the color data needed to be generated; and

the program module further including instructions for;

inputting a plurality of the three-dimensional objects before reading the status register;

reading the status register and inputting, to the computer graphics pipeline, renderable primitives corresponding to the three-dimensional objects whose non-renderable primitives are not hidden, thereby avoiding inputting the renderable primitives corresponding to the three-dimensional objects whose non-renderable primitives are hidden.