Patent Description:
A computer graphics system may render an image based on multiple objects from a perspective of a camera. As in the real world, when virtual objects are viewed from a particular perspective, other objects may block (or occlude) the view of all or a portion of the object. Generally, a closer object will occlude a more distant object. In a computer graphics system, overdraw occurs when a closer object is drawn using pixels that already include another object. The existing pixels are replaced with pixels for the closer object. Generally, overdrawing is considered wasteful because the properties of each overdrawn pixel are determined multiple times, using additional processing resources.

One solution to reduce or eliminate overdraw is the use of a depth pre-pass, which is available on modern graphics processing units (GPU). In this scheme each object is rendered twice. In the first iteration, only the per-pixel nearest depth is recorded to the depth buffer. In the second iteration, only the nearest object will pass the depth buffer test and write pixel data. This avoids overdraw, but at the expense of processing every object twice. This expense can sometimes outweigh the benefit of eliminating overdraw resulting in a net loss.

Another solution to reducing overdraw is to perform a low resolution occlusion render, typically using the central processing unit (CPU). Low resolution occlusion geometry is rendered to an occlusion buffer, for example, a box for a building or rectangles for a wall or fence. This occlusion render is used to test a single bounding volume for each object, typically a box. If the entire bounding box is occluded, the software may prevent rendering of the object. Often, however, objects may be only partially occluded, so software occlusion render may still render the entire object, resulting in rendering many pixels that are occluded and which are later overdrawn.

Thus, there is a need in the art for improvements in graphics processing for determining whether to render pixels.

<CIT> discloses a method and apparatus for calculating position attributes and culling triangles before calculating shading attributes other than position attributes. In order to be able to do occlusion culling, a graphics processor has an occlusion representation. One type of representation is to store a maximum depth and a minimum depth scaler value per tile. The maximum depth is greater or equal to the largest depth in the tile, and the minimum depth is less than or equal to the smallest depth in the tile. If a triangle resides completely inside a single tile and if the triangle's depths are larger than the tile's maximum depth, than that triangle is occluded by already rendered geometry, and therefore, the triangle can safely be culled. A Cull Pipe contains coarser rasterizer that identifies all tiles overlapped by a triangle.

It is therefore the object of the present invention to provide an improved computing device for rendering an image at a full resolution, as well as a corresponding method and corresponding computer readable medium.

The following presents a simplified summary of one or more implementations of the present disclosure in order to provide a basic understanding of such implementations. This summary is not an extensive overview of all contemplated implementations, and is intended to neither identify key or critical elements of all implementations nor delineate the scope of any or all implementations. Its sole purpose is to present some concepts of one or more implementations of the present disclosure in a simplified form as a prelude to the more detailed description that is presented later.

Claim <NUM> discloses a method of rendering an image at full resolution, which includes rendering an occlusion geometry at a reduced resolution lower than said the full resolution.

A computing device for rendering an image at a full resolution is disclosed in claim <NUM>.

A computer-readable medium, comprising code executable by one or more processors for rendering an image at a full resolution is disclosed in claim <NUM>.

Additional advantages and novel features relating to implementations of the present disclosure will be set forth in part in the description that follows, and in part will become more apparent to those skilled in the art upon examination of the following or upon learning by practice thereof.

The present disclosure provides systems and methods for drawing images on a display with relatively low latency (as compared to current solutions). In graphics intensive computer applications (e.g., video games), the user experience is usually improved by increasing the speed at which an image can be rendered by a particular system. For example, faster rendering may enable higher frame-rates, which the user perceives as smoother movement. As another example, faster rendering may enable use of a higher resolution, more effects, or more content while keeping the frame-rate constant.

In an implementation, for example, this disclosure provides systems and methods for performing a low resolution rendering of an image to determine a depth of visible pixels to be used for occlusion culling. The low resolution rendering may use far fewer resources than performing a full resolution rendering of the image. For example, a low resolution rendering at one eighth of the full resolution may use one sixty-fourth of the pixels. In an implementation, the low resolution pixels may correspond to tiles of the full-resolution image, so culling may occur at the tile level of granularity. Accordingly, by using the low resolution rendering to cull groups of pixels corresponding to occluded portions of objects from a full resolution rendering, the disclosed techniques may reduce resource usage (e.g., time and processing resources) for rendering the image.

One issue with using a reduced resolution rendering for occlusion culling is the possibility of undersampling. Because each pixel in the reduced resolution rendering may represent multiple pixels in the full resolution rendering, it is possible that a reduced resolution rendering may not capture some details of the objects. Of particular concern is the possibility that further or deeper features are not captured by sampling the reduced resolution depth rendering. For example, sampling concave surfaces at a low resolution may not capture the deepest point of the concave surface. If groups of features corresponding to the deeper features are improperly culled from the full resolution rendering due to the undersampling, the final image may include missing pixels, which may be noticeable to the user. Accordingly, the disclosure provides several techniques for biasing samples from the reduced resolution depth rendering to prevent improper culling.

Referring now to <FIG>, an example computer system <NUM> includes a computer device <NUM>. The computer device <NUM> may be, for example, any mobile or fixed computer device including but not limited to a desktop or laptop or tablet computer, a cellular telephone, a gaming device, a mixed reality or virtual reality device, a music device, a television, a navigation system, a camera, a personal digital assistant (PDA), a handheld device, any other computer device having wired and/or wireless connection capability with one or more other devices, or any other type of computerized device. The computer device <NUM> may include a display <NUM> for displaying a rendered image. The display <NUM> may be periodically updated at a refresh rate (e.g., <NUM> - <NUM>). The computer device <NUM> may provide images for display on the display <NUM> using a graphics processing unit (GPU) <NUM> including a graphics queue <NUM> for receiving commands to render objects in an image, an occlusion culling component <NUM> for culling groups of pixels based on a hierarchical depth buffer <NUM>, and a render pipeline <NUM> for drawing remaining groups of pixels that are not culled.

The computer device <NUM> may also include a CPU <NUM> that executes instructions stored in memory <NUM>. For example, the CPU <NUM> may execute an operating system <NUM> and one or more applications <NUM>. The operating system <NUM> may include a display controller <NUM> to control the GPU <NUM>. For example, the display controller <NUM> may send rendering commands to the GPU <NUM>. In some cases, the display controller <NUM> may execute on the CPU <NUM> to generate a reduced resolution occlusion geometry <NUM>.

Computer device <NUM> may include a memory <NUM> and CPU <NUM> configured to control the operation of computer device <NUM>. Memory <NUM> may be configured for storing data and/or computer-executable instructions defining and/or associated with an operating system <NUM> and/or application <NUM>, and CPU <NUM> may execute operating system <NUM> and/or applications <NUM>. An example of memory <NUM> can include, but is not limited to, a type of memory usable by a computer, such as random access memory (RAM), read only memory (ROM), tapes, magnetic discs, optical discs, volatile memory, non-volatile memory, and any combination thereof. Memory <NUM> may store local versions of applications being executed by CPU <NUM>.

The CPU <NUM> may include one or more processors for executing instructions. An example of CPU <NUM> can include, but is not limited to, any processor specially programmed as described herein, including a controller, microcontroller, application specific integrated circuit (ASIC), field programmable gate array (FPGA), system on chip (SoC), or other programmable logic or state machine. The CPU <NUM> may include other processing components such as an arithmetic logic unit (ALU), registers, and a control unit.

The operating system <NUM> may include instructions (such as application <NUM>) stored in memory <NUM> and executable by the CPU <NUM>. The operating system <NUM> may include a display controller <NUM> for controlling the GPU <NUM>. For example, the display controller <NUM> may receive objects <NUM> from applications <NUM> and provide commands <NUM> to the GPU <NUM> to perform one or more specific graphics processing operations such as rendering source images or performing adjustments.

The GPU <NUM> may include one or more processors and specialized hardware for image processing. In an implementation, the GPU <NUM> may be integrated with a CPU <NUM> on a motherboard of the computer device or may be a discrete chip. The GPU <NUM> may include a dedicated memory <NUM>. The GPU <NUM> may be connected to the display <NUM> via a display interface <NUM>. The GPU <NUM> may periodically scan out an image from an image buffer <NUM> to the display <NUM> via the display interface <NUM> according to a refresh rate of the display <NUM>. The GPU <NUM> may include a graphics queue <NUM>, a render pipeline <NUM>, a hierarchical depth buffer <NUM>, and an occlusion culling component <NUM>. The graphics queue <NUM> may receive commands from the display controller <NUM> for rendering an image. The graphics queue <NUM> may generally provide the commands to the render pipeline <NUM>. The render pipeline <NUM> may perform multiple stages of image processing. For example, the render pipeline <NUM> may include an input-assembler stage, vertex shader stage, hull shader stage, tessellator stage, domain shader stage, geometry shader stage, stream output stage, rasterizer stage, pixel-shader stage, and output merger stage.

The GPU <NUM> may include GPU depth data <NUM> for storing depth data related to a full resolution rendering. For example, the GPU depth data <NUM> may include a hierarchical depth buffer <NUM>, which may also be referred to as a hierarchical z buffer or HZB. The hierarchical depth buffer <NUM> may also include metadata <NUM>, which may include additional information for groups of pixels. For example, the hierarchical depth buffer <NUM> and metadata <NUM> may include information for <NUM> x <NUM> groups of pixels referred to as tiles. The hierarchical depth buffer <NUM> contains the minimum and/or maximum depth values for the set of pixels contained in that tile. These minimum and maximum depth values may be conservatively quantized, for example using <NUM>-bits or <NUM>-bits, whereas full resolution depth data <NUM> may be stored using more bits, for example <NUM>-bits. Accordingly, the hierarchical depth buffer <NUM> may have less precision than the actual GPU <NUM> calculations. The metadata <NUM> may also include a clear state bit and other data used to accelerate depth testing or clear operations. The hierarchical depth buffer <NUM> minimum and maximum depth values may be packed in with other values of metadata <NUM> to form complete machine words, for example <NUM> bits of data, or they may be stored separately.

The occlusion culling component <NUM> may be a hardware accelerator for culling pixels or tiles based on the hierarchical depth buffer <NUM>. In a first pass, the occlusion culling component <NUM> may receive a tile and determine whether the tile is occluded based on the hierarchical depth buffer <NUM>, for example, by comparing a depth range of the tile being rendered to the minimum and maximum depth values. In a second pass, if the tile passes occlusion culling, the occlusion culling component <NUM> may determine whether individual pixels are occluded based on the hierarchical depth buffer <NUM> and finally if necessary, testing individual pixels against the full resolution depth buffer. The implementation of the occlusion culling component <NUM> may vary based on the GPU <NUM> and may be transparent to an application <NUM> once the hierarchical depth buffer <NUM> and/or metadata <NUM> are populated.

In an example, display interface <NUM> can be communicatively coupled with the GPU <NUM> and/or memory <NUM> for communicating with the display <NUM>. A display interface, as referred to herein, may also include various types of ports, including high definition multimedia interface (HDMI) ports, display serial interface (DSI) ports, mobile industry processor interface (MIPI) DSI ports, universal serial bus (USB) ports, Firewire ports, or other embedded or external wired or wireless display ports that can allow communications between computer device <NUM> and display <NUM>.

The applications <NUM> may include graphical components that involve rendering an image to the display <NUM>. For example, the applications <NUM> may include video games that render a series of images to the display <NUM> at a frame-rate. Generally, application developers may seek to improve the user experience by maximizing frame-rate, resolution, color depth, or other image properties, or letting the user select such properties. One or more applications <NUM> may include a depth pre-pass component <NUM> for culling occluded groups of pixels from an image using a reduced resolution rendering prior to rendering the image at a full resolution. The depth pre-pass component <NUM> may include a depth renderer <NUM> for rendering an occlusion geometry <NUM> at a reduced resolution lower than the full resolution and a sampler <NUM> for pre-populating the GPU depth data <NUM> (e.g., the hierarchical depth buffer <NUM>, metadata <NUM>, or depth data <NUM>) based on sampled depth values <NUM> of the occlusion geometry <NUM>.

The depth renderer <NUM> may include instructions to perform a depth-only rendering of a scene to generate an occlusion geometry <NUM>. The occlusion geometry <NUM> may have a lower resolution than the final full resolution image. For example, the lower resolution may be one-fourth, one-eighth, or less of the full resolution. The depth renderer <NUM> may instruct either the CPU <NUM> or the GPU <NUM> to perform the depth-only rendering. Since the depth-only rendering is performed at a lower resolution and may omit some processing intensive pixel level operations, both the CPU <NUM> and the GPU <NUM> may be able to quickly perform the depth-only rendering. An application designer may select whether the CPU <NUM> or the GPU <NUM> performs the depth-only rendering based on the particular needs of the application <NUM> and other work being performed on each of the CPU <NUM> or the GPU <NUM>. The occlusion geometry <NUM> generated by the depth-only rendering may include a depth value for each pixel of screen space in the depth-only rendering. The depth value <NUM> may be the depth of the closest object/surface rendered. A greater depth value <NUM> may indicate that the object is further away from the camera or screen, or if the Reverse-Z algorithm is being employed by the application, a smaller depth value <NUM> may indicate that the object is further away from the camera.

The depth renderer <NUM> may omit some scene objects from the depth-only rendering. In particular, objects that are poor occluders may be omitted from the depth-only rendering. For example, small objects, transparent objects, and objects including holes may not fully occlude an object behind the poor occluder. Poor occluders may also have a greater occlusion effect than is desired, due to low resolution and undersampling, resulting in an incorrect image. That is, pixels behind the poor occluder may be culled based on depth, resulting in missing pixels being visible adjacent or through the poor occluder. Poor occluders may be identified by the number of covered pixels, by their projected screen space area, by being manually excluded from the occlusion render or by other means. Accordingly, the depth renderer <NUM> may omit poor occluders from the depth-only rendering, but such poor occluders may be included in a full resolution rendering process.

The sampler <NUM> may sample depth values <NUM> of the occlusion geometry <NUM> for pre-populating the hierarchical depth buffer <NUM>, metadata <NUM>, or full resolution depth data <NUM> of the GPU depth data <NUM>. In an implementation, the sampler <NUM> may be biased to generate a conservative depth sample value. That is, the sampler <NUM> may generate a further depth value to prevent improper culling of pixels that may be close to the occlusion geometry <NUM>. For example, the sampler <NUM> may use techniques such as a global bias, rounding bias and per sample bias to conservatively bias the depth samples while remaining close to the actual depth value of the occlusion geometry <NUM> in order to gain the benefits of culling. Per sample bias may include taking the furthest depth of neighbouring pixels and their phantom points. These sampling techniques are described in further detail below with respect to <FIG>.

Referring now to <FIG>, an example image <NUM> represents an example object <NUM> that may be rendered via a GPU <NUM>. The object <NUM> may have a geometry that may be subject to overdraw and may consume significant graphical processing resources. For example, the illustrated object <NUM> may be a fractal object composed of multiple cubes having semi-spherical indentations in the surfaces. The spherical indentations may be a texture based effect that is not present in the underlying object. As illustrated, surfaces of the cubes overlap the surfaces of other cubes often resulting in the visible portion of each cube being a rectangular prism. Accordingly, if every surface is rendered, the GPU <NUM> may perform significant overdrawing of previously rendered pixels. Additionally, a full resolution depth pre-pass would still include rendering every cube. A bounding volume software occlusion culling may not be particularly useful since each cube blocks only a portion of other cubes, therefore, the software occlusion culling may cull few cubes from the rendering process, and a great deal of overdraw may remain.

<FIG> illustrates an example reduced resolution occlusion geometry <NUM> of the object <NUM> (i.e., and example of occlusion geometry <NUM>) that may be generated by a depth renderer <NUM> of depth pre-pass component <NUM>. The reduced resolution occlusion geometry <NUM> includes only depth values of the object <NUM>. Pixels that are closer to the camera (less deep) are shown in darker shades, while pixels that are further away from the camera (deeper) are shown in lighter shades.

<FIG> illustrates an example image <NUM> of a portion of the object <NUM>. The image <NUM> may include missing pixels <NUM>, <NUM> due to undersampling. The missing pixels <NUM> may be at locations where groups of pixels were culled based on the reduced resolution occlusion geometry <NUM>. Accordingly, when the full resolution rendering process compares the actual farthest point of each tile to the sampled value of the reduced resolution occlusion geometry <NUM>, the sampled point appears to occlude the tile and so the tile is incorrectly culled. Other missing pixels <NUM> may be due to an edge of a surface not actually occluding a further surface that is adjacent the edge in the 2D image. That is, due to undersampling, the sample value of the closer surface is applied to the adjacent pixel in the high resolution rendering, which appears to be occluded, even though the high resolution rendering does not include a pixel for the closer surface for the adjacent pixel.

<FIG> is a conceptual diagram <NUM> showing a cross-sectional view of an object <NUM> being sampled into a low-resolution screen space. The low-resolution screen space may be represented by pixels <NUM>, <NUM>, <NUM>. A full-resolution screen space may be presented by pixels <NUM>. The object <NUM> may have a slope such that the depth of the object <NUM> varies when sampled at different locations corresponding to the pixels <NUM>, <NUM>, <NUM>, to obtain depth values <NUM>, <NUM>, <NUM>. When the depth values <NUM>, <NUM>, <NUM> are used by the occlusion culling component <NUM> of the GPU <NUM> to cull pixels <NUM> in the full-resolution screen space, the depth value <NUM> may represent pixels <NUM> that actually correspond to a different depth. For purposes of culling, a portion of the object <NUM> that is closer than the depth value <NUM> will not be culled, but a pixel <NUM> corresponding to a portion of the object <NUM> that is further than the depth value <NUM> may be culled because the occlusion culling component <NUM> may determine that the portion of the object is occluded by the pixel corresponding to depth value <NUM>, even though the depth value <NUM> and the pixel <NUM> may represent the same surface of the object <NUM>. This improper culling may result in the missing pixels <NUM>, <NUM>.

<FIG> is a conceptual diagram <NUM> showing an example per sample biasing technique for sampling the object <NUM> into the low-resolution screen space. The per sample biasing technique may assign a farthest sampled depth value of the corresponding pixel <NUM> and up to eight adjacent pixels to the depth value <NUM>. In this cross-sectional view only two adjacent pixels are illustrated. For example, the depth value <NUM> may be set to the greatest depth value of samples at pixels <NUM>, <NUM>, and <NUM>, which is the depth value <NUM> at the pixel <NUM> in this example. Accordingly, by assigning the depth value at the pixel <NUM> to the depth value <NUM>, the stored value may be further than the surface of object <NUM> for each pixel <NUM>, <NUM>, and <NUM>. Therefore, none of the illustrated full-resolution pixels <NUM> would be culled when using per sample biasing.

<FIG> is a conceptual diagram <NUM> showing a cross-sectional view of an object <NUM> being sampled into a low-resolution screen space. The low-resolution screen space may be represented by pixels <NUM>, <NUM>, and <NUM>. A full-resolution screen space may be presented by pixels <NUM>. The object <NUM> may have a convex surface defined by surface <NUM> and surface <NUM>. Accordingly, when the depth values <NUM>, <NUM>, <NUM> corresponding to pixels <NUM>, <NUM>, <NUM>, respectively, are sampled, there is a chance that the surface of object <NUM> is further than any depth value <NUM>, <NUM>, <NUM> for some full-resolution pixels <NUM>. Therefore, the per sample biasing technique of taking the furthest depth of the set of neighboring depths may not prevent some full-resolution pixels <NUM> from being improperly culled.

<FIG> is a conceptual diagram showing an example per sample biasing technique using phantom points. A phantom point may be a point corresponding to a surface that extends beyond an edge of the surface. For example, the phantom point <NUM> may correspond to the surface <NUM>. The sampler <NUM> may determine phantom points for each pixel <NUM>, <NUM> adjacent a pixel <NUM> being sampled based on a depth of the pixel <NUM> being sampled and a pixel <NUM> opposite the phantom point <NUM> using a simplified slope calculation. That is, since the two adjacent pixels <NUM>, <NUM> are equidistant from the pixel <NUM> being sampled, the depth of the phantom point <NUM> may be the depth of the depth value <NUM> minus the difference between the depth value <NUM> and the depth value <NUM> at the opposite pixel <NUM>. That is, as illustrated in <FIG>, the depth value for the phantom point for pixel A (PA) = B - (C - B).

<FIG> is a conceptual diagram showing biasing using phantom points applied to the object <NUM>. As in <FIG>, the phantom point <NUM> may correspond to the surface <NUM>. The depth value <NUM> of the pixel <NUM> may be set to the farthest of the depth of the pixel <NUM>, the depth of the eight neighbor pixels (e.g., pixels <NUM> and <NUM>), and the depth of any phantom points (e.g., phantom point <NUM>). Accordingly, in this example, the sample depth value <NUM> may be set to the depth of phantom point <NUM>. In an implementation, only phantom points corresponding to a surface sampled for the pixel being sampled may be determined for the pixel being sampled. For example, the sampler <NUM> may not determine a phantom point corresponding to the surface <NUM> for the pixel <NUM> because the pixel <NUM> does not correspond to the surface <NUM>. The sampler <NUM> may, however, determine a phantom point for the surface <NUM> when determining the sample depth value <NUM>. The depth of the object <NUM> for each of the full-resolution pixels <NUM> may be closer than the depth value <NUM> based on phantom point <NUM>, so each of the pixels <NUM> would be drawn based on the object <NUM>.

Additional biasing techniques that may be used include a global bias that applies an offset to each depth sample. While a global bias reduces improper culling, a global bias may also reduce desirable culling and associated processing savings. Another example biasing technique is biased rounding. The hierarchical depth buffer <NUM> and metadata <NUM> may have a limited precision. Accordingly, when sampling a depth value, the sampler <NUM> may need to round to a discrete value to be stored in the hierarchical depth buffer <NUM>. Therefore, the sampler <NUM> may always round to a further depth value when sampling the reduced resolution occlusion geometry <NUM>.

<FIG> is a diagram <NUM> showing overdraw when rendering the object <NUM> without pre-populating the hierarchical depth buffer <NUM>. The darker shades indicate that the pixels were overdrawn more times. As illustrated, the surfaces of the smaller rectangular prisms are overdrawn multiple times.

In contrast, <FIG> is a diagram <NUM> showing overdraw when rendering the object <NUM> after pre-populating the hierarchical depth buffer <NUM> using a low-resolution depth pre-pass. In this example, the depth renderer <NUM> only rendered four of the six iterations of the cubes in the fractal object <NUM>. As illustrated, the overdraw occurs mostly for the surfaces of the cubes that were not rendered in the depth pre-pass. There is also some overdraw along the edges of the rectangular prisms where the biasing conservatively samples neighbor pixels corresponding to the further object along an edge of the closer object. Accordingly, some of the occluded pixels along the edge are drawn multiple times. Overall, however, the overdraw is greatly reduced using the low-resolution depth pre-pass.

Referring now to <FIG>, an example method <NUM> provides for the computer device <NUM> to render a full-resolution image using a low-resolution depth pre-pass. For example, method <NUM> may be performed by an application <NUM> executing on a CPU <NUM> and performing graphics processing using a GPU <NUM>.

In block <NUM>, the method <NUM> may include rendering an occlusion geometry at a reduced resolution lower than the full resolution. For instance, the application <NUM> may execute the depth renderer <NUM> to render the occlusion geometry <NUM> (e.g., reduced resolution occlusion geometry <NUM>) at a reduced resolution lower than the full resolution. The depth renderer <NUM> may render the occlusion geometry <NUM> either on the CPU <NUM> or the GPU <NUM>. The reduced resolution may be a fraction of the full resolution. In one implementation, the reduced resolution may be one-eighth of the full resolution. For example a <NUM> frame (<NUM> x <NUM> pixels) may use a reduced resolution of 270p (<NUM> * <NUM>). In this case, one pixel of the occlusion geometry <NUM> may correspond to one tile of the full resolution. Other resolutions may also be selected, based on, for example, the available processing resources of the CPU <NUM> or the GPU <NUM>.

At block <NUM>, the block <NUM> may include rendering only objects having a size greater than a threshold size. For instance, the depth renderer <NUM> may choose to render only objects having a size greater than a threshold size. For example <NUM>% of screen area. In another example, the threshold size may be at least two pixels per triangle at the reduced resolution, which may result in at least two samples of the object such that a slope of the object may be determined.

At block <NUM>, the method <NUM> may include sampling depth values of pixels of the occlusion geometry. For instance, the sampler <NUM> may sample the depth values of pixels of the occlusion geometry <NUM>. In an implementation, the sampling count may correspond to a structure of the hierarchical depth buffer <NUM>. For example, if the hierarchical depth buffer <NUM> includes metadata <NUM> for 8x8 tiles, one sample per tile may be used. Accordingly, when the reduced resolution is one-eighth, each pixel may correspond to a tile sample. However, other groupings of hierarchical depth buffer <NUM> or different resolution ratios may be used and sampled appropriately.

At block <NUM>, the method <NUM> may include pre-populating GPU depth data based on the sampled depth values. For instance, in an implementation, an application <NUM> may execute the depth pre-pass component <NUM> to pre-populate the GPU depth data <NUM>. The pre-populated GPU depth data <NUM> may include the hierarchical depth buffer <NUM> which may be combined with other depth metadata <NUM>. For example, at block <NUM>, the block <NUM> may include setting corresponding values of a hierarchical depth buffer of the GPU depth data to the sampled depth values. For instance, the depth pre-pass component <NUM> may set the minimum and maximum depth values for a tile in the hierarchical depth buffer <NUM> to the sampled depth value. In another implementation without a hierarchical depth buffer <NUM> or with no direct access to the hierarchical depth buffer <NUM>, the sampler <NUM> may sample the occlusion geometry <NUM> and the depth pre-pass component <NUM> may directly populate the full resolution depth data <NUM>. For example, at <NUM>, the block <NUM> may include copying the sampled depth value to each of a group of corresponding pixels in a full resolution depth data of the GPU depth data. For instance, the depth pre-pass component <NUM> may copy the sampled depth value to each of a group of corresponding pixels in the full resolution depth data <NUM> of the GPU depth data <NUM>. In the case where the reduced resolution is one-eighth of the full resolution, the depth pre-pass component <NUM> may copy the sampled value of a low resolution pixel to each pixel of an 8x8 group of corresponding full resolution pixels.

In block <NUM>, the block <NUM> may include biasing the sampled depth values toward a depth value further from the camera. For instance, the depth pre-pass component <NUM> or sampler <NUM> may bias the sampled depth values toward a further depth. For a first example biasing technique, at block <NUM>, biasing the sampled depth values may include setting a depth value of the hierarchical depth buffer <NUM> for a pixel to the furthest depth value of the pixel and each pixel adjacent to the pixel. For instance, the depth pre-pass component <NUM> or sampler <NUM> may set a depth value (e.g., depth value <NUM>) of the hierarchical depth buffer <NUM> for a pixel (e.g., pixel <NUM>) to a greatest depth value of the pixel <NUM> and each pixel adjacent to the pixel (e.g., pixels <NUM> and <NUM>). For non-edge pixels, there may be eight adjacent pixels.

For a second example biasing technique, at block <NUM>, biasing the sampled depth values may include determining a slope between a sampled depth value of a pixel and a sampled depth value of each neighboring pixel. For instance, the depth pre-pass component <NUM> or sampler <NUM> may determine the slope between the sampled depth value <NUM> of the pixel <NUM> and the sampled depth value <NUM> of each neighboring pixel <NUM>. The slope may be based on a difference of the sampled depth values and a uniform pixel size. At block <NUM>, biasing the sampled depth values may include determining a depth value along the slope at a pixel opposite each neighboring pixel. For instance, the depth pre-pass component <NUM> or sampler <NUM> may determine a depth value <NUM> along the slope at a pixel <NUM> opposite each neighboring pixel <NUM> (e.g., at phantom point <NUM>). At block <NUM>, biasing the sampled depth values may include setting a depth value of the hierarchical depth buffer metadata for a pixel to the furthest depth value of the sampled depth value of the pixel, the sampled depth value of each neighboring pixel, and each extrapolated depth value along the slope. For instance, the depth pre-pass component <NUM> or sampler <NUM> may set the depth value of the hierarchical depth buffer <NUM> for a pixel <NUM> to the furthest depth value of the sampled depth value <NUM> of the pixel, the sampled depth value <NUM>, <NUM> of each neighboring pixel, and each extrapolated depth value <NUM> along the slope.

At block <NUM>, the method <NUM> may include culling at least one tile or pixel from a full resolution rendering process in response to a depth of the at least one tile or pixel being further than a corresponding depth value in the GPU depth data <NUM>. In an implementation, for example, the GPU <NUM> may cull at least one tile or pixel from a full resolution rendering process in response to a depth of the at least one tile or pixel being further than a corresponding depth value in the GPU depth data <NUM>. In an implementation, the GPU <NUM> may perform the culling automatically in response to a request from the application <NUM> or display controller <NUM> to perform the full resolution rendering.

At block <NUM>, the method <NUM> may include performing the full resolution rendering process on remaining tiles or pixels to generate the image at the full resolution. For instance, the GPU <NUM> may use the render pipeline <NUM> to perform the full resolution rendering process on the remaining tiles or pixels (e.g., the tiles or pixels that are not culled). The GPU <NUM> may display the image on the computer display <NUM> at the full resolution.

Referring now to <FIG>, illustrated is an example computer device <NUM> in accordance with an implementation, including additional component details as compared to <FIG>. In one example, computer device <NUM> may include processor <NUM> for carrying out processing functions associated with one or more of components and functions described herein. Processor <NUM> can include a single or multiple set of processors or multi-core processors. Moreover, processor <NUM> can be implemented as an integrated processing system and/or a distributed processing system. In an implementation, for example, processor <NUM> may include CPU <NUM> and/or GPU <NUM>. In an example, computer device <NUM> may include memory <NUM> for storing instructions executable by the processor <NUM> for carrying out the functions described herein. In an implementation, for example, memory <NUM> may include memory <NUM> and/or memory <NUM>.

Further, computer device <NUM> may include a communications component <NUM> that provides for establishing and maintaining communications with one or more parties utilizing hardware, software, and services as described herein. Communications component <NUM> may carry communications between components on computer device <NUM>, as well as between computer device <NUM> and external devices, such as devices located across a communications network and/or devices serially or locally connected to computer device <NUM>. For example, communications component <NUM> may include one or more buses, and may further include transmit chain components and receive chain components associated with a transmitter and receiver, respectively, operable for interfacing with external devices.

Additionally, computer device <NUM> may include a data store <NUM>, which can be any suitable combination of hardware and/or software, that provides for mass storage of information, databases, and programs employed in connection with implementations described herein. For example, data store <NUM> may be a data repository for operating system <NUM> (<FIG>) and/or applications <NUM> (<FIG>).

Computer device <NUM> may also include a user interface component <NUM> operable to receive inputs from a user of computer device <NUM> and further operable to generate outputs for presentation to the user. User interface component <NUM> may include one or more input devices, including but not limited to a keyboard, a number pad, a mouse, a touch-sensitive display, a digitizer, a navigation key, a function key, a microphone, a voice recognition component, any other mechanism capable of receiving an input from a user, or any combination thereof. Further, user interface component <NUM> may include one or more output devices, including but not limited to a display (e.g., display <NUM>), a speaker, a haptic feedback mechanism, a printer, any other mechanism capable of presenting an output to a user, or any combination thereof.

In an implementation, user interface component <NUM> may transmit and/or receive messages corresponding to the operation of operating system <NUM> and/or application <NUM>. In addition, processor <NUM> executes operating system <NUM> and/or application <NUM>, and memory <NUM> or data store <NUM> may store them.

As used in this application, the terms "component," "system" and the like are intended to include a computer-related entity, such as but not limited to hardware, firmware, a combination of hardware and software, software, or software in execution. For example, a component may be, but is not limited to being, a process running on a processor, a processor, an object, an executable, a thread of execution, a program, and/or a computer. By way of illustration, both an application running on a computer device and the computer device can be a component. One or more components can reside within a process and/or thread of execution and a component may be localized on one computer and/or distributed between two or more computers. In addition, these components can execute from various computer readable media having various data structures stored thereon. The components may communicate by way of local and/or remote processes such as in accordance with a signal having one or more data packets, such as data from one component interacting with another component in a local system, distributed system, and/or across a network such as the Internet with other systems by way of the signal.

Various implementations or features may have been presented in terms of systems that may include a number of devices, components, modules, and the like. It is to be understood and appreciated that the various systems may include additional devices, components, modules, etc. and/or may not include all of the devices, components, modules etc. discussed in connection with the figures. A combination of these approaches may also be used.

The various illustrative logics, logical blocks, and actions of methods described in connection with the embodiments disclosed herein may be implemented or performed with a specially-programmed one of a general purpose processor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. A processor may also be implemented as a combination of computer devices, e.g., a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a DSP core, or any other such configuration. Additionally, at least one processor may comprise one or more components operable to perform one or more of the steps and/or actions described above.

Further, the steps and/or actions of a method or procedure described in connection with the implementations disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, a hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. An exemplary storage medium may be coupled to the processor, such that the processor can read information from, and write information to, the storage medium. Further, in some implementations, the processor and the storage medium may reside in an ASIC. Additionally, the ASIC may reside in a user terminal. Additionally, in some implementations, the steps and/or actions of a method or procedure may reside as one or any combination or set of codes and/or instructions on a machine readable medium and/or computer readable medium, which may be incorporated into a computer program product.

Claim 1:
A computing device for rendering an image at a full resolution, comprising:
a memory storing one or more parameters or instructions for executing an operating system and one or more applications;
a graphics processing unit, GPU, (<NUM>) for rendering frames of the one or more applications for display on a display device coupled to the computing device, the GPU including GPU depth data (<NUM>);
at least one processor coupled to the memory, and the GPU, wherein the at least one processor is configured to:
render (<NUM>) an occlusion geometry at a reduced resolution lower than the full resolution;
sample (<NUM>) a depth value of pixels of the occlusion geometry;
pre-populate (<NUM>) the GPU depth data based on the sampled depth values prior to a full resolution rendering process to generate the image at the full resolution, wherein the GPU depth data includes hierarchical depth buffer metadata (<NUM>); and
bias (<NUM>) the sampled depth values toward a further depth for pre-populating the GPU depth data,
wherein the GPU is configured to:
cull (<NUM>) at least one tile or pixel from a full resolution rendering process in response to a depth of the at least one tile or pixel being further than a corresponding depth value in the GPU depth data; and
perform (<NUM>) the full resolution rendering process on remaining tiles or pixels to generate the image at the full resolution.