Graphics renderer and method for rendering 3D scene in computer graphics using object pointers and depth values

• US 9,922,450 B2
• Filed: 12/12/2016
• Issued: 03/20/2018
• Est. Priority Date: 07/24/2001
• Status: Active Grant

• Current Assignee: Imagination Technologies Limited (Imagination Technologies Group Ltd.)
• Original Assignee: Imagination Technologies Limited (Imagination Technologies Group Ltd.)
• Inventors: Morphet, Stephen
• Primary Examiner(s): HAJNIK, DANIEL F
• Application Number:
  US15/376,323
• Publication Number:
  US 20170091987A1
• Time in Patent Office: 463 Days
• CPC Class Codes: G06T 15/005 General purpose rendering architectures
• CPC Class Codes: G06T 15/40 Hidden part removal
• CPC Class Codes: G06T 15/405 using Z-buffer
• CPC Class Codes: G06T 2200/04 involving 3D image data
• CPC Class Codes: G06T 2200/28 involving image processing hardware

Abstract

An apparatus and a method for generating 3-dimensional computer graphic images. The image is first sub-divided into a plurality of rectangular areas. A display list memory is loaded with object data for each rectangular area. The image and shading data for each picture element of each rectangular area are derived from the object data in the image synthesis processor and a texturizing and shading processor. A depth range generator derives a depth range for each rectangular area from the object data as the imaging and shading data is derived. This is compared with the depth of each new object to be provided to the image synthesis processor and the object may be prevented from being provided to the image synthesis processor independence on the result of the comparison.

Claims

1. A graphics renderer for rendering a scene having an image plane divided into a set of one or more tiles, the renderer comprising:

a tiling unit configured to;

receive data for a plurality of objects,

calculate the tiles overlapped by each object,

derive a depth range for each object, and

write for each object an object pointer into per-tile lists stored in a memory only for tiles that are overlapped by the object, each object pointer containing information on the depth range of the object;

a fetch unit configured to;

read the object pointers for objects identified in the tile list for a tile being rendered,

perform a depth range test for each object identified for the tile being rendered to compare the depth range of the object with a received depth range for the tile, and

read, from a memory, parameter data only for objects that pass the depth range test;

a rendering processor configured to render each tile of the set of one or more tiles using the object pointers and parameter data fetched by the fetch unit for each tile to render the scene, wherein the rendering processor is configured to calculate per-pixel depth values for each object rendered as part of rendering a tile; and

a range generation unit configured to compute a depth range for a tile being rendered by the rendering processor that represents the range of depth values for objects that have been processed for that tile, and to feed back computed depth ranges to the fetch unit for the tile being rendered by the rendering processor for use in depth range tests for objects identified in the tile list for that tile.

2. A graphics renderer as claimed in claim 1, wherein the tiling unit is further configured to perform a depth range test for each object by comparing the depth range of the object with a depth range for each tile overlapped by that object, and to write for each object an object pointer into the per-tile lists stored in the memory only for tiles for which the object passes the depth range test at the tiling unit.

3. A graphics renderer as claimed in claim 2, wherein the range generation unit is further configured to feed back computed depth ranges to the tiling unit for use in the depth range test.

4. A graphics renderer as claimed in claim 3, wherein the rendering processor is configured to render the set of one or more tiles by performing multiple partial renders, and the range generation unit is configured to feed back to the tiling unit the depth range computed for a tile only at the completion of a partial render for that tile.

5. A graphics renderer as claimed in claim 1, wherein the range generation unit is configured to compute an updated depth range for a tile each time an object has been processed for that tile.

6. A graphics renderer as claimed in claim 5, wherein the range generation unit is configured to feed back a computed depth range to the fetch unit in response to the depth range being updated.

7. A graphics renderer as claimed in claim 1, wherein the fetch unit is configured to perform the depth range test in dependence on a depth compare mode specifying the conditions an object is to satisfy to pass the depth range test.

8. A graphics renderer as claimed in claim 7, wherein the renderer further comprises a counter configured to increment each time parameter data for an object is read, and the fetch unit is further configured to disable avoidance of reading parameter data for objects that fail the depth range test at the fetch unit when the counter has a value below a specified threshold.

9. A graphics renderer as claimed in claim 8, wherein the renderer is configured to render objects according to a graphics pipeline, and the specified threshold of the counter is equal to the maximum number of objects that can be held in the pipeline.

10. A graphics renderer as claimed in claim 8, wherein the counter is configured to reset in response to a change in the depth compare mode.

11. A graphics rendering method for a scene having an image plane divided into a set of one or more tiles, the method comprising:

receiving data for a plurality of objects at a tiling unit;

calculating the tiles overlapped by each object at the tiling unit;

deriving a depth range for each object at the tiling unit and writing for each object an object pointer into per-tile lists stored in a memory only for tiles that are overlapped by the object, each object pointer containing information on the depth range of the object;

reading at a fetch unit object pointers for objects identified in the tile list for a tile being rendered;

performing at the fetch unit a depth range test for each object identified for the tile being rendered to compare the depth range of the object with a received depth range for the tile and reading, from a memory, parameter data only for objects that pass the depth range test;

rendering each tile of the set of one or more tiles at a rendering processor using the object pointers and parameter data fetched by the fetch unit for each tile to render the scene, comprising calculating per-pixel depth values for each object rendered as part of rendering a tile; and

computing a depth range for a tile being rendered by the rendering processor that represents the range of depth values for objects that have been processed for that tile, and feeding back computed depth ranges to the fetch unit for the the being rendered by the rendering processor for use in depth range tests for objects identified in the tile list for that tile.

12. A method as claimed in claim 11, further comprising:

performing at the tiling unit a depth range test for each object by comparing the depth range of the object with a depth range for each tile overlapped by that object; and

writing for each object an object pointer into the per-tile lists stored in the memory only for tiles for which the object passes the depth range test at the tiling unit.

13. A method as claimed in claim 12, further comprising feeding back computed depth ranges to the tiling unit for use in the depth range test.

14. A method as claimed in claim 13, the set of one or more tiles are rendered by performing multiple partial renders, and the depth range computed for a tile is fed back to the tiling unit only at the completion of a partial render for that tile.

15. A method as claimed in claim 11, further comprising computing an updated depth range for a tile each time an object has been processed for that tile.

16. A method as claimed in claim 15, wherein a computed depth range is fed back to the fetch unit in response to the depth range being updated.

17. A method as claimed in claim 11, wherein the depth range test at the fetch unit is performed in dependence on a depth compare mode specifying the conditions an object is to satisfy to pass the depth range test.

18. A method as claimed in claim 17, wherein the method further comprises incrementing a counter each time parameter data for an object is read, and disabling avoidance of reading parameter data for objects that fail the depth range test at the fetch unit when the counter has a value below a specified threshold.

19. A method as claimed in claim 18, wherein the objects are rendered according to a graphics pipeline, and the specified threshold of the counter is equal to the maximum number of objects that can be held in the pipeline.

20. A method as claimed in claim 18, further comprising resetting the counter in response to a change in the depth compare mode.