Input Geometry Object Visibility Recording for Graphics Rendering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current graphics processing techniques, such as early depth culling and deferred rendering, still face challenges in reducing pixel computation burden and unnecessary geometry processing, especially in low-power devices, where performance is limited by pixel computation throughput and memory bandwidth.
Innovation Solution
Implementing a tile-based deferred rendering approach that performs depth tests and records visibility results on a per-input geometry object basis, allowing for compressed visibility information to be stored in memory buffers and used to skip over non-visible objects during subsequent rendering passes, thereby reducing redundant geometry processing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If traditional per-pixel depth testing and rendering is performed, then visibility determination is accurate, but pixel computation burden and memory bandwidth usage increase significantly
Solution Approach 1:
The patent segments the scene into discrete geometry objects and performs depth testing at the object level rather than per-pixel. Each geometry object receives a visibility tag (visible, culled, or occluded) based on depth testing against already-rendered objects, eliminating the need for per-pixel computation while maintaining visibility accuracy.
Solution Approach 2:
The patent performs depth testing and visibility determination for geometry objects before actual pixel rendering. By tagging objects with visibility information in advance, the system prevents unnecessary pixel computation for occluded or culled objects, significantly reducing pixel computation burden while preserving accurate visibility determination.
2Measurement precision
If comprehensive depth testing is performed for all pixels, then visibility accuracy is maintained, but memory bandwidth consumption increases
Solution Approach 1:
The patent segments the rendering process into geometry object-level operations rather than pixel-level operations. Depth testing is performed once per geometry object against the existing depth buffer, and the result is cached as a visibility tag. This eliminates redundant memory accesses to the depth buffer that would occur with per-pixel testing, significantly reducing memory bandwidth consumption while maintaining visibility accuracy.
Solution Approach 2:
The patent creates a simplified representation of visibility information by tagging geometry objects with visibility status (visible, culled, occluded) instead of maintaining per-pixel depth information. This copied visibility metadata allows the system to determine which objects need rendering without accessing the full depth buffer, reducing memory bandwidth consumption while preserving visibility accuracy.
3Reliability
If all geometry objects are processed through the rendering pipeline, then complete scene coverage is achieved, but unnecessary geometry processing increases computation burden
Solution Approach 1:
The patent performs preliminary depth testing and visibility tagging on geometry objects before they enter the full rendering pipeline. Objects are tagged as culled (definitely invisible), occluded (partially visible), or visible based on depth testing against already-rendered objects. This preliminary classification allows the rendering pipeline to skip or optimize processing for inappropriate objects, reducing geometry processing complexity while maintaining complete and accurate scene coverage.
Solution Approach 2:
The patent dynamically adjusts the rendering pipeline behavior based on visibility tags assigned to geometry objects. The system adapts by applying different processing levels: culled objects are completely skipped, occluded objects receive partial processing, and visible objects undergo full rendering. This dynamic approach reduces overall geometry processing complexity while ensuring complete and accurate scene coverage.
Data Source
AI summary
According to some embodiments of the present invention, pixel throughput may be improved by performing depth tests and recording the results on the granularity of an input geometry object. An input geometry object is any object within the depiction represented by a primitive, such as a triangle within an input triangle list or a patch within an input patch list.