WO2022134125A1

WO2022134125A1 - Graphics processing method and apparatus and electronic device

Info

Publication number: WO2022134125A1
Application number: PCT/CN2020/139783
Authority: WO
Inventors: 殷亚云
Original assignee: 华为技术有限公司
Priority date: 2020-12-27
Filing date: 2020-12-27
Publication date: 2022-06-30
Also published as: CN116670719A

Abstract

Disclosed in the present application are a graphics processing method and apparatus and an electronic device. The method mainly comprises: dividing a display region into multiple units arranged in an array, and respectively rendering multiple draws. For a part of any draw in any unit, when the highest visual priority of the draw in the unit is not lower than the lowest visual priority corresponding to the unit, the part of the draw in the unit is rendered, and when the highest visual priority of the draw in the unit is lower than the lowest visual priority corresponding to the unit, the part of the draw in the unit is not rendered, thereby facilitating the saving of computing resources.

Description

A graphics processing method, device and electronic device

technical field

The present application relates to the technical field of graphics processing, and in particular, to a graphics processing method, apparatus and electronic device.

Background technique

A graphics processor (graphics processing unit, GPU) is a dedicated hardware-accelerated processor for image rendering, which can perform graphics processing using basic graphics elements (primitives) as materials to generate images. In the process of graphics processing, the GPU can sequentially draw multiple drawings (draws) in the display area, each draw includes one or more primitives, and the primitives in the same draw can overlap each other. Each draw can cover the display area, and the primitives in different draws can also overlap each other. After that, the GPU renders the primitives in each draw to get the target image. Wherein, when any two primitives partially or completely overlap, the pixel of the primitive with a higher visual priority is preferentially displayed on each pixel of the overlapping area.

Specifically, the target image is superimposed by multiple draws. Different draws can have the same or different visual priorities on the same pixel in the display area. For example, the depth value can be used to represent the visual priority of each draw on each pixel. The smaller the depth value of any draw on any pixel, the higher the visual priority of the draw on that pixel. Taking pixel a as an example, the GPU can respectively determine the depth values of multiple draws at pixel a, and select the pixel a in the draw with the smallest depth value (such as draw1) as the pixel a in the target image. That is, the pixel a in the final generated image is the pixel a in draw1, and the pixel a in other draws will be occluded by the pixel a in draw1.

Because in the graphics processing process of the GPU, one or more primitives are often occluded by other primitives. In this case, these occluded parts do not actually need to be rendered, so the computing resources of the GPU are wasted.

SUMMARY OF THE INVENTION

In view of this, the present application provides a graphics processing method, apparatus and electronic device, which are beneficial to saving computing resources.

In a first aspect, the present application provides a graphics processing method, which mainly includes: dividing a display area into a plurality of units arranged in an array, each unit including at least one pixel, and the display area is used to display a target image to be generated, the target image Include multiple drawing draws that overlap within the display area. Render multiple draws respectively, and any one of the multiple draws is the first draw, where: when the highest visual priority of the first draw in the first unit is not lower than the lowest visual priority corresponding to the first unit , rendering the part of the first draw in the first unit, where the first unit is any one of the multiple units, and the lowest visible priority corresponding to the first unit is the lowest visible priority of the target image in the first unit; When the highest visual priority of the first draw in the first unit is lower than the lowest visual priority corresponding to the first unit, the part of the first draw in the first unit is not rendered.

Exemplarily, the visual priority may be a depth value or a drawing order. For example, the greater the depth value, the lower the visual priority. For another example, the primitives drawn first have a higher priority on each pixel than those drawn later. Primitive priority per pixel. With this implementation, when the highest visual priority of the first draw in the first unit is not lower than the lowest visual priority corresponding to the first unit, it means that the part of the first draw in the first unit may not be Other draw occlusions. In this case, the part of the first draw in the first cell can be rendered. When the highest visible priority of the first draw in the first unit is lower than the lowest visible priority corresponding to the first unit, it indicates that the part of the first draw in the first unit may be blocked by other draws. In this case, the part of the first draw in the first unit is not visible in the target image, so the part of the first draw in the first unit may not be rendered, which is beneficial to saving computing resources.

Next, the highest visual priority of the first draw in the first unit is further exemplified. Specifically, the first draw may include one or more primitives, wherein: when part or all of at least one primitive in the first draw is located in the first unit, the highest visible element of the first draw in the first unit The priority is the highest value of the highest visual priority of at least one primitive in the first unit; and/or, when none of the one or more primitives in the first draw is located in the first unit, the first The highest visual priority of draw in the first unit is the default value, and the default value is not higher than the lowest visual priority that can appear in the target image.

There are one or more primitives in the first draw, and each primitive may be partially or wholly located in the first unit, or may be located outside the first unit. When there are one or more primitives partially or entirely located in the first unit, each primitive in the first unit has the highest visible priority. In this case, the maximum value of the highest priority can be selected as the The highest visual priority of the first draw in the first unit. When all the primitives in the first draw are located in the first unit, that is, when the first draw is drawn, the primitives are not drawn in the first unit, so the highest possible value of the first draw in the first unit can be set. The visual priority is set to the default value, which is no higher than the lowest visual priority that can appear in the target image.

In this embodiment of the present application, each unit may include at least one subunit arranged in an array, and each subunit includes at least one pixel arranged in an array. In this case, the lowest visible priority corresponding to the first unit may be the lowest value of the lowest visible priority corresponding to at least one subunit in the first unit, wherein the lowest visible priority corresponding to the first subunit level is the lowest visible priority of the target image in the first subunit, and the first subunit is any subunit in at least one subunit of the first unit.

When rendering the first draw, it can be rendered at subunit granularity. In the case where there are multiple primitives in the first draw, one or more primitives may also be blocked by other primitives in the unit to be rendered, which will also result in invalid rendering. In order to further save computing resources, in a possible implementation manner, the first draw includes one or more primitives, and before rendering the part of the first draw in the first unit, a The first primitive, the first primitive is a primitive part or all of which is located in the first subunit in the first draw. When there is at least one first graphic element, at least one second graphic element is filtered out from the at least one first graphic element according to the highest visual priority of the at least one first graphic element in the first subunit respectively, and the screened out The at least one second graphic element is the first graphic element with the highest visual priority not lower than the lowest visual priority corresponding to the first subunit. Afterwards, when rendering the part of the first draw in the first unit, the part in which the at least one second primitive is located in the first subunit may be rendered.

In at least one of the first primitives, there may be primitives that are completely occluded. In order to reduce invalid rendering, the second primitive that is not completely occluded may be filtered out from the first primitive, and then the second primitive is rendered, thereby saving computing resources.

Exemplarily, when rendering the part of the at least one second primitive located in the first subunit, the visual priority of the first pixel may be determined for each second primitive, and the first pixel may be each second primitive. Any pixel in the first subunit. When the visible priority of the first pixel is higher than or equal to the lowest visible priority corresponding to the first subunit, the first pixel is rendered, and the visible priority of the first pixel is lower than the lowest visible priority corresponding to the first subunit. Depending on the priority, the first pixel is not rendered.

Specifically, if the visual priority of the first pixel is higher than or equal to the lowest visual priority corresponding to the first subunit, it means that the first pixel of the second graphic element may be displayed on the first pixel of the display area. Therefore the first pixel of the second primitive needs to be rendered. If the visual priority of the first pixel is lower than the lowest visual priority corresponding to the first sub-unit, it means that the first pixel of the second graphic element on the first pixel of the display area will be blocked by other graphic elements, so there is no need to Rendering the first pixel in the second primitive is beneficial to save computing resources.

In a second aspect, the present application provides a graphics processing device, which may be a GPU, such as a tile base rendering (TBR) GPU, an immediate rendering (IMR) GPU, and a tile deferred rendering (tile base rendering, TBR) GPU. base deferred rendering, TBDR) GPU, etc. For the technical effects of the corresponding solutions in the second aspect, reference may be made to the technical effects that can be obtained by the corresponding solutions in the first aspect, and the repeated parts will not be described in detail.

Exemplarily, the graphics processing device provided by the present application mainly includes a partition unit and a rendering unit, wherein: the partition unit can divide the display area into a plurality of units arranged in an array, each unit includes at least one pixel, and the display area is used for The target image to be generated is displayed, and the target image includes a plurality of drawing draws overlapping in the display area; the rendering unit can render the plurality of draws respectively, and any one of the plurality of draws is the first draw, wherein: in the first draw When the highest visual priority in the first unit is not lower than the lowest visual priority corresponding to the first unit, the part of the first draw in the first unit is rendered. The lowest visual priority corresponding to a unit is the lowest visual priority of the target image in the first unit; the highest visual priority of the first draw in the first unit is lower than the lowest visual priority corresponding to the first unit level, the part of the first draw in the first unit is not rendered.

Among them, the visual priority is the depth value or the drawing order.

Exemplarily, the first draw may include one or more primitives, wherein: when a part or all of at least one primitive is located in the first unit in the first draw, the highest visible value of the first draw in the first unit is The priority may be the highest value of the highest visual priority of the at least one graphic element in the first unit.

It can be understood that one or more primitives in the first draw often cannot cover all the units, so one or more primitives in the first draw may not be located in the first unit. When one or more primitives in the first draw are not located in the first unit, the highest visual priority of the first draw in the first unit can be the default value, and the default value is not higher than the one that can appear in the target image Lowest visible priority.

In this embodiment of the present application, each unit may include at least one subunit arranged in an array, and each subunit may include at least one pixel arranged in an array. The lowest visible priority corresponding to the first unit may be the lowest value of the lowest visible priority corresponding to at least one subunit in the first unit, wherein the lowest visible priority corresponding to the first subunit may be the target image The lowest visible priority in the first subunit, and the first subunit may be any subunit in at least one subunit of the first unit.

When rendering the first draw, it can be rendered at subunit granularity. In order to further save computing resources, in a possible implementation manner, the partition unit may further determine a first graphic element associated with the first subunit, where the first graphic element is partially or wholly located in the first subunit in the first draw graphic element; when there is at least one first graphic element, filter out at least one second graphic element from the at least one first graphic element according to the highest visual priority of the at least one first graphic element in the first subunit respectively , the screened out at least one second primitive is the first primitive whose highest visible priority is not lower than the lowest visible priority corresponding to the first subunit; the rendering unit can render at least one second primitive in the first primitive part of the subunit.

Exemplarily, when rendering the part of the at least one second primitive located in the first subunit, the rendering unit may determine the visual priority of the first pixel for each second primitive, and the first pixel may be each Any pixel of the two primitives in the first subunit; when the visible priority of the first pixel is higher than or equal to the lowest visible priority corresponding to the first subunit, the first pixel is rendered; When the visual priority is lower than the lowest visual priority corresponding to the first subunit, the first pixel is not rendered.

In a third aspect, the present application provides a graphics processing apparatus, and the graphics processing apparatus may be a GPU. Exemplarily, the graphics processing device mainly includes a memory and an arithmetic circuit. Wherein, the memory can buffer the operation data of the arithmetic circuit. The arithmetic circuit may execute the graphics processing method provided in any one of the above-mentioned first aspects.

In a fourth aspect, the present application provides an electronic device, which may be an electronic device with a graphics processing function, such as a smart phone and a tablet computer. It mainly includes a processor and a graphics processing device as provided in the third aspect, and the processor can instruct the graphics processing device to generate a target image.

In a fifth aspect, the present application provides a computer-readable storage medium, where instructions are stored in the computer-readable storage medium, when the computer-readable storage medium runs on a computer, the computer executes the methods described in the above aspects.

In a sixth aspect, the present application provides a computer program product comprising instructions which, when run on a computer, cause the computer to perform the methods of the above aspects.

These and other aspects of the present application will be more clearly understood in the description of the following embodiments.

Description of drawings

1 is a schematic structural diagram of an electronic device;

2a to 2c are schematic diagrams of multiple draws of a target image;

3 is a schematic diagram of a depth value;

4 is a schematic flowchart of a graphics processing method provided by an embodiment of the present application;

5 is a schematic diagram of multiple draws of a target image provided by an embodiment of the present application;

FIG. 6 is a schematic diagram of the relationship between tile and pixel block provided by an embodiment of the present application;

7 is a schematic diagram of the relationship between the pixel block and the depth block provided by the embodiment of the present application;

8 is a schematic diagram of the positional relationship between each graphic element of drawX and a plurality of subunits of any unit according to an embodiment of the present application;

FIG. 9 is a schematic flowchart of a specific graphics processing method provided by an embodiment of the present application;

FIG. 10 is a schematic structural diagram of a graphics processing apparatus according to an embodiment of the present application;

FIG. 11 is a schematic structural diagram of a graphics processing apparatus according to an embodiment of the present application.

Detailed ways

In order to make the objectives, technical solutions and advantages of the present application clearer, the present application will be further described in detail below with reference to the accompanying drawings. The specific operation methods in the method embodiments may also be applied to the apparatus embodiments or the system embodiments. It should be noted that, in the description of the present application, "at least one" refers to one or more, wherein a plurality of refers to two or more. In view of this, in the embodiment of the present invention, "a plurality" may also be understood as "at least two". "And/or", which describes the association relationship of the associated objects, means that there can be three kinds of relationships, for example, A and/or B, which can mean that A exists alone, A and B exist at the same time, and B exists alone. In addition, the character "/", unless otherwise specified, generally indicates that the related objects are an "or" relationship. In addition, it should be understood that in the description of this application, words such as "first" and "second" are only used for the purpose of distinguishing the description, and should not be understood as indicating or implying relative importance, nor should it be understood as indicating or implied order.

A GPU is a hardware-accelerated processor dedicated to graphics and graphics work. GPUs can generate target images for displaying 2D or 3D models. Therefore, GPUs are widely used in graphics-related fields such as games, videos, and modeling.

FIG. 1 exemplarily shows an electronic device, and the electronic device may be a smart camera, a smart phone, a tablet computer, or other devices with an image generation function. As shown in FIG. 1 , the electronic device 10 mainly includes a processor 11 and a GPU 12 , and the processor 11 is connected to the GPU 12 .

The processor 11 may be a chip with logic computing capability such as a central processing unit (CPU), a system on chip (SoC), or other types of application specific integrated circuits (application specific integrated circuits). ASIC), field programmable gate array (FPGA) and other programmable logic devices, transistor logic devices, hardware components or any combination thereof. The processor 11 can send various types of instructions to the GPU 12 so that the GPU 12 can complete graphics processing under the control of the processor 11 .

Taking the game scene as an example, the processor 11 can run the game client to obtain the target model that needs to be presented through the target image. For example, the target model can be a combination of one or more objects such as mountains, water, trees, characters, and the sky. The target image can also be understood as a game screen. In most scenarios, the target model of any form can usually be constructed by multiple primitives, and the processor 11 can instruct the GPU 12 to render these primitives in the display area of the target image, thereby obtaining the target image. Among them, primitives generally refer to basic graphic elements, mostly simple graphics such as dots, lines, and surface patterns.

When instructing the GPU 12 to render a primitive, the processor 11 often needs to send a draw-call (draw-call) instruction to the GPU 12, and the draw-call instruction may indicate the primitive to be rendered by the GPU 12 and the rendering state of the primitive. After receiving the draw-call instruction, the GPU 12 can determine the primitive to be rendered according to the draw-call instruction, and configure the rendering state of the primitive (for example, the shader configured to color the primitive, the material texture, etc.) to complete the rendering of the primitive.

It can be understood that if there are too many draw-call commands, the GPU 12 will frequently configure the rendering state, which is not conducive to improving the graphics processing efficiency. Therefore, currently a draw-call instruction can often call the GPU 12 to draw one or more primitives, and the primitives corresponding to the same draw-call instruction have the same or similar rendering states. Before the processor 11 sends the draw-call instruction, the GPU 12 only needs to configure the rendering state once, and then the rendering of one or more primitives can be completed. Therefore, it is beneficial to reduce the number of draw-call instructions and improve the efficiency of graphics processing.

Taking a game scene as an example, after the processor 11 obtains a plurality of primitives corresponding to the target model, the processor 11 can classify the plurality of primitives according to the rendering states of the plurality of primitives. In this case, the processor 11 may instruct the GPU 12 to render a draw every time a draw-call instruction is sent. Each draw can include one or more primitives, these primitives correspond to the same draw-call instruction, and the primitives have the same or similar rendering state.

Exemplarily, it is assumed that the target model is mainly composed of primitive a and primitive b, wherein primitive a belongs to drawA, and primitive b belongs to drawB. As shown in Figure 2a, the CPU 12 may instruct the GPU to render draw B and draw A in sequence. After the GPU finishes rendering draw B, the image shown in Figure 2b is formed in the display area of the target image. After the GPU 12 continues to render draw A in the display area, the image shown in FIG. 2c can be obtained in the display area.

It can be understood that both draw A and draw B can cover the display area. For each pixel in the display area, draw A and draw B have the same or different visual priority.

In one possible implementation, a depth value can be used to characterize the visual priority. First, a brief description of the depth value is given.

Assuming that there is a virtual camera, the virtual camera may also be called a view point. The target model includes one or more objects, along the lens orientation of the virtual camera, the projection distance of the object on the display area can be understood as the depth value of the object.

As shown in Fig. 3, the projection distance between the object 2 and the display area is the smallest, so the depth value of the object 2 is the smallest. The projection distance between object 3 and the display area is the largest, so the depth value of object 3 is the largest. The depth value of object 1 is located between the depth value of object 2 and the depth value of object 3.

When the projections of two objects overlap, distant objects will be occluded by nearby objects. For example, in Figure 3, object 1 can block object 3. Therefore, when the projection angle shown in Figure 3 is adopted and object 1, object 2 and object 3 are used as target models, the projection of object 1 will be preferentially displayed in the target image, while the projection of object 3 will be partially or completely occluded.

The above is the depth value and the occlusion relationship between different objects. In the target image, the depth value and the occlusion relationship are also satisfied between the primitives. That is to say, if any two primitives cover the same pixel, the pixel of the primitive with the smaller depth value is preferentially displayed on the pixel. It can also be understood that if the depth value of the draw on the pixel is smaller, the visual priority of the draw on the pixel is higher. For the depth value corresponding to the area not covered by the primitive in each draw, the default value can be used. The default value should be greater than or equal to the largest possible depth value in the target image.

It will be appreciated that the relationship between depth value and visual priority is not fixed. In some scenarios, the larger the depth value, the higher the visual priority. This embodiment of the present application does not limit this.

In another possible implementation, the visual priority may also be represented by the drawing sequence. Specifically, in some scenarios, the processor 11 may instruct the GPU 12 to draw multiple primitives in sequence in the display area, and the visual priority of each primitive increases in sequence according to the drawing sequence of the GPU 12 . That is, when two primitives overlap, the primitive drawn later is preferentially displayed in the overlapping area.

It can be understood that the relationship between drawing sequence and visual priority is not fixed. In some scenarios, it may also happen that the earlier the primitives are drawn, the higher the visual priority thereof, which is not limited in this embodiment of the present application.

It should be pointed out that, in addition to the depth value and the drawing sequence, the visual priority in the embodiment of the present application may also have multiple possible representation modes, which are not listed one by one in the embodiment of the present application.

For ease of understanding, unless otherwise specified, the following embodiments of the present application take a scenario in which the smaller the depth value is, the higher the visual priority is, as an example for description.

Since some primitives with larger depth values may be obscured by other primitives with smaller depth values, the occluded parts of primitives often do not need to be rendered in the target image without considering the existence of transparent or translucent objects. . Therefore, the rendering of the covered parts of the primitives by the GPU 12 is often invalid rendering, which wastes the computing resources of the GPU 12 .

In view of this, before rendering each draw, the GPU 12 may further perform a depth-test (depth-test) on the primitives in each draw, so as to filter out the primitives that are not completely occluded in each draw for rendering. Next, the specific implementation process of the depth test performed by the GPU 12 is further exemplified.

Exemplarily, each time the GPU 12 receives a draw-call instruction, it may perform a depth test on the primitives in the draw indicated by the draw-call instruction. After the processor 11 indicates all the primitives corresponding to the target model to the GPU 12 through the draw-call instruction, the GPU 12 will also synchronously complete the depth test on all the primitives, thereby obtaining the depth buffer data.

Take draw X as an example, the draw X can be any draw used to generate the target image. Specifically, draw X includes one or more primitives. For one target image, the processor 11 may send multiple draw-call instructions to the GPU 12 in sequence.

For the target image, if draw X is the draw indicated by the first draw-call instruction received by the GPU 12, the GPU 12 can obtain the initial depth buffer data, and the depth value of each pixel in the initial depth buffer data is Defaults. It can be understood that the default value is not less than the maximum depth value that can appear in the target image. The GPU updates the depth buffer data based on the depth values of one or more primitives in draw X. For example, draw X includes primitive x and primitive y, and primitive x and primitive y overlap at pixel i. Among them, the depth value of primitive x at pixel i is 10, and the depth value of primitive y at pixel i is 15.

During the depth test of draw X, the GPU can obtain the depth value of the primitive x at each pixel. The GPU first updates the depth buffer data according to the depth value of the primitive x at each pixel. At this time, the depth value of pixel i in the depth buffer data is the default value, and the depth value of the primitive x in pixel i is 10 (less than the default value), and the GPU can update the depth value of pixel i in the depth buffer data to 10.

After traversing the depth values of each pixel in the primitive x, the GPU can obtain the depth value of each pixel in the primitive y. The GPU continues to update the depth buffer data according to the depth value of the primitive y at each pixel. At this time, the depth value of pixel i in the depth buffer data is 10, and the depth value of primitive y in pixel i is 15 (greater than 10). Since the depth value of the primitive y at the pixel i is greater than the depth value of the pixel i in the depth buffer data at this time, it can be considered that the primitive y at the pixel i will be covered by other primitives (the primitive x), and the GPU maintains the depth buffer. The depth value of pixel i in the data is 10.

The GPU 12 can then render the primitives in draw X respectively according to the depth buffer data. Taking the pixel j covered by the primitive x as an example, assuming that the depth value corresponding to the pixel j in the depth buffer data is 15, if the depth value of the primitive x in the pixel j is 10, it is smaller than the depth corresponding to the pixel j in the depth buffer data. value, it means that the pixel j in the target image may represent the pixel j of the primitive x, and the GPU 12 can render the pixel j in the primitive x, that is, the pixel of the primitive x is presented on the pixel j. If the depth value of the primitive x in the pixel j is 20, which is greater than the depth value corresponding to the pixel j in the depth buffer data, it means that the pixel j in the target image may not present the pixel j of the primitive x, and the GPU 12 may not render the pixel j. The pixel j in the primitive j is beneficial to save the computing resources of the GPU 12 .

For the target image, if draw X is the draw indicated by the nth draw-call instruction corresponding to the target image received by the GPU 12, and n is an integer greater than 1, then the GPU 12 can obtain a The depth buffer data obtained after the draw) indicated by the draw-call instruction completes the depth test, and on this basis, the depth test of draw X is continued. The specific depth testing process is similar to the above, and will not be repeated here.

In general, GPUs can perform depth testing before pixel shaders. When performing pixel shading, pixels in each primitive that are not occluded by other primitives in the same draw can be shaded. Among them, the depth test performed before pixel shading may also be called early-depth-test.

In some scenes, such as when there are transparent or semi-transparent objects in the model, pixel shading will change the depth value of some pixels, so it is often necessary to perform depth testing after pixel shading, which can also be called post-depth testing (late-depth testing). depth-test).

In addition, there are some scenes where the depth value of some pixels is affected by pixel shading, but the effect is predictable. For example, after pixel shading, the depth value of some pixels can become larger. In this case, a pre-depth test can be performed before pixel shading and another depth test after pixel shading. This depth test method may also be referred to as a conservative depth test.

Although by passing the above depth test, the process of rendering partially occluded primitives within each draw can be omitted. However, primitives overlap between different draws. As shown in Figure 2c, primitive a in draw A will partially occlude primitive b in draw B. If the processor 11 first instructs the GPU 12 to render the primitive b in the draw B, and then instructs the GPU 12 to render the primitive a in the draw A, in this case, the invalid rendering of the primitive b cannot be avoided through the above depth test, resulting in GPU computing resources are wasted.

In view of this, the embodiments of the present application provide a graphics processing method, which can reduce invalid rendering during graphics processing and save GPU computing resources. It should be pointed out that the graphics processing method provided by the embodiments of the present application can be applied to subregion rendering (tile base rendering, TBR) GPU, immediate rendering (immediate rendering, IMR) GPU, subregion deferred rendering (tile base deferred rendering, TBDR) GPU and other types of GPU.

FIG. 4 exemplarily shows a graphics processing method provided by an embodiment of the present application. As shown in Figure 4, it mainly includes the following steps:

S401: Divide the display area of the target image to be generated into a plurality of units arranged in an array, and each unit includes at least one pixel.

S401 may also be referred to as a binning pass. Exemplarily, as shown in FIG. 2 a and FIG. 5 , the GPU 12 may divide the display area into units 0 to 15 . Cells 0 to 15 are arranged in an array in the display area, and each cell may include one or more pixels arranged in an array. It can be understood that since the target image includes multiple draws that overlap in the display area, the GPU12 divides the display area into multiple units, which can also be equivalent to that the GPU12 divides the multiple draws that constitute the target image into multiple draws arranged in an array. unit.

For example, in Fig. 2a, the target image includes drawA and drawB, and the display area is divided into units 0 to 15, which is equivalent to the GPU 12 dividing drawA and drawB into units 0 to 15 respectively. 5, the target image includes drawA, drawB, drawC and drawD, and the display area is divided into units 0 to 15, which is equivalent to the GPU 12 dividing drawA, drawB, drawC and drawD into units 0 to 15 respectively.

In the embodiment of the present application, each unit corresponds to the lowest visible priority, that is, the lowest visible priority of the target image in each unit. For example, in a scene where the smaller the depth value is, the higher the visual priority is, the lowest visual priority corresponding to each unit is the maximum depth value Dmax corresponding to each unit. The maximum depth value Dmax corresponding to each unit can be understood as the maximum depth value of the target image in this unit. For example, the maximum depth value corresponding to unit 0 may be the maximum depth value of the target image in unit 0, or it may be understood as the maximum depth value of visible pixels in unit 0.

Exemplarily, the GPU 12 may calculate the maximum depth value of the target image in each unit by methods such as enumeration, scan line algorithm, linear difference algorithm, etc., which is not limited in this embodiment of the present application. It can be understood that there may be errors in the calculation result compared with the actual target image obtained. In view of this, the GPU can use a more conservative algorithm to calculate each corresponding maximum depth value. Taking unit 0 as an example, the calculation is performed by a relatively conservative algorithm. On the basis of ensuring that the calculated maximum depth value Dmax corresponding to unit 0 is not less than the maximum depth value of the target image actually obtained in the later stage in unit 0, make the corresponding maximum depth value of unit 0. The maximum depth value Dmax is as close as possible to the maximum depth value of the target image in unit 0 actually obtained later.

For another example, in a scenario where the larger the depth value is, the higher the visual priority is, the lowest visual priority corresponding to each unit is the minimum depth value corresponding to each unit. The minimum depth value corresponding to each unit can be understood as the minimum depth value of the target image in this unit. For example, the minimum depth value corresponding to unit 0 may be the minimum depth value of the target image in unit 0, or it may be understood as the minimum depth value of the visible pixels in unit 0.

For another example, in a scenario where the visual priority of each graphic element increases in sequence according to the drawing sequence, the lowest visual priority corresponding to each unit is the earliest graphic element drawn by the target image in that unit. priority. For example, if there are 3 primitives in the target image, some or all of them are located in unit 0, and the lowest visible priority corresponding to unit 0 is the priority of the earliest drawn primitive among the above 3 primitives.

Also, for example, in a scenario where the visual priority of each primitive decreases in sequence according to the drawing sequence, the lowest visual priority corresponding to each unit is the final value of the primitive drawn by the target image in the unit. priority. For example, if there are 3 primitives in the target image, some or all of them are located in unit 0, and the lowest visible priority corresponding to unit 0 is the priority of the earliest drawn primitive among the above 3 primitives.

In addition, each draw in the embodiment of the present application also corresponds to a plurality of maximum visual priorities. Specifically, each draw can be divided into multiple units, and the multiple maximum visual priorities corresponding to each draw can be understood as the maximum visual priorities of the draw in the multiple units respectively.

For example, in a scene with a smaller depth value and a higher visual priority, each draw corresponds to multiple minimum depth values Dmin. For example, drawA includes unit 0 to unit 15, then draw A has 15 minimum depth values corresponding to unit 0 to unit 15 respectively, such as DminA0 to DminA15. Among them, DminA0 is the minimum depth value of drawA in unit 0, DminA1 is the minimum depth value of drawA in unit 1, ..., DminA15 is the minimum depth value of drawA in unit 15.

For another example, in a scene with a larger depth value and a higher visual priority, each draw corresponds to multiple maximum depth values. For another example, in a scenario where the visual priority of each primitive increases in sequence according to the drawing sequence, each draw corresponds to multiple highest visual priorities, that is, the draw is drawn at the latest in each unit. The priority of the primitive. For another example, in a scenario where the visual priority of each primitive decreases in sequence according to the drawing sequence, each draw corresponds to multiple highest visual priorities, that is, the earliest drawing drawn by the draw in each unit. Element priority.

For ease of understanding, the embodiment of the present application uses a scene in which the smaller the depth value is, the higher the visual priority is, as an example for description. It should be pointed out that the specific implementation of the visual priority in other scenarios and the determination of the priority level can be realized by making adaptive adjustments on the basis of the following examples provided in this application, and shall also be included in the embodiments of this application. among.

As mentioned above, the minimum depth value corresponding to each unit can be understood as the minimum depth value of the target image in this unit. In a possible implementation manner, the GPU 12 may obtain the minimum depth value corresponding to each unit according to the depth buffer data. Taking FIG. 5 as an example, it is assumed that the processor 11 sequentially sends the draw-call instruction 1 corresponding to draw D, the draw-call instruction 2 corresponding to draw C, the draw-call instruction 3 corresponding to draw B, and the draw corresponding to draw C to the GPU 12. -call instruction 4. GPU12 can also perform depth test on draw D to draw A. After completing the depth test on draw A, the depth value corresponding to each pixel in the obtained depth buffer data can be understood as the depth corresponding to each pixel in the target image. value. Therefore, the maximum depth value corresponding to each unit can be determined on the basis of the depth buffer data.

As mentioned earlier, each draw corresponds to multiple maximum depth values. Exemplarily, as shown in Figure 5, draw D includes a primitive d1 and a primitive d2 (the same is true for the case where draw D has only one primitive or draw D has three or more primitives). For any unit in the display area, the minimum depth value of the unit mainly has the following possible situations:

Case 1: Part or all of the primitive d1 is located in the unit, and the primitive d2 is all located outside the unit, such as unit 0 in FIG. 5 . In this case, the minimum depth value of drawD in unit 0 is the minimum depth value of primitive d1 in unit 0, that is, the minimum depth value of each pixel in the part of primitive d1 located in unit 0.

Case 2: Part or all of the primitives d2 are located in this unit, and all of the primitives d1 are located outside the unit, such as unit 15 in FIG. 5 . In this case, the minimum depth value of drawD in unit 15 is the minimum depth value of primitive d2 in unit 15, that is, the minimum depth value of each pixel in the portion of primitive d2 located in unit 15.

Case 3: Part or all of the primitive d1 is located in this unit, and part or all of the primitive d2 is located in this unit, for example, the unit 9 in FIG. 5 . In this case, assuming that the minimum depth value of primitive d1 in unit 9 is Dmind1, and the minimum depth value of primitive d2 in unit 9 is Dmind2, the minimum depth value of drawD in unit 9 is the minimum of Dmind1 and Dmind2.

Case 4: Both the primitive d1 and the primitive d2 are located outside the unit, such as unit 11 in FIG. 5 . In this case, the minimum depth value of drawD in unit 11 may be the default value, and the default value is not less than the maximum depth value that can appear in the target image.

In other words, each unit has a maximum depth value Dmax corresponding to it, and a plurality of minimum depth values, and the plurality of minimum depth values respectively correspond to a plurality of draws of the target image in a one-to-one manner. For example, unit 0 in FIG. 5 has one maximum depth value Dmax and 4 minimum depth values Dmin corresponding to it. The four minimum depth values Dmin are respectively the minimum depth value DminA0 of drawA in unit 0, the minimum depth value DminB0 of drawB in unit 0, the minimum depth value DminC0 of drawC in unit 0, and the minimum depth value DminD0 of drawD in unit 0.

Exemplarily, the GPU 12 may calculate a plurality of minimum depth values corresponding to each unit through methods such as enumeration, scan line algorithm, linear difference algorithm, etc., which is not limited in this embodiment of the present application.

S402: Render multiple draws respectively.

S402 may also be referred to as a rendering pass. Specifically, the GPU 12 may render the multiple draws according to the respective maximum depth values Dmax corresponding to the multiple units and multiple minimum depth values Dmin corresponding to each draw.

Taking drawA as an example, the GPU 12 sequentially traverses the units in drawA in the order of unit 0 to unit 15 . Taking unit 0 as an example, when the minimum depth value DminA0 of drawA in unit 0 is less than or equal to the maximum depth value Dmax0 corresponding to unit 0, it means that at unit 0, drawA may not be blocked by primitives in other draws. So the GPU can render the part of drawA in cell 0.

When the minimum depth value DminA0 of drawA in unit 0 is greater than the maximum depth value Dmax0 corresponding to unit 0, the depth value of any pixel in drawA in unit 0 is smaller than the maximum depth value of the target image in unit 0. Therefore, it can be considered that drawA will be completely occluded by the primitives in other draws, and the rendering of drawA at this time is invalid rendering. In order to save GPU computing resources, in this case, GPU 12 may not render the part of drawA in unit 0.

The GPU 12 continues to traverse the unit 1 to the unit 15 according to the above process, so as to complete the rendering of drawA. It can be understood that, because the GPU 12 in this embodiment of the present application may not render the completely occluded units in drawA, there may be one or more units in the rendered drawA that have not been rendered.

The rendering of drawB, drawC, and drawD by GPU12 is similar, and the specific implementation will not be repeated. After the GPU 12 completes the rendering of draw D to draw A, the target image can be obtained. As shown in Figure 5, if the depth value of primitive a in draw A is greater than the depth value of primitive b in draw B, primitive a will be completely occluded by primitive b. Using the graphics processing method provided by the embodiment of the present application, the GPU 12 does not need to respond to the draw-call instruction 4 corresponding to draw A, neither needs to configure the rendering state of the primitive a, nor does it need to render the primitive a, which is beneficial to The computing resources of the GPU 12 are saved.

It can be understood that in the above manner, the process of rendering the units occluded by other draws in each draw can be omitted. However, within each draw, there may also be occlusions between primitives, thereby wasting the computing resources of the GPU 12 . Moreover, if each unit includes more pixels, the invalid rendering of the occluded primitives by the GPU 12 will increase. In view of this, in the embodiment of the present application, each unit may include at least one subunit arranged in an array, Each subunit includes at least one pixel arranged in an array.

For example, the display area may be divided into 16 cells (cell 0 to cell 15). Each unit may further include 4 subunits, specifically, unit 0 may include subunit 0-0 to subunit 0-3, unit b1 includes subunit 1-4 to subunit 1-7, ..., unit 15 Subunits 15-60 to 15-63 may be included.

Each subunit corresponds to a maximum depth value, and the maximum depth value is the maximum depth value of the target image in the first subunit. Taking unit 0 as an example, the GPU may take the maximum value among the maximum depth values corresponding to subunit 0-0 to subunit 0-3 as the maximum depth value corresponding to unit 0. The same is true for other units and will not be repeated here.

Exemplarily, when the embodiments of the present application are applied to a TBR GPU, the unit may be a tile, and the subunit may be a pixel block or a depth block; Cells can be depth blocks.

Among them, tiles in TBR GPU are mainly used for partition rendering. In the process of rendering each draw on the TBR GPU, the TBR GPU only needs to cache the data generated in the process of rendering a tile. Compared with the traditional GPU (the GPU needs to cache the data generated in the process of rendering the entire draw), the display Dividing a region into multiple tiles can greatly reduce the storage space required by the GPU. In the embodiment of the present application, the tiles in the TBR GPU can be reused as the unit in the embodiment of the present application, which is beneficial to reduce changes to the TBR GPU and save design costs.

Generally speaking, tiles include more pixels. It can be understood that if the number of pixels in a unit is large, it is not conducive to improving the fineness of the embodiment of the present application, and may reduce the optimization effect of the embodiment of the present application on the computing resources of the GPU 12 . In view of this, the unit in this embodiment of the present application may also be a pixel block.

Specifically, as shown in FIG. 6 , each tile may include a plurality of pixel blocks (b0 to b15) arranged in an array. When the unit in the embodiment of the present application is a pixel block, the subunit may be a depth block. As shown in Fig. 7, each pixel block includes 4 depth blocks, wherein b0 includes d0 to d3, b1 includes d4 to d7, ..., b15 includes d60 to d63.

In this embodiment of the present application, the GPU 12 may render each draw at the granularity of subunits. Since the number of pixels in the subunit is not greater than the number of pixels in the unit, it is beneficial to improve the fineness of the contrast in the rendering process and to improve the optimization effect of the computing resources of the GPU 12 .

Specifically, take draw X as an example, the draw X can be any draw in the target image. Before rendering the draw X, the GPU 12 may first determine the first primitive associated with each subunit in the draw X, wherein the first primitive associated with each subunit may be a part or all of the primitives located in the first subunit. Figure 8 is a schematic diagram of drawX in any unit, and any unit is a pixel block. The any unit includes 64 sub-units (depth blocks), which are sub-unit d0 to sub-unit d63 respectively. As shown in FIG. 8 , the first primitive associated with the subunit d48 includes the primitive x1, the primitive x2 and the primitive x3.

The GPU 12 filters out at least one second primitive from the primitive x1 to the primitive x3 according to the minimum depth values of the primitive x1, the primitive x2 and the primitive x3 in the subunit d48, respectively. Specifically, if the minimum depth value of the primitive x1 in the subunit d48 is less than or equal to the maximum depth value corresponding to the subunit d48, it means that the part of the primitive x1 in the subunit d48 may not be blocked by other primitives , so the part of the primitive x1 in the subunit d48 needs to be rendered, and the primitive x1 can be used as the second primitive.

If the minimum depth value of the primitive x1 in the subunit d48 is smaller than the maximum depth value corresponding to the subunit d48, it means that the part of the primitive x1 in the subunit d48 is blocked by other primitives, so there is no need to render the primitive x1 in the subunit d48. Section in cell d48. The same is true for other graphic elements and will not be repeated here.

In the process of subsequent rendering of drawX, the GPU 12 only needs to render the part of the second primitive in the subunit d48. The GPU does not need to render the primitives that are completely occluded in the subunit d48, so it is beneficial to further save the GPU computing resources.

In the specific implementation process, the GPU can determine the second primitive that needs to be rendered in each draw in the partition stage, and record the difference between the second primitive and the subunit in each draw in the polygon list (PL). Correspondence. In some scenarios, the PL can be stored in the PL heap, and the PL heap can also include the configuration information of each draw (such as the identifier and pointer of each draw), the boundary identifier between adjacent draws, etc. The specific implementation You can refer to the existing TBR GPU, which will not be repeated here.

As shown in FIG. 8 , although the primitive x1 and the primitive x2 need to be rendered, some areas of the primitive x2 in the subunit d48 are still occluded by the primitive x3. In this case, the rendering of this part of the pixels in the primitive x2 is invalid rendering. In order to further save the computing resources of the GPU 12, taking the part of the rendering primitive x2 in the subunit d48 as an example, the GPU 12 can first determine the depth value of the pixel for each pixel in this part, and the depth value of the pixel is less than or equal to When the maximum depth value corresponding to the subunit d48, the pixel is rendered; when the depth value of the pixel is greater than the maximum depth value corresponding to the subunit d48, the pixel is not rendered. By adopting the above scheme, the invalid rendering of some pixels can be further omitted, which is beneficial to further saving the computing resources of the GPU 12.

Next, taking FIG. 9 as an example, the graphics processing method provided by the embodiment of the present application is further exemplified. As shown in FIG. 9 , the graphics method provided by the embodiment of the present application is mainly divided into a partition stage ( S401 ) and a rendering stage ( S402 ). Specifically, it mainly includes the following steps:

S901: After receiving the multi-draw instruction instructed by the processor 11, the GPU 12 performs rasterization (raserization) processing on the display area. Each draw includes one or more primitives. Through the rasterization process, the display area can be divided into a plurality of pixels arranged in an array. On this basis, the display area can be further divided into a plurality of units arranged in an array, and each unit includes at least one pixel arranged in an array.

S902: Determine the maximum depth value Dmax corresponding to each unit, and the minimum depth value Dmin of each draw in each unit.

It can be understood that in the case that each unit includes only one pixel, the maximum depth value Dmax corresponding to each unit is the depth value of the pixel in the target image. In this case, the maximum depth value Dmax corresponding to each unit can also be understood as the depth value corresponding to each pixel in the obtained depth buffer data after completing the depth test for all the multiple draws of the target image. For example, in the scene shown in Figure 5, the depth test is performed on draw D to draw A in turn, and the depth buffer data obtained after the depth test on draw A is completed can be used as the maximum depth value Dmax corresponding to each unit (pixel). .

In the case that only one pixel is included in each unit, the minimum depth value Dmin of each draw in each unit is the depth value of each draw on each pixel. For example, in the scene shown in FIG. 5 , the depth value of draw A on unit (pixel) 14 is equivalent to the minimum depth value Dmin of draw A on unit (pixel) 14 .

S903: Filter out the second primitive in each draw and record it in the PL. PL can be stored in the PL heap. As mentioned earlier, there may be occlusions between primitives in each draw. The second primitive in each draw can be understood as a primitive that is not completely occluded by other primitives in the same draw. By filtering the second primitive in each draw, invalid rendering can be reduced and GPU computing resources can be saved .

S904: When rendering any draw, read the PL corresponding to the draw and the configuration information of the draw from the PL heap.

S905: Determine whether the part of the draw in each unit needs to be rendered according to the maximum depth value Dmax corresponding to each unit and the minimum depth value Dmin of the draw in each unit. As mentioned earlier, occlusion may also occur between primitives between different draws. Before rendering, filter out the units that need to be rendered in each draw, which is beneficial to reduce invalid rendering and save GPU computing resources.

S906: Render the part of the draw that needs to be rendered in each unit.

After testing, in benchmark tests such as Manhattan 3.0/3.1 and Aztec, through the above method, in any unit, more than 10% of the draw can be directly placed in the part of the unit in advance. Discard, i.e. do not render the part of these draws in this unit. In some scenes, more than 50% of the draws in the unit can be discarded in advance. It also performs well for many game scenarios.

The solution provided by the present application has been described above mainly from the perspective of method embodiments. It can be understood that, in order to realize the above-mentioned functions, the GPU 12 may include corresponding hardware structures and/or software modules for performing each function. Those skilled in the art should easily realize that the present invention can be implemented in hardware or a combination of hardware and computer software in conjunction with the units and algorithm steps of each example described in the embodiments disclosed herein. Whether a function is implemented by hardware or computer software driven hardware depends on the specific application and design constraints of the technical solution. Skilled artisans may implement the described functionality using different methods for each particular application, but such implementations should not be considered beyond the scope of the present invention.

In the case of using an integrated unit, FIG. 10 shows a possible exemplary block diagram of the graphics processing apparatus involved in the embodiments of the present application, and the graphics processing apparatus 1000 may be the GPU in any of the above-mentioned embodiments or other Integrated circuits for graphics processing functions. The graphics processing apparatus 1000 may include: a partition unit 1001 and a rendering unit 1002 .

Specifically, in one embodiment, the partition unit 1001 can divide the display area into a plurality of units arranged in an array, each unit includes at least one pixel, the display area is used to display the target image to be generated, and the target image is included in the display area. Multiple drawing draws that overlap in the area; the rendering unit 1002 can render multiple draws respectively, and any draw in the multiple draws is the first draw, wherein: the highest visual priority of the first draw in the first unit is not When it is lower than the lowest visual priority corresponding to the first unit, the part of the first draw in the first unit is rendered. The first unit is any one of the multiple units, and the lowest visual priority corresponding to the first unit is the target. The lowest visual priority of the image in the first unit; when the highest visual priority of the first draw in the first unit is lower than the lowest visual priority corresponding to the first unit, do not render the first draw in the first unit part of the unit.

Among them, the visual priority is the depth value or the drawing order.

Exemplarily, the first draw may include one or more primitives, wherein: when a part or all of at least one primitive is located in the first unit in the first draw, the highest visible value of the first draw in the first unit is The priority, which can be the highest value of the highest visual priority of the at least one graphic element in the first unit; and/or, when one or more graphic elements in the first draw are not located in the first unit, The highest visual priority of the first draw in the first unit may be a default value, and the default value is not higher than the lowest visual priority that can appear in the target image.

When rendering the first draw, it can be rendered at subunit granularity. In order to further save computing resources, in a possible implementation manner, the partitioning unit 1001 may also determine a first graphic element associated with the first subunit, where the first graphic element is partially or entirely located in the first subunit in the first draw When there is at least one first graphic element, filter out at least one second graphic element from the at least one first graphic element according to the highest visual priority of the at least one first graphic element in the first subunit respectively element, the at least one second element screened out is the first element with the highest visible priority not lower than the lowest visible priority corresponding to the first subunit; the rendering unit 1002 can render at least one second element located in part of the first subunit.

Exemplarily, when rendering the part of at least one second primitive located in the first subunit, the rendering unit 1002 may determine the visual priority of the first pixel for each second primitive, and the first pixel may be each The second primitive is any pixel in the first subunit; when the visual priority of the first pixel is higher than or equal to the lowest visual priority corresponding to the first subunit, the first pixel is rendered; in the first pixel When the visible priority of the first subunit is lower than the lowest visible priority corresponding to the first subunit, the first pixel is not rendered.

Referring to FIG. 11 , which is a schematic diagram of a graphics processing device provided by the present application, the graphics processing device may be the GPU in the above-mentioned embodiment or other integrated circuits with graphics processing functions. The graphics processing apparatus 1100 includes: a memory 1101 and an arithmetic circuit 1102 . Exemplarily, the operation circuit 1102 may be an integrated circuit with logic operation capability, and may execute the above-mentioned graphics processing method provided by the embodiments of the present application. In a possible implementation manner, the operation circuit 1102 may include multiple arithmetic and logic units (ALUs), and the multiple ALUs in the graphics processing device 1100 may perform logic operations in parallel, thereby improving the performance of the graphics processing device 1100. calculating speed.

The memory 1101 can buffer data generated when the arithmetic circuit 1102 operates. For example, the operation circuit 1102 may write the lowest visible priority corresponding to each unit into the memory 1101 after determining the lowest visible priority corresponding to each unit. In the rendering stage, the arithmetic circuit 1102 reads the lowest visual priority corresponding to each unit from the memory 1101, so that each draw can be rendered.

As will be appreciated by those skilled in the art, the embodiments of the present application may be provided as a method, a system, or a computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to the present application. It will be understood that each flow and/or block in the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to the processor of a general purpose computer, special purpose computer, embedded processor or other programmable data processing device to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing device produce Means for implementing the functions specified in a flow or flow of a flowchart and/or a block or blocks of a block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory result in an article of manufacture comprising instruction means, the instructions The apparatus implements the functions specified in the flow or flow of the flowcharts and/or the block or blocks of the block diagrams.

These computer program instructions can also be loaded on a computer or other programmable data processing device to cause a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process such that The instructions provide steps for implementing the functions specified in the flow or blocks of the flowcharts and/or the block or blocks of the block diagrams.

Obviously, those skilled in the art can make various changes and modifications to the present application without departing from the protection scope of the present application. Thus, if these modifications and variations of the present application fall within the scope of the claims of the present application and their equivalents, the present application is also intended to include these modifications and variations.

Claims

A graphics processing method, comprising:

The display area is divided into a plurality of units arranged in an array, each unit includes at least one pixel, the display area is used to display the target image to be generated, and the target image includes a plurality of drawings overlapping in the display area draw;

The multiple draws are rendered respectively, and any one of the multiple draws is the first draw, where:

When the highest visual priority of the first draw in the first unit is not lower than the lowest visual priority corresponding to the first unit, the part of the first draw in the first unit is rendered, so The first unit is any one of the multiple units, and the lowest visible priority corresponding to the first unit is the lowest visible priority of the target image in the first unit;

When the highest visual priority of the first draw in the first unit is lower than the lowest visual priority corresponding to the first unit, the part of the first draw in the first unit is not rendered .
The method of claim 1, wherein the first draw includes one or more primitives, wherein:

When part or all of at least one primitive in the first draw is located in the first unit, the highest visual priority of the first draw in the first unit is the at least one primitive respectively the highest value of the highest visible priority in the first unit.
The method according to claim 1 or 2, wherein each unit includes at least one subunit arranged in an array, and each subunit includes at least one pixel arranged in an array;

The lowest visible priority corresponding to the first unit is the lowest value of the lowest visible priority corresponding to the at least one subunit in the first unit, wherein the lowest visible priority corresponding to the first subunit level is the lowest visible priority of the target image in the first subunit, and the first subunit is any subunit in at least one subunit of the first unit.
The method of claim 3, wherein the first draw includes one or more primitives, and before rendering the part of the first draw in the first unit, further comprising:

determining a first primitive associated with the first subunit, where the first primitive is a primitive part or all of the primitives located in the first subunit in the first draw;

When there is at least one first graphic element, filter out at least one first graphic element from the at least one first graphic element according to the highest visual priority of the at least one first graphic element in the first subunit respectively Two graphic elements, the at least one second graphic element is the first graphic element with the highest visual priority not lower than the lowest visual priority corresponding to the first subunit;

Rendering the part of the first draw in the first unit, including:

Rendering the portion of the at least one second primitive located in the first subunit.
The method of claim 4, wherein rendering the portion of the at least one second primitive located in the first subunit comprises:

For each second graphic element, determine a visual priority of a first pixel, where the first pixel is any pixel of each second graphic element in the first subunit;

rendering the first pixel when the visual priority of the first pixel is higher than or equal to the lowest visual priority corresponding to the first subunit;

When the visual priority of the first pixel is lower than the lowest visual priority corresponding to the first subunit, the first pixel is not rendered.
The method according to any one of claims 1 to 5, wherein the visual priority is a depth value or a drawing order.
A graphics processing device, comprising a partition unit and a rendering unit, wherein:

The partition unit is used for: dividing the display area into a plurality of units arranged in an array, each unit including at least one pixel, the display area is used to display the target image to be generated, and the target image is included in the Multiple drawing draws that overlap in the display area;

The rendering unit is configured to: render the multiple draws respectively, and any draw in the multiple draws is the first draw, wherein:

When the highest visual priority of the first draw in the first unit is not lower than the lowest visual priority corresponding to the first unit, the part of the first draw in the first unit is rendered, so The first unit is any one of the multiple units, and the lowest visible priority corresponding to the first unit is the lowest visible priority of the target image in the first unit;

When the highest visual priority of the first draw in the first unit is lower than the lowest visual priority corresponding to the first unit, the part of the first draw in the first unit is not rendered .
The graphics processing apparatus according to claim 7, wherein the first draw includes one or more primitives, wherein:

When part or all of at least one primitive in the first draw is located in the first unit, the highest visual priority of the first draw in the first unit is the at least one primitive the highest value of the highest visible priority in the first unit respectively; and/or,

When one or more primitives in the first draw are not located in the first unit, the highest visual priority of the first draw in the first unit is the default value, the default value No higher than the lowest visible priority that can appear in the target image.
The graphics processing device according to claim 7 or 8, wherein each unit includes at least one subunit arranged in an array, and each subunit includes at least one pixel arranged in an array;

The lowest visible priority corresponding to the first unit is the lowest value of the lowest visible priority corresponding to the at least one subunit in the first unit, wherein the lowest visible priority corresponding to the first subunit level is the lowest visible priority of the target image in the first subunit, and the first subunit is any subunit in at least one subunit of the first unit.
The graphics processing device according to claim 9, wherein the partition unit is further configured to:

determining a first primitive associated with the first subunit, where the first primitive is a primitive part or all of the primitives located in the first subunit in the first draw;

When there is at least one first graphic element, filter out at least one first graphic element from the at least one first graphic element according to the highest visual priority of the at least one first graphic element in the first subunit respectively Two graphic elements, the at least one second graphic element is the first graphic element with the highest visual priority not lower than the lowest visual priority corresponding to the first subunit;

The rendering unit is specifically used for:

Rendering the portion of the at least one second primitive located in the first subunit.
The graphics processing apparatus according to claim 10, wherein the rendering unit is specifically configured to:

For each second graphic element, determine a visual priority of a first pixel, where the first pixel is any pixel of each second graphic element in the first subunit;

When the visual priority of the first pixel is higher than or equal to the lowest visual priority corresponding to the first subunit, rendering the first pixel;

When the visual priority of the first pixel is lower than the lowest visual priority corresponding to the first subunit, the first pixel is not rendered.
The graphics processing apparatus according to any one of claims 7 to 11, wherein the visual priority is a depth value or a drawing order.
A graphics processing device, comprising a memory and an arithmetic circuit;

the memory, used for buffering the operation data of the operation circuit;

The arithmetic circuit is used to perform the method according to any one of claims 1 to 6 .
An electronic device, characterized by comprising a processor and a graphics processing apparatus according to claim 13, wherein the processor is used to instruct the graphics processing apparatus to generate the target image.
A computer-readable storage medium comprising instructions which, when run on a computer, cause the computer to perform the method of any one of claims 1 to 6.
A computer program product which, when run on a computer, causes the computer to perform the method of any one of claims 1 to 6.