Deferred shading graphics pipeline processor

• US 6,268,875 B1
• Filed: 08/04/2000
• Issued: 07/31/2001
• 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): Tung, Kee M.
• Application Number:
  US09/632,293
• Time in Patent Office: 361 Days
• Field of Search: 345/419-422, 345/425-432, 345/501-503, 345/506-509, 345/523, 345/524, 345/521, 345/522, 345/530-532, 345/536, 345/537, 345/545, 345/561, 345/562
• US Class Current: 345/506
• CPC Class Codes: G06T 1/60 Memory management
• CPC Class Codes: G06T 11/001 Texturing; Colouring; Generation of texture or colour inpainting G06T5/77
• 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/40 Hidden part removal
• CPC Class Codes: G06T 15/50 Lighting effects
• CPC Class Codes: G06T 15/80 Shading
• CPC Class Codes: G06T 15/83 Phong shading
• CPC Class Codes: G06T 15/87 Gouraud shading

Abstract

Three-dimensional computer graphics systems and methods and more particularly to structure and method for a three-dimensional graphics processor and having other enhanced graphics processing features. In one embodiment the graphics processor is a Deferred Shading Graphics Processor (DSGP) comprising an AGP interface, a command fetch & decode (2000), a geometry unit (3000), a mode extraction (4000) and polygon memory (5000), a sort unit (6000) and sort memory (7000), a setup unit (8000), a cull unit (9000), a mode injection (10000), a fragment unit (11000), a texture (12000) and texture memory (13000) a phong shading (14000), a pixel unit (15000), a backend unit (1600) coupled to a frame buffer (17000). Other embodiments need not include all of these functional units, and the structures and methods of these units are applicable to other computational processes and systems as well as deferred and non-deferred shading graphical processors.

Claims

1. A graphics pipeline generating a rendered image in a frame buffer, the image being generated from a plurality of graphics primitives, the graphics pipeline comprising:

(1) a sort block comprising;

logic sorting the graphics primitives into a plurality of tiles, each of the tiles being an area within the image, the tiles each being rendered separately;

logic selecting one of the tiles;

logic generating a first indicator designating a beginning of the rendering of the selected tile, the first indicator being sent to one or more rendering blocks in the pipeline;

logic generating a second indicator designating the beginning of the rendering of the selected tile, the second indicator bypassing the one or more rendering blocks in the pipeline; and

logic sending the graphics primitives that touch the selected tile down the pipeline after the first indicator is sent down the pipeline;

(2) the one or more rendering blocks comprising;

logic receiving the first indicator;

logic receiving the graphics primitives that touch the selected tile;

logic generating image color values for the received graphics primitives; and

logic outputting the first indicator and the generated image color values;

(3) a backend block comprising;

logic controlling the frame buffer;

logic receiving the second indicator; and

logic reading image data from the frame buffer corresponding to the selected tile as designated in the second indicator, generating a third indicator designating the image data has been read; and

(4) a pixel block comprising;

logic receiving the first indicator and the third indicator, thereby synchronizing, for the selected tile, the generated image color values and the read image data; and

logic receiving the generated image color values and combining the generated image color values and the read image data.

2. The graphics pipeline of claim 1, further comprising:

one or more memories storing the read image data, the read image data in the memories being overwritten with the combined generated image color values and the read image data.

3. The graphics pipeline of claim 1, the second indicator further designating whether any of color values, z values, and stencil values need to be read from the frame buffer for the selected tile.

4. The graphics pipeline of claim 1, the pixel block further comprising:

logic computing depth values corresponding to the generated image color values, the depth values being used for a depth test.

5. The graphics pipeline of claim 1, the pixel block further comprising:

logic performing fragment operations including a fragment operation selected from the group consisting of;

a scissor test, an alpha test, a stencil test, a depth test, blending, dithering, logicop, and combinations thereof.

6. The graphics pipeline of claim 1, the one or more rendering blocks further comprising:

a cull block determining the visible fragments within the received graphics primitives, the image color values being generated only for the determined visible fragments.

7. The graphics pipeline of claim 1, the one or more rendering blocks further comprising:

a lighting block performing per-fragment lighting.

8. The graphics pipeline of claim 7, the lighting further comprising:

logic computing Phong shading, the Phong shading contributing to the generation of image color values.

9. The graphics pipeline of claim 1, further comprising:

a two-dimensional graphics block performing two-dimensional graphics processing operations, the two-dimensional graphics processing operations being performed in parallel with the generation of image color values.

10. A graphics rendering method generating a rendered image in a frame buffer, the image being generated from a plurality of graphics primitives, the method comprising the steps:

sorting the graphics primitives into a plurality of tiles, each of the tiles being an area within the image, the tiles each being rendered separately;

selecting one of the tiles;

generating a first sequence of data comprising a first indicator followed by the graphics primitives that touch the selected tile, the first indicator designating a beginning of the rendering of the selected tile;

generating a second indicator requesting image data corresponding to the selected tile from the frame buffer;

reading the requested image data from the frame buffer and generating a third indicator when the reading is completed;

generating a second sequence of data comprising the first indicator followed by generating image color values for the selected tile, the generating image color values being generated from the graphics primitives that touch the selected tile;

combining, according to one or more programmatically specified fragment operations, the generated image color values and the read image data, the generated image color values for the selected tile and the read image data for the selected tile being synchronized by associating the first indicator and the third indicator.

11. The method of claim 10, the second indicator designating whether any of color values, z values, and stencil values need to be read from the frame buffer for the selected tile.

12. The method of claim 10, the combining step further comprising:

computing depth values corresponding to the generated image color values, the depth values being used for a depth test.

13. The method of claim 10, the combining step further comprising:

performing at least one fragment operation selected from the group consisting of;

a scissor test, an alpha test, a stencil test, a depth test, blending, dithering, logicop, and combinations thereof.

14. The method of claim 10, further comprising the step:

determining the visible fragments within the graphics primitives, the image color values being generated only for the determined visible fragments.

15. The method of claim 10, further comprising the step:

performing per-fragment lighting.

16. The method of claim 10, further comprising the step:

computing Phong shading, the Phong shading contributing to the generation of image color values.

17. A graphics pipeline generating a rendered image in a frame buffer, the image being generated from a plurality of graphics primitives, the graphics pipeline comprising:

(1) logic sorting the graphics primitives into a plurality of tiles, each of the tiles being an area within the image, the tiles each being rendered separately;

(2) shading logic generating image color values for the sorted graphics primitives in one of the separately rendered tiles;

(3) logic generating a prefetch indicator for the one of the separately rendered tiles, causing image data to be read from the frame buffer in parallel with the shading logic generating image color values; and

(4) pixel logic combining the generated image color values and the read image data.

18. The graphics pipeline of claim 17, further comprising:

one or more memories storing the read image data, the read image data in the memories being overwritten with the combined generated image color values and the read image data.

19. The graphics pipeline of claim 17, the prefetch indicator further designating whether any of color values, z values, and stencil values need to be read from the frame buffer for the one of the separately rendered tiles.

20. The graphics pipeline of claim 17, the pixel logic further comprising:

logic computing depth values corresponding to the generated image color values, the depth values being used for a depth test.

21. The graphics pipeline of claim 17, the pixel logic further comprising:

logic performing at least one fragment operation selected from the group consisting of;

a scissor test, an alpha test, a stencil test, a depth test, blending, dithering, logicop, and combinations thereof.

22. The graphics pipeline of claim 17, further comprising:

logic determining the visible fragments within the received graphics primitives, the image color values being generated only for the determined visible fragments.

23. The graphics pipeline of claim 17, further comprising:

logic performing per-fragment lighting.

24. The graphics pipeline of claim 17, further comprising:

logic performing two-dimensional graphics processing operations, the two-dimensional graphics processing operations being performed in parallel with the generation of image color values.

25. A graphics rendering method generating a rendered image in a frame buffer, the image being generated from a plurality of graphics primitives, the method comprising the steps:

(1) sorting the graphics primitives into a plurality of tiles, each of the tiles being an area within the image, the tiles each being rendered separately;

(2) generating image color values for the sorted graphics primitives in one of the separately rendered tiles;

(3) generating a prefetch indicator for the one of the separately rendered tiles, causing image data to be read from the frame buffer in parallel with the step of generating image color values; and

(4) combining the generated image color values and the read image data.

26. The method of claim 25, the prefetch indicator designating whether any of color values, z values, and stencil values need to be read from the frame buffer for the one of the separately rendered tiles.

27. The method of claim 25, the combining step further comprising:

computing depth values corresponding to the generated image color values, the depth values being used for a depth test.

28. The method of claim 25, the combining step further comprising:

performing at least one fragment operation selected from the group consisting of;

a scissor test, an alpha test, a stencil test, a depth test, blending, dithering, logicop, and combinations thereof.

29. The method of claim 25, further comprising the step:

determining the visible fragments within the graphics primitives, the image color values being generated only for the determined visible fragments.

30. The method of claim 25, further comprising the step:

performing per-fragment lighting.

31. A graphics rendering method generating a rendered image in a frame buffer, the image being generated from a plurality of graphics primitives, the frame buffer storing data comprising color values, z values, and stencil values, the method comprising the steps:

(1) dividing the area of the image into a plurality of tiles, the tiles each being rendered separately;

(2) detecting a condition of an application program specifying one or more buffer clear operations during an early stage of the generation of the rendered image, such that the rendered image can not be affected by the previous one or more of color values, z values, and color values stored in the frame buffer;

(3) conditionally reading, for a selected tile, color values, z values, and stencil values from the frame buffer into a tile buffer, some of the reading being avoided if the condition is detected; and

(4) rendering the image for the selected tile.