KR20140078568A - Hidden surface removal in graphics processing systems - Google Patents

Abstract

An initial depth test stage (4, 13) of a graphics processing pipeline (1) is configured to transmit information on a fragment passing through an initial depth test to other stages (3, 4, 6, 12) of the pipeline. The other stages of the pipeline determine whether the processing of an arbitrary fragment which is currently processed can be stopped using initial depth test pass information.

Description

[0001] HIDDEN SURFACE REMOVAL IN GRAPHICS PROCESSING SYSTEMS [0002]

The present invention relates to the processing of computer graphics, and more particularly, to the removal of hidden surfaces in graphics processing.

As is known in the art, graphics processing generally involves rendering a graphics processing (rendering) output portion, such as a frame to be displayed, with a number of similar basic components (so-called "primitive" ]. These "primitives" are generally in the form of simple polygons such as triangles.

The primitive of the output, such as the frame to be displayed, is typically generated by an application program interface for the graphics processing system using a graphics drawing command (request) received from an application that requires graphics processing (e.g., a game).

Each primitive is typically defined by a vertex set at this stage and represented as its vertex set. Each vertex of the primitive has a set of related data (e.g., position, color, texture, and other attribute data) representing the vertex. This data is then used, for example, in rasterizing and rendering vertices (primitives associated with vertices) for display.

Once the primitive and its vertices have been created and defined, they can be processed by the graphics processing system to display, for example, a frame.

This process basically includes determining which of the sampling points of the array of sampling points covering the output area to be processed is covered by the primitive, and determining whether each sampling point represents a primitive at the corresponding sampling point (e.g., ≪ / RTI >

The rasterization process determines the sampling point (i. E., The (x, y) position of the sampling point to be used to represent the primitive in the rendering output, e.g., the frame to be displayed) that should be used for the primitive.

The rendering process then derives data such as the red, green, and blue (RGB) color values and the "alpha" (transparency) values needed to represent the primitives at the sampling points (i.e., "mask" each sampling point). This may involve applying a texture, mixing sampling point data values, etc., as is known in the art.

(In 3D graphic prints, the term "rasterization" is sometimes used to refer both to the switching and rendering of primitives to sample locations. However, here, "rasterization" refers to only converting primitive data to sampling point addresses .

These processes typically test one or more than one set of sampling points and then perform a sampling operation on a sampling point (covered by the primitive) within the corresponding primitive (being tested) and a graphics processing operation Quot; is performed by generating each set of sampling points that have been found to contain distinct graphic entities, generally referred to as "fragments " Thus, the covered sampling point is treated as a fragment to be used to render the primitive at the corresponding sampling point in effect. A "fragment" is a graphical entity that passes through the rendering process (the rendering pipeline). Each fragment that is generated and processed may provide a single sampling point or a set of multiple sampling points depending on, for example, how the graphics processing system is configured.

Thus, a "fragment" is essentially a set of primitive data (related to it) that is inserted into a given output space sampling point or points of a primitive. It may also include data for each primitive and other states required to mask the primitive at the corresponding sampling point (fragment location). Each graphic fragment may typically be the same size and position as the "pixel" of the output (e.g., output frame) (since the pixel is a singularity in the final display, One-to-one mapping "). However, there may be cases where there is not a one-to-one correspondence between the frame and the display pixel, for example a special form of preprocessing such as downsampling is performed on the rendered image before displaying the final image.

(Also, when multiple fragments from different overlapping primitives at a given location can affect each other (e.g., due to transparency and / or blending), the final pixel output may contain multiple or all fragments It can be influenced by the facts.]

Thus, there may be a one-to-one correspondence between the sampling point and the pixels of the display, but more typically there may not be a one-to-one correspondence between the sampling point and the display pixel, The downsampling can be performed on the rendered sample value to generate the sampled value. Similarly, for example, where multiple sampling point values from different overlapping primitives at a given location affect each other (e.g., due to transparency and / or blending), the final pixel output also has a plurality of overlapping It will depend on the sample value.]

In one known technique for graphics processing, generally referred to as "immediate mode" graphics processing or rendering, primitives are processed (rasterized and rendered) one by one when they are generated.

In this type of system, a primitive (its vertices) is provided on a first-come, first-served basis to the graphics system so that primitives are rendered in the order in which primitives are received.

Also, in graphics processing systems, it is known to use so-called "tile based" or "postponed" rendering. In a tile-based rendering, the entire render output, rather than the entire render output, is processed at one time, such as in virtually instant mode rendering, and the render output, e.g., the frame to be displayed, is split into a plurality of smaller sub- do. Each tile (sub-region) is rendered separately (typically one after the other), and then the rendered tile (sub-region) is recombined to provide a complete render output, e.g., a frame for display. In such a structure, the render output is typically subdivided into sub-zones (tiles) (typically, for example, squares or rectangles) that are formed at regular sizes, but this is not critical.

In immediate mode and tile-based rendering, the input to the rasterization and rendering process will typically include a list of graphical instructions to be executed by the graphics processor. This "instruction list" includes instructions that instruct the graphics processor to draw primitives, as is well known in the art, and instructions that instruct other graphics processes, such as rendering state changes, start and end tile instructions, .

In instant mode rendering, this command simply lists the instructions to be executed one after the other, whereas in tile-based rendering, the list can be divided into "tiles" and typically split (ie, separate from the instructions for other tiles It will list the commands for the tile).

One disadvantage of current graphics processing systems is that the predetermined sampling points (and thus the fragments and pixels) are covered several times when the output is processed for display, since the primitives are typically processed sequentially rather than in a full front-to-back order It is possible to be. This occurs when the received and rendered first primitive is later covered by the following primitive so that the rendered first primitive is virtually invisible at the corresponding pixel (s) (and at the sampling point (s)). Primitives can be overwritten several times in this manner, which typically results in multiple ultimate redundant rendering operations performed on each render output, e.g., frame, that is typically rendered. This phenomenon is generally referred to as "overdraw ".

The result of performing such ultimately redundant tasks includes reduced frame rate and increased memory bandwidth requirements (e.g., as a result of loading data for a primitive overwritten by a later primitive). All of which are undesirable and reduce the overall performance of the graphics processing system. These problems arise when the render output, such as the frame to be rendered, becomes larger and more complex (because there is more surface in the potentially visible field) and when programmable fragment shading is increased (programmable fragment shading is used The cost of covering the fragments of the network is relatively large).

The problem of "overdraw" can be significantly reduced by transmitting primitives to render in forward-backward order. However, other graphical processing requirements, such as the requirement of coherent access to resources such as textures, and the need to minimize the number of API calls per frame, generally require other desirable ordering requirements for primitives. Also, sufficient forward-backward alignment of the primitives before rendering may not be practical while still maintaining sufficient throughput of the primitives to the graphics processing unit. These and other factors mean that the forward-backward order of primitives for a given render output, e.g., frame, is generally not practically possible or desirable.

Thus, the amount of "overdraw" (the amount of surplus processing on the hidden surface) that is performed when processing a render output, such as a frame, for display (ie, to avoid rendering non-visible primitives and / A number of other techniques have been proposed to reduce < RTI ID = 0.0 >

It is known, for example, to perform the form of hidden surface removal before primitives and / or fragments are sent for rendering so that primitives or fragments etc. are obscured by already rendered primitives (in this case, And / or primitives need not be rendered). Such hidden surface removal may include initial blocking excerpts such as initial-Z (depth) and / or stencil, test process, as is known in the art.

For example, those structures that attempt to identify fragments to be intercepted by primitives that have already been processed before (and need not be processed accordingly) will result in a rendering pipeline. In these structures, for example, the depth value of a new fragment to be processed is compared with the current depth value for the fragment position in the depth buffer to know whether or not the new fragment is blocked. This can help avoid sending fragments that are blocked by already processed primitives through the rendering pipeline.

However, these "early" (before rendering) hidden surface removal techniques only consider new (e.g., primitive or fragment) fragments that have completed their processing (already rendered) when primitive primitive primitive primitives are tested Since the associated test data (Z-buffer, etc.) contains only data from fragments that have already been processed.

The Applicant therefore believes that there is still room for improved techniques for removal of hidden surfaces in a graphics processing system.

According to a first aspect of the present invention there is provided a computer program product comprising a rasterizer for rasterizing an input primitive to generate a graphic fragment to be processed and a fragment generated by the rasterizer to generate output fragment data, A method of operating a graphics processing pipeline, comprising: a plurality of processing stages including a renderer to process each graphic fragment, each graphics fragment having associated one or more sampling points,

Performing an initial excerpt test on at least one sampling point associated with a fragment generated by the rasterizer before the fragment is sent to the renderer for processing; And

If at least one sampling point passes the initial excerpt test, the fragment is forwarded for processing, and processing of other sampling points in the graphics processing pipeline is suspended as a result of the at least one sampling point passing the initial excerpt test The method comprising the steps of: determining whether the graphics processing pipeline is capable of operating.

According to a second aspect of the present invention there is provided a computer program product comprising a rasterizer for rasterizing input primitives to generate a graphics fragment to be processed, a renderer for processing fragments generated by the rasterizer to generate output fragment data, And an initial excerpt test stage that performs an initial excerpt test with respect to a sampling point associated with a fragment generated by the rasterizer prior to being sent to the renderer for processing, each graphical fragment comprising one or more sampling Point, and the graphics processing pipeline includes:

In response to at least one sampling point associated with a fragment generated by a rasterizer passing the initial extractive test, forwarding the fragment for processing, and processing of another sampling location within the graphics processing pipeline, And to determine if it can be stopped as a result of at least one sampling position passing through the graphical processing pipeline.

The graphics processing pipeline of the present invention may be implemented as an initial depth test or the like prior to the renderer stage of the graphics processing pipeline to extract graphical entities such as sampling points, fragments, and / or primitives prior to being processed by the renderer, Includes initial excerpts.

However, the present invention uses the results of sampling points that have passed the initial excerpt test to determine if processing of other sampling points processed in the graphics processing pipeline can be stopped. In other words, the present invention prolongs the effect of the initial excerpt test at or after the rasterization stage, thereby potentially affecting the excerpt sampling point of the primitive that has already been rasterized and transferred to the rest of the pipeline for processing.

This avoids the processing of sampling points for primitives that have already passed that test and are already in the pipeline and / or that have already been in the pipeline, rather than simply stopping the sampling point for new primitives whose results are to be rendered (e. G. ("To kill" This has the advantage, for example, that the processing of the sampling point in the pipeline for primitives that have already passed the initial excerpt test can still be stopped if the fragments of the latter primitive to be blocked occur before the processing is complete.

Thus, the present invention is capable of reducing or avoiding "overdraw" in situations where, for example, unlike prior art techniques, primitives and / or fragments are actually blocked by later primitives in the rendering order.

This effect can further reduce the extent to which the present invention is unnecessarily processed in the graphics processing pipeline, for example, when compared to conventional initial depth testing techniques. Moreover, it is not necessary to perform each sample or each fragment classification expensive of the samples / fragments before rendering occurs.

Indeed, a significant advantage of the present invention is that while providing the minimum cost increase across the "standard" initial depth test structure in that event by virtually no intervention when the provided primitive order is optimal (i.e., (And in this preferred embodiment, at least the hidden surface can be removed as long as all the primitives can be efficiently categorized in a cube-to-back order before rendering) ). The cost of using the present invention is also unrelated to the level of multi-sample anti-aliasing used, and its use with higher order multiple sample anti-aliasing is relatively inexpensive (and with higher order multiple sample anti-aliasing To make it cheaper to use.

The rasterizer of the graphics processing pipeline can be configured to operate in any suitable and preferred manner, such as in a known rasterization configuration, for example. As is known in the art, any sampling point (or sampling point) of an array of sampling points that covers an area of the output of the graphics processing pipeline that (at least in part) covers certain primitives, etc. received by the lasterizer Lt; RTI ID = 0.0 > set). ≪ / RTI > The rasterizer may be implemented by each set of multiple sampling points (e.g., sampling mask) determined to include sampling points covered by primitives (each) and / or by each set of sampling points covered by the set Lt; / RTI >

Each fragment generated by the rasterizer may represent a single sampling point, or a plurality of sampling points, as desired. In a preferred embodiment, each fragment represents a plurality, preferably four (2x2) sampling points.

A rasterizer may be configured to generate fragments one at a time, but in the preferred embodiment, multiple fragments may be generated at one time (simultaneously) (e.g., primitives cover spatially adjacent sampling points or sampling point sets). In this case, the rasterizer generates a plurality of sets of fragments, and the fragments in the set are preferably still individually processed by the fragment processing portion of the pipeline, such as a fragment shader. When the rasterizer simultaneously generates a plurality of fragments, the fragments maintain a "filled" rendering pipeline by contributing to the generation of backpressure.

In a particularly preferred embodiment, the rasterizer is configured to discard any patches that do not (at least partially) cover the primitive and then to render the patches or patches of the sampling points determined to be at least partially covered by the primitive Is a hierarchical rasterizer that operates to repeatedly test a primitive against a patch of predetermined, preferably selected, preferably a sampling point that is progressively smaller at a predetermined minimum patch size, to generate fragments or fragments. Each patch of the sampling point to be tested preferably corresponds to a fragment of integers such as 16 x 16, 8 x 8, 4 x 4 and / or 2 x 2 fragments.

The rasterizer preferably begins with a large patch of the render target area and tests whether the primitive is in the patch. If not, the entire patch is discarded and the next patch is tested (et al.). On the other hand, if the primitive is found to be in the patch (at least partially covering the patch), then the patch is preferably divided into four parts and the minimum patch size (in the preferred embodiment, Sub-patches "are tested in the same manner until they are reached (although they may be individual sampling points, individual fragments, or fragments of groups of different sizes, for example) corresponding to a fragment (e.g., corresponding to a fragment).

In this configuration, if the smallest patch size comprises a plurality of sampling points, the lasterizer preferably sets the individual sampling points of the final patch so that it knows that the sampling points are covered by the primitives and then generate the fragments accordingly Test.

If the fragments generated by the rasterizer are capable of being associated (and corresponding and representable) to a set of a plurality of sampling points, each such graphical fragment is preferably one of the sampling points in the set of corresponding sampling points Quot; is covered (e.g., by a primitive that is preferably sampled), i.e., in fact, a fragment is used in the set of corresponding sampling points to indicate which sampling point is used to render.

The information indicating whether the fragment covered the sampling point used to render is preferably related to or part of the fragment data for the fragment that passed through the renderer (such as RGB and alpha values for fragments). Preferably, for each sample location in the set of sampling points associated with the fragment, it is determined whether the sample location is covered, i.e., whether the fragment was actually used to render the sampling point (i.e., if the data is to be stored for that sampling point ) In the form of a coverage mask. Preferably, this coverage mask is in the form of a bitmap representing the sampling position. The rasterizer preferably generates a coverage mask.

The initial excerpt test used by the operation of the present invention may include any suitable such test, such as an initial interception test, a depth (Z) test, and / or an initial stencil test. In a particularly preferred embodiment, it includes an initial depth (Z) test (or tests). In a preferred embodiment, both the initial depth and the initial stencil test are included.

Any or all of the available initial excerpt tests (initial excerpt test stages) of the graphics processing pipeline can be configured (to trigger operation in the manner of the present invention) to operate in the manner of the present invention. If the graphics processing pipeline includes more than one initial excerpt test (initial excerpt test stage), preferably all the initial excerpt test stages may trigger an operation in the manner of the present invention. Thus, preferably, there are more than one initial excerpt test in the pipeline.

The initial extract test stage may operate on a patch (set) of a plurality of fragments. For example, if the Leicester can rasterize the primitives into a patch of a plurality of fragments, such a patch may be subjected to an initial excerpt test as a whole. In this case, the initial excerpt test is thus associated with a set of a plurality of fragments (i. E., A patch of a fragment is considered) and the performance of the initial excerpt test on at least one sampling point associated with the fragment is caused by the rasterizer (Patch) of a plurality of fragments that have been fragmented (this involves performing a subtest test with respect to at least one sampling point associated with the fragment, since in a set of a plurality of fragments Because it performs the initial excerpt test efficiently for all sampling points associated with the fragment).

Thus, in a preferred embodiment, the pipeline includes an initial depth (or initial depth and stencil) tester that commonly tests patches (sets) of a plurality of fragments. This test is preferably performed only for a plurality of fragments (sets) that are (fully) covered by the corresponding primitive, preferably using a range of depth values for the patches (sets) of the plurality of fragments.

Preferably, an initial "patch" extract, such as any patches (sets) of a plurality of fragments that pass the depth and / or stencil test, can trigger operation in the manner of the present invention.

The initial excerpt test may preferably and / or alternatively, and preferably also, operate a single fragment. Thus, the pipeline preferably includes an initial excerpt tester, preferably an initial depth (or initial depth and stencil) tester, which tests individual fragments. This test is preferably performed only for fragments that are sufficiently (fully) covered by the corresponding primitive, preferably using a depth value range or a single depth value for the fragment as a whole.

Preferably, this (single fragments) initial excerpt, such as any fragments that pass the depth and / or stencil test, can trigger operation in the manner of the present invention.

In a preferred embodiment, a single sampling point, which also includes sampling points that are less than the set of sampling points for which a given fragment is associated, also or alternatively and / or in the initial sampling test (there is an initial sampling test) and / (E.g., for two of the four sampling points associated with the fragment) in the set of sampling points. In this case, the initial excerpt test preferably works at a single (covered) sampling point. In this case, each sampling point has an associated depth value, i. E. There will be a depth value for each sampling point (which can be shared with other sampling points) used for the excerpt test.

Again, preferably, any sampling point that passes this sampling point early excerpt, e.g., depth and / or stencil test, can trigger operation in the manner of the present invention.

In a particularly preferred embodiment, the pipeline includes an initial excerpt test that tests a set of a plurality of fragments and / or individual fragments (with respect to what the operation of the method of the present invention can be triggered on), and an individual sampling point Lt; RTI ID = 0.0 > test < / RTI > about the operation of the method of the present invention can be triggered). This allows the present invention to generate a hidden surface removal event with a single fragment and / or sampling point granularity from the entire tile covering the primitive.

In a particularly preferred embodiment, the system includes a set of sampling points, fragments and / or a plurality of fragments (such as a set of sampling points, fragments and / or a plurality of fragments Patch) to an extent of the stored depth value associated with the location of the sampling point, fragment, or set of corresponding fragments (patches).

The depth value range is preferably stored for each patch of fragments that can be considered (extractively tested).

The initial excerpt test or tests themselves may be performed in any suitable and desired manner, e.g., in a normal manner known in the art and / or used in the graphics processing system. Tests can be a test that specifically tests the sampling point (or each sampling point), or has the effect of testing the sampling point (s) even if the sampling point (or each sampling point) is not specifically tested.

In a particularly preferred embodiment, the system (and preferably the rasterizer) is configured to determine the location of each of the sampling locations, the set of sampling locations, the fragments, the location of the fragments, Generates and / or stores a range of expected and / or expected depth values for a set of patches and / or fragment positions of the fragment, and the excerpt test or tests are performed on primitives and fragments generated by the rasterizer And the like, and is preferably used. These ranges of expected depth values should (and should) include all possible outcomes of the depth values for the patches, etc., preferably when the sampling points and fragments are processed by the graphics processing pipeline, Is updated when rasterization and rendering are performed using depth values and depth value ranges for individual sampling positions, fragments, patches of fragments,

The initial excerpt test or tests may be conducted as part of a rasterizer, for example, or after a rasterizer (but before the renderer), or in combination (e.g., there are more than one initial excerpt test). In a preferred embodiment, the tests or tests may be performed as part of the rasterization process and / or after the rasterizer, but before the rest of the graphics processing pipeline.

If the sampling points or points to be tested, or fragments or fragments, fail the initial excerpt test (e.g., turns out to be blocked), then the sampling point or points, or fragments or fragments, As well as "excerpts" from further processing in the pipeline.

This excerpt can be achieved (and provided) in any desired and appropriate manner. For example, if the excerpt test is for an entire fragment (or a set of a plurality of entire fragments), then preferably a fragment or a set of fragments may be used for processing (e.g., for rendering) (I.e., excerpted) through the line.

On the other hand, if the excerpt test is for a sampling point that is less than all sampling points associated with the fragment to be rendered, then preferably further processing of the corresponding sampling point (i.e., failed excerpt test) (By, for example, indicating that it is not covered in the coverage mask associated with the fragment), or in some other appropriate way, but the fragment is still in the "unexpressed" sampling point associated with the fragment (Via the pipeline).

If the at least one sampling point being tested passes the initial excerpt test, then the set of sampling points being tested (i.e., the fragments with which the sampling point is associated), fragments, or a plurality of fragments, (E.g., toward the renderer). However, in this event it is determined whether the processing of another sampling point in the pipeline can be stopped as a result of the sampling point passing the initial excerpt test (and the processing of the sampling point already in the pipeline is an initial excerpt test The processing of that sampling point is preferably stopped). ≪ / RTI >

In this regard, the process may operate at the sampling point level (resolution) (e.g., not for the entire fragment) and thus test and stop further processing of the individual sampling points associated with the fragments already in the pipeline. This may be particularly appropriate when the initial excerpt test tests individual sampling points and the process "chip away" at sampling points associated with the fragments in the pipeline (e.g., Quot ;, the entire fragment may be discarded at that point).

Likewise, the process may also or alternatively determine whether the processing of any fragments in the pipeline can be aborted if the entire fragment (or set of fragments) passes the initial excerpt test . ≪ / RTI > This may be particularly appropriate if the initial excerpt test is to test the fragments as well as or instead of individual sampling points.

Thus, in a preferred embodiment, the initial excerpt test involves testing a set of fragments and / or a plurality of fragments, and if the tested fragment or set of fragments passes the initial excerpt test, It is determined whether the test can be stopped as a result of a set of fragments or fragments that have passed the test.

In a preferred embodiment, a determination is made in the resolution of the entity in which the rendering pipeline operates, e.g. (and preferably) in a fragment.

Preferably, it is determined whether the processing of any one of the plurality of sampling points and / or fragments already in the pipeline can be stopped as a result of at least one sampling point and / or fragment (s) that have passed the initial extractive test do.

The determination of whether the processing of any other sampling point already in the pipeline can be discontinued can be based on any desired and appropriate criteria. In a particularly preferred embodiment, it is based on whether the sampling point (s) and / or fragment (s) that have passed the excerpt test are over-drawing (preferably blocking) the sampling points and / or fragments already in the pipeline (Because, if later sampling points (s) and / or fragments pass, for example, an initial depth test, they may be applied to the front of any sampling points and / or fragments that represent the same location (s) Because they indicate that there is a sampling point and / or a fragment (and thus blocks if it is opaque).

Thus, the determination of the sampling points and / or fragments that need not be further processed at the time of the event of the initial excerpt test "pass" event is preferably performed by later stages or stages of the graphics processing pipeline, (E.g., processing) any sampling points and / or fragments that are currently overdrawn by sampling points or points and / or fragments or fragments (if appropriate) that have passed the test.

This process may be performed in any suitable and preferred manner, but it is desirable to initially place one or some or all of the sampling points and / or fragments (e.g., (x, y)) that currently occupy the pipeline stage in the initial (X, y) position of the sampling point (s) and / or the fragment (s) that have passed the excerpt test.

If a sampling point (for the entire fragment) is considered, this can be done by comparing the "actual" position of the corresponding sampling point, but in the preferred embodiment the corresponding sampling position and the position of the fragment indicating the relative position of the sampling point in the fragment (E.g., based on the coverage mask associated with the fragment).

If fragments are considered, this is preferably done by comparing the location of one or several or all of the fragments currently occupying the pipeline stage to the location (s) of the fragment (s) that have passed the initial excerpt test.

When a plurality of sets of fragments are considered (passed the initial excerpt test), this is preferably done by setting the location of one or some or all of the fragments currently occupying the pipeline stage to a set of a plurality of fragments (Region) covered by the fragment in the region of interest.

(I.e., having the same (x, y) position) at the sampling point (s) and / or fragment (s) that passed the initial excerpt test and (if appropriate) The processing of the current sampling point and / or fragment may (optionally) be stopped and preferably paused (e.g., experiencing other criteria to stop processing of the sampled point being satisfied).

In a preferred embodiment, the determination of whether the processing of the sampling points and / or fragments can be discarded from further is subject to additional checks and / or criteria. Other characteristics of the fragment (or sampling point) that are preferably in the pipeline that are potentially discarded (e.g., blocked) are such that the fragment (or sampling point) is still to be processed for any other reason before stopping the process First checked. This check preferably includes determining whether the fragment (or sampling point) is required for blocking questions (with the active blocking query attached) or for other side effects (in this case, not discarded).

Thus, in a particularly preferred embodiment, the graphics processing pipeline is configured to selectively stop processing of sampling points and / or fragments or fragments already in the pipeline in response to at least one sampling point associated with a fragment that passes the initial excerpt test .

The operation of determining whether the processing of any sampling points and / or fragments in the pipeline can be stopped when the sampling point or fragments or fragments pass the initial excerpt test can be performed in any suitable and desired manner.

Preferably, the sampling point or event of fragments or fragments that pass the initial excerpt test is associated with the relevant information, such as the sampling point at which the test point passed or the location of the fragment (s) For example, a later stage of the processing pipeline, using another piece of information, for example, a later stage, to evaluate whether or not the processing pipeline can have a suspended process.

If the test is for an entire fragment, then this location information preferably includes the (x, y) location (s) of the fragment (s) as discussed above. If the test is for a set of a plurality of fragments, the location information preferably includes a range of (x, y) positions covered by the fragments of the set of corresponding fragments (again, as mentioned above) do. If the test is for a sampling point, the location information preferably includes the sampling point (s) along with an indication of the sampling point location for the fragment (preferably in the form of a coverage mask as discussed above) (X, y) position of the relevant fragment.

Thus, in a particularly preferred embodiment, the graphics processing system is configured to display information about at least one sampling point (and / or a corresponding fragment) that has passed the initial excerpt test if at least one sampling point associated with the fragment passes the initial excerpt test At least one stage of the graphics processing pipeline is configured to transmit to at least one, preferably another (and preferably later) stage of the graphics processing pipeline, wherein at least one stage of the graphics processing pipeline includes at least one sampling point and / Or broadcast information associated with the fragment to determine whether processing of any fragments and / or sampling points associated with fragments in the current stage can be discontinued.

As discussed above, most preferably the initial excerpt test comprises an initial depth test, and / or at least one stage of the graphics processing pipeline includes sampling point (s) and / or fragments Or fragments are overdrawn by the sampling point (s) and / or fragments that have passed the initial extractive test, and whether any of the sampling points and / or fragments in the current stage are overdrawn using any of such sampling points Or fragments, to selectively discontinue further processing of overdrawn sampling points and / or fragments.

As discussed above, most preferably, the information transmitted to the stage (s) of the graphics processing pipeline includes the location (s) of the sampling point (s) and / or fragment (s) that have passed the initial excerpt test , And / or at least one stage of the graphics processing pipeline, using broadcast location information associated with the sampling point (s) and / or fragment (s) that have passed the initial excerpt test, And / or to determine whether the fragment occupies a location in the same target (s) and / or the same render target (usage buffer) as the fragment, e.g., the tile being processed, that passed the initial extractive test, Any sampling points occupying positions in the same render target as point (s) and / or fragments and / It is configured to selectively stop the further processing of the tree.

The stages or stages of the processing pipeline in which it is determined whether any sampling points and / or fragments need not be further processed in the event of an initial excerpt test "pass" . ≪ / RTI > The stage preferably includes at least one later stage of the graphics processing pipeline (i. E., The stage following the initial excerpt test and / or the rasterizer). The processing pipeline can be partitioned into as many stages as desired for this purpose.

In one preferred embodiment, this stage is a renderer of the graphics processing pipeline (this decision is made by the renderer). For example, the renderer may or may not be processed as a single stage that operates in the manner of the present invention as a whole, and is divided into a plurality of distinct stages, each of which operates independently of each other. Thus, in a preferred embodiment, the initial excerpt test "pass" event information is sent to a (at least) renderer of the graphics processing pipeline and / or to a portion or portions of the renderer ).

The stages or stages of the processing pipeline in which it is determined whether any sampling points or fragments need to be processed further in the event of the initial excerpt test "pass" test are preferably also or alternatively [the initial excerpt test (E.g., extracting an initial fragment (and / or a fragment of a fragment) that still receives the lyserization (which is later than the initial excerpt test pipeline) and / or (still not fully lysed) To include other stages of the pipeline in which fragments can be usefully extracted, such as an initial excerpt test.

In a particularly preferred embodiment, a plurality of fragments (and preferably all fragments in the stage) and / or sampling points may be tested in parallel. This facilitates taking the advantageous effect of an initial excerpt test, for example, which can test a patch of a plurality of fragments at once. Preferably, the structure is such that the pipeline stage is able to discard the sampling points and fragments at the same rate that the initial excerpt test pass event can generate a potential excerpt opportunity.

Sampling points and / or fragments that are determined to be capable of halting processing may have their processing suspended and / or omitted in any desired and appropriate form. Preferably, this is done by marking so identified sampling points and / or pips as "killing " (invalidated), and the associated stage is not killing (invalidated) before the sampling points and / . This avoids and / or stops any unwanted processing of these sampling points and / or fragments.

In the case of a sampling point, the sampling point is preferably marked as invalid by appropriately setting its value in the coverage mask for that fragment.

When a fragment is considered in its entirety, each fragment is associated with a "killed" ("invalid") bit (e.g., as part of the associated fragment data) indicating that the fragment need not be processed . In one preferred embodiment, this is done. The processing stage checks, for example, the invalid bits of each fragment that it accepts for processing. This bit can also be set if testing of individual sampling points ultimately invalidates all sampling points associated with the fragment.

Alternative structures such as having a fragment queue with a validity tag that acts like a cache to release the queue (cache) line when the validity tag of the fragment is set can be used instead or also as desired.

Although any "killed" fragment may be retained in the pipe (but not processed), in a preferred embodiment, the step of removing the invalid fragment from the pipeline is taken. This is preferably done by providing the pipeline with one or more consolidation stages that can be operated (receive) to remove any invalid fragments from the pipeline. Such a consolidation stage may include, for example, a first-in first-out (FIFO) queue that operates to remove any invalid fragments (clear any holes) when the fragments work through the FIFO.

Applicants have recognized that the more sampling points and especially the fragments that can be operated to "kill" (invalidate) the invention, the more advantageous. Thus, in a preferred embodiment, the pipeline is configured to increase the number of fragments in the pipeline that can be operated in the manner of the present invention.

In one preferred embodiment, this is accomplished by passing through the fragment at one or more points in the pipeline (e.g., by delaying pipeline operation) so as to provide more time for operation in the manner of the present invention to invalidate the fragment before point of the pipeline By introducing retardation into the poem.

In a particularly preferred embodiment, the number of fragments that can be subjected to the operation of the method of the present invention is increased by increasing the number of fragments that may be in the pipeline after the initial test run stage (s). This may instead introduce delays at the fragment throughput as discussed above or as discussed above.

The number of fragments in the pipeline can be increased as desired, for example by making the pipeline longer. In a particularly preferred embodiment, this is done by including one or more queues (queue stages) in the pipeline, and the fragments must pass before reaching the next processing stage. A plurality of queues may be included in the pipeline. In a preferred embodiment, a single queue is added to the pipeline. The queue length is preferably selected to optimize the efficiency of operation in the manner of the present invention.

If a delay and / or queue is included in the pipeline, it is preferably included before the more processing concentration stages of the processing pipeline, such as a fragment shader (if any). This has the advantage that the delay or queue can operate to reduce the number of fragments to be processed reaching a more processing-intensive stage of the pipeline. Thus, if the processing pipeline has a gearing point, if the relative speed of the processing of the fragment after the gearing point is slower than the speed of the (substantially production) processing of the fragment before the gearing point, then the delay and / Is positioned before the gearing point in the line.

Thus, in a preferred embodiment, the graphics processing pipeline includes a queue that is located before the renderer (fragment shader) of the graphics processing pipeline and through which the fragments must pass. Similarly, the queue is preferably located after the initial excerpt test stage or stages of the graphics processing pipeline. Preferably, the graphics processing pipeline includes an initial excerpt test stage at and / or within the rasterizer, and a queue stage between the initial excerpt test stage and the renderer (rendering stage).

If the pipeline includes a consolidation stage as discussed above, it is preferably placed after the queue and / or delay stage and before the subsequent fragment processing stage for the same reason.

If the pipeline includes a queue, the initial extract test pass event information is preferably sent to the queue (s).

In a particularly preferred embodiment, once the initial excerpt test passes, any data buffer, such as a depth buffer for the acceptance data on the test and / or test, as well as any other data buffer, for example, and preferably sampling points ) Or associated data value (s) associated with the fragment or fragments, e.g., depth value (s). This means that, for example, rather than effectively indicating the state of the depth buffer at the end of the pipeline (e.g., only when the depth buffer is updated when the fragment is exited at the end of the pipeline) For example, depth, the current state of the buffer. This also means that any new fragments that have been generated will be more accurate than the data that is placed in the depth buffer when any previous fragment completes its depth test, e.g., based on a depth value and / , E. G., Depth, value, when the < / RTI >

The operation of the inventive scheme (potentially "killing" other fragments, etc., in the graphics pipeline) is performed with respect to each and every fragment (associated with the sampling point passing the initial excerpt test) that passes the initial excerpt test , But in a particularly preferred embodiment, the operation is performed with respect to a fragment that satisfies only the selected fragment, preferably the definite selected, preferably the predetermined criterion (and through the initial excerpt test (s)).

The criteria for a fragment that triggers the operation of the scheme of the present invention after passing the initial excerpt test (s) may be any selected and appropriate criteria. In a preferred embodiment, the criterion is that the fragment has a full RGB recording mask; The fragment has a blending function that depends on the previous RGBA value; The shader program for the fragment is not read from the tile buffer; The fragment is completely opaque; And one or more and preferably all of the fragments are not constrained (by the application programmer) to perform late depth updates.

In a particularly preferred embodiment, the operation of the present invention in which an event of a fragment passing an initial excerpt test or tests is used to determine if any fragments can be discarded in the processing pipeline is performed only with respect to a fully opaque fragment. Thus, if a fragment or a set of fragments that pass the initial excerpt test is a transparent fragment (i.e., a fragment that is not completely opaque) or a set of fragments or fragments are preferably still passed for processing, An initial excerpt test pass event associated with a set of fragments or fragments is not used to determine if any fragments already in the processing pipeline can be discarded,

This simply disables the potential fragments or sampling point "killing" operations of the invention for fragments that are required to receive alpha testing and alpha for coverage testing (and equivalently, more transparent fragments and / Point simply allows that the farther fragments and / or sampling points are still not visible at the final output).

The operation of the method of the present invention is preferably performed with respect to and for each set of opaque fragments or opaque fragments that cause the rasterizer to (potentially) process by the renderer.

The initial excerpt test (s) (excerpt test stage (s)) may be configured to operate in the manner of the present invention in any suitable and desired manner. In a preferred embodiment, the excerpt test stage performs the excerpt test, and if the excerpt test is passed and the fragment meets any desired criteria (such as opaque), then the pass event and the relevant required information are sent to the appropriate stage of the graphics pipeline To " transmit "to the depth buffer (s), and to update depth information, e.g., in the depth buffer (s).

The stages or stages of the graphics processing pipeline that respond to the initial excerpt "pass through " event can be configured to do so in any suitable and desired manner. Preferably, the stage is associated with an actor that is responsible for the fragment at the stage and receives the initial excerpt test "pass" information, and is associated with any fragment < RTI ID = 0.0 > and / or & To identify the sampling point, to suspend the fragment and / or the sampling point, and / or to prevent any unnecessary further processing thereof.

In some embodiments, the graphics processing pipeline includes one or more memory and / or memory devices that store data described herein and / or facilitate software for performing the processes described herein, and / Communication. The graphics processing pipeline may also communicate with a host microprocessor, and / or a disproller for displaying an image based on data generated by the graphics processor.

The renderer of the graphics processing pipeline must be capable of rendering (shading) graphics fragments that are acceptable to generate the desired output graphic fragment data as is known in the art. May include any suitable and desired rendering element, and may be constructed in any suitable and desired manner. Thus, it may include a fixed function rendering pipeline, including one or more fixed function rendering stages, such as texture mappers, blenders, fogging units, and the like. In a preferred embodiment, the renderer includes a fragment shader (i.e., a shader pipeline) (i.e., a programmable pipeline stage that can be programmed and programmed to perform a fragment shading program in a fragment to render). The present invention may be particularly advantageous when fragment shading is used because fragment shading may be a relatively expensive process, and such a more efficient initial removal of the hidden surface is particularly advantageous when fragment shading is performed.

As those skilled in the art will appreciate, the renderer may be configured to cause the rendered frame data to be written to an output buffer, such as a frame buffer, in an external memory, preferably for use (e.g., to display the frame on the display) Handles fragments that it accepts.

The present invention can be used regardless of the type of output that a graphics processing system can be provided with. Thus, for example, a render output may be used that is intended to form an image (frame) for display (e.g., on a screen or printer) (in one preferred embodiment in this case) display. However, the present invention also relates to the case where the render output is not intended for display, for example when the render output is a texture used to cause the graphics processing system (in the "render on texture & May be used in the case where the graphics processing system to be used is any other type of data array.

The various functions of the present invention can be performed in any desired and appropriate manner. For example, the functions of the present invention may be implemented in hardware or software as desired. Thus, for example, various functional elements, processing stages, and "means ", of the present invention may be embodied in a variety of forms, such as appropriately configured dedicated hardware elements or processing circuits and / or programmable hardware elements or processing circuits, A processor or processors, a controller or controllers, a functional unit, a circuit, processing logic, a microprocessor structure, etc., that may be operable to perform the functions described herein.

Further, as will be appreciated by those skilled in the art, the various functions, etc. of the present invention may be copied and / or performed in parallel on a given processor. Equally, the various processing stages can share a reasoning circuit and the like if desired.

The present invention may be applied to any suitable form or configuration of graphics processing system, graphics processor, and renderer having a "pipelined" structure. The graphics processing pipeline may include any suitable and desired processing stage or the like that the graphics processing pipeline typically includes. In a particularly preferred embodiment, the graphics processing system is a tile-based graphics processing system. Similarly, in a preferred embodiment, the graphics processing system is a multi-core system (i. E., Includes a plurality of graphics processing cores).

Accordingly, the present invention extends to a graphics processor and a graphics processing platform that includes an apparatus that operates in accordance with any one or more of the aspects of the invention described herein. With respect to any hardware necessary to perform the specific functions discussed above, such graphics processors may include any one or more, or any, of the useful functional units otherwise included in the graphics processor.

It will also be appreciated by those skilled in the art that all of the described aspects and embodiments of the invention may suitably include any one or more or all of the preferred and optional features described herein.

The method according to the invention can be carried out at least in part using software, for example a computer program. Thus, viewed from a further aspect, the present invention provides computer software that when installed in a data processing means is specifically adapted to perform the methods described herein, and computer software that when executed on a data processing system, Or code means adapted to perform all steps of the method. The data processing system may be a microprocessor, a programmable FPGA (Field Programmable Gate Array), or the like.

Thus, the present invention may be suitably implemented as a computer program product for use in a computer system. Such an implementation may include a series of computer readable instructions fixed on a type medium such as a non-volatile computer readable medium, such as a diskette, CD ROM, ROM, or hard disk. A set of computers that can be communicated to a computer system via a modem or other interface device, including, but not limited to, type media including optical or analog communication lines, or intangible wireless techniques including but not limited to microwave, infrared, Readable instructions. A series of computer readable instructions embodies all or part of the functionality previously described herein.

Hereinafter, a number of preferred embodiments of the present invention will be described, by way of example only, with reference to the accompanying drawings.

Figure 1 schematically illustrates an embodiment of a graphics processing system according to the present invention.

Hereinafter, a number of preferred embodiments of the present invention will be described. These embodiments will be mainly described with reference to the use of the present invention in a graphics processing system. However, as described above, the present invention can be applied to other pipelined data processing systems including an initial "data entity" excerpt test.

Figure 1 schematically illustrates a graphics processor 1 that can operate in accordance with the present invention.

Figure 1 shows the main elements and pipeline stages of the graphics processor 1 in connection with the operation of this embodiment. As will be appreciated by those skilled in the art, there may be other elements of the graphics processor that are not illustrated in FIG. It should also be noted that FIG. 1 is only schematic and that, for example, in practice, the illustrated functional units and pipeline stages share important hardware circuitry even though they are schematically illustrated as separate stages in FIG. Further, each of the stages, elements and units of the graphics processor as shown in FIG. 1 may be implemented as desired and accordingly include suitable circuitry and / or processing logic, etc. to perform the required operations and functions I will know.

The graphics processing system shown in FIG. 1 is a tile-based system. The graphics processor 1 will thus generate tiles of the rendering output data array, such as the output frame to be generated, as is known in the art. (The present invention applies equally to other systems, such as an immediate mode rendering system, as described above.) The output data array is typically intended to be displayed on a display device such as a screen or printer, as is known in the art Output frame, or may include a "render to texture" output, such as, for example, a graphics processor.

Figure 1 schematically illustrates a pipeline stage after creation of a graphics primitive (polygon) 2 for input to a rasterization process. At this point, the graphic data (vertex data) undergoes a transformation and lighting operation (not shown), and a primitive setup stage (not shown) A setup is made so that the primitive is rendered in response.

1, this part of the fragment processing pipeline of the graphics processor 1 includes a rasterization stage 3, an early hierarchical ZS (depth and stencil) test stage 4, , A rendering stage in the form of an initial ZS (depth and stencil) stage 13, a fragment shading stage 6, and a late ZS (depth and stencil) test stage 7 do.

The rasterization stage 3 operates to rasterize the primitives that make up the rendering output (e.g., the image to be displayed) into discrete graphics fragments for processing as is known in the art. To this end, the rasterizer 3 receives the graphics primitives 2 for rendering and rasterizes the primitives to the sampling points to create graphic fragments with appropriate locations (representing the appropriate sampling locations) to render the primitives do. In this embodiment, each graphic fragment generated by the rasterizer 3 represents a plurality (usually four) of sampling locations (in this regard). Each graphics fragment is associated with a coverage mask indicating a sampling point representing a fragment of a plurality of sampling points actually being used for rendering (i.e., actually covered by the corresponding primitive) .

In this embodiment, the rasterizer 3 is a patch of a sampling point (i. E., An array of sampling points that are rasterized into a 2x2 group of fragments) progressively smaller with a minimum patch size corresponding to a 2x2 group of fragments (At least in part) of the primitive to discard any patches that do not cover the primitive. Each patch to be tested corresponds to a given set of fragments.

This is done by starting with a large patch of the rendering target area by the rasterizer 3 and testing whether the primitive is inside the patch. Otherwise, the entire patch is discarded, the next patch is tested, and so on. On the other hand, if the primitive is found to be in the patch (at least partially confirmed to cover the patch), the patch is sub-divided into four parts, and each "sub- It is tested until this.

Once the minimum patch size is reached (i.e., a patch of a 2x2 fragment covering at least partially the primitive is identified), the rasterizer 3 tests the individual sampling points in the final patch to determine if the sampling point is covered by the primitive . The rasterizer 3 then generates and outputs the individual fragments for the leathers corresponding to the sampling points identified as being covered by the primitives.

The rasterizer 3 includes a bitmap-like coverage mask with respect to each fragment, which covers whether the corresponding sampling location for each sampling location in the set of sampling locations associated with the fragment (i.e., Is used for rendering the corresponding sampling point (i.e., whether or not the related data should be stored for the corresponding sampling point)).

Of course, other rasterization arrangements would be possible.

As shown in FIG. 1, the rasterizer 3 may have an initial "hierarchical" depth Z associated therewith and a stencil testing stage 4. This hierarchical depth and stencil testing stage 4 performs an "initial" depth and stencil test to check whether the patches generated by the rasterizer 3 are cullable.

To this end, each patch of the sampling point (of the fragment) generated by the rasterizer 3 is sent to the initial hierarchical depth and stencil test stage 4, and at that stage, to the patch of the sampling point (of the fragment) A Z (depth) test is performed to determine whether or not the patch can be discarded in the corresponding stage. To this end, the initial hierarchical depth and stencil tester 4 derives a range of depth values for each patch received from the rasterizer 3 by acquiring the appropriate depth samples for the patch, (Depth) range covered by the patch and a sampling (fragment) position covered by the patch in order to attempt a determination as to whether it is intercepted or overdrawn by fragments and sampling points (e.g., in the pipeline or already rendered) And compares the depth value range that has already been derived and stored. At the same time, an initial stencil test is performed.

If the patch being tested fails initial depth and stencil testing, it is discarded from any further processing.

If the patch being tested passes the initial depth and stencil test, it is returned to the rasterizer 3 for further sub-division into a small "sub-patch " Subsequently, each "sub-patch" is made to return to the initial depth and stencil tester 4 for testing until a minimum patch size is obtained, and so on.

When performing depth and stencil tests on patches of a plurality of sampling points received from the rasterizer 3, the initial hierarchical depth and the range of depth values used by the stencil test stage 4 are stored in the depth and stencil buffer 5 . The range of depth values (and stencil values) is dependent on the depth of each patch size and position represented by the buffer (basically for each patch size and location that can be created for the tile for which the rasterizer 3 is being processed) And the stencil buffer 5, respectively.

The depth value range stored for each patch is initially set to a default value for each patch, or, if the value can be determined, set to the expected depth value range for the patch. (In some configurations, the range of possible depth values that a primitive for a tile may have is known in advance. This may then be used to provide a range of expected depth values for that patch to the depth buffer 5) The depth value range is determined by the initial hierarchical depth and the patches and / or sampling points tested by the stencil test stage 4, the initial depth and stencil test stage 13 and the late depth and stencil test stage 7, It will be updated as you pass the stencil exam.

Storing the expected range of depth and depth values for the patches at the plurality of sampling point locations (and fragments) of the tile being rendered in the stencil buffer 5 means that the initial fragments that already exist in the pipeline have the same location, Or stencil test has not yet been completed (eg, no experience of initial hierarchical depth and stencil test (4) and initial depth and stencil test (13), and late depth and stencil test (7) ) Also means that the initial hierarchical depth and stencil tester 4 can still perform depth and stencil tests with respect to the patches of the sampling point locations generated by the rasterizer 3. This is because, with respect to the initial fragment, if the depth test has not yet been performed, it is possible to use the range of the expected depth value to determine the possible outcome of the depth test (e.g.). This may then be used to (potentially) discontinue the processing of the initial fragment existing in the pipeline in the manner of the present invention, with the initial hierarchical depth and stencil test (4) if the initial fragment has not yet experienced the actual depth or stencil test Let's do it.

Storing and testing a range of depth values for a patch at a sampling point location means that a large patch at the sampling point location can easily receive the initial depth and stencil test (which, depending on the stored range, Outside, for example, whether it passes solely the initial hierarchical depth and the stencil test is determined by the test). This facilitates broadcasting of the initial depth and stencil test pass events, as will be further described below, and the event is (potentially) stopping the processing of the fragments of the entire group within the patch region within one processing cycle , Instead of potentially interrupting the processing of each fragment one by one). ≪ / RTI >

The initial hierarchical depth and stencil test stage 4 is configured to operate in a suitably conservative manner as is known in the art.

Once the minimum patch size (the patch of the 2x2 fragment in the present embodiment) is reached, the rasterizer 3 is then applied to the initial hierarchical Z and stencil test stages 4 through the patches passing through the remainder of the graphics processing pipeline for processing And a sampling point corresponding thereto).

The first part of this process is to cause each of the fragments issued (output) by the rasterizer 3 to be subjected to initial depth and initial depth and stencil tests at the stencil test stage 13. This initial depth and stencil test stage 13 performs depth and stencil tests on the individual (covered) sampling locations associated with the fragments issued by the rasterizer 3 (i.e., per- sampling point resolution).

To this end, the initial depth and stencil tester 13 uses the depth and per-sampling position depth and stencil values stored in the stencil buffer 5. Thus, the depth and stencil buffer 5 can be adjusted to suit the respective sampling point represented by the buffer (for each sampling point location in the tile being processed) in addition to the per-patch depth value ranges Depth (Z) values and stencil values. These values are stored in the depth and stencil buffer 5 when the initial depth and the sampling points tested by the stencil test stage 13 and the late depth and stencil test stage 7 pass their respective depth and stencil tests.

The depth and stencil buffer 5 are two distinct buffers (having the same physical memory), one buffer for storing the depth range per patch and another buffer for storing the depth value per sample in this embodiment . Other configurations are of course possible.

The initial depth and stencil test stage 13 is configured to operate in a suitably conservative manner as is known in the art.

The initial depth and the fragments passing through the stencil test stage 13 (i.e., the fragments having the initial depth and at least one associated sampling location passing through the stencil test stage 13) quot; queue "12 (whose function and purpose are discussed in more detail below) to the fragment shading stage 6 (the renderer).

(Initial depth and fragments that failed stencil testing stage 13 are discarded by initial depth and stencil testing stage 13 as is known in the art.)

The fragment shading stage 6 performs the appropriate fragment processing (rendering) operation on the fragment it receives by itself, so that the processing of the fragment allows for the appropriate fragment (for display of the fragment) Data and the like.

Such fragment processing may be accomplished by executing a fragment shader program on a fragment, applying a tensor to the fragment, blending, fogging, or both, for generation of the appropriate fragment data, Or other suitable fragment shading processing such as applying a different operation to a fragment or the like. In this embodiment, the fragment shading stage 6 is in the form of a shader pipeline (programmable fragment shader), but if desired, other configurations may be used to replace or replace the fragment shading unit of a fixed function.

(I.e., the fragment data for a fragment issued from the fragment shading stage 6 is not stored in the tile buffer 5) to determine whether the sampling point indicated by the drawn fragment is to over draw the current stored value in the tile buffer 5 (E.g., to determine whether fragment data should be replaced or modified in the tie buffer (s) of a fragment that has already been rendered) (e.g., if the fragment has not experienced an initial Z and stencil test) There is a "late" fragment Z and a stencil test stage 7 that performs the end of the pipeline depth test for the shaded fragments (the covered sampling points associated with the shaded fragments).

To this end, the late depth test stage 7 compares the depth value of the issued (and related) fragment from the fragment shading stage 6 with the depth value (per sampling position) stored in the depth buffer 5 for that sampling position do. The depth value for the sampling point passing through the late depth test (7) is suitably recorded in the Z-buffer (5) for updating as is known in the art.

This late fragment depth and stencil test stage 7 also performs any necessary "late" alpha and / or stencil tests on the fragments.

The fragment passing through the late fragment test stage 7 is subjected to any remaining operations required for the fragment, such as blending with a frame buffer, a dither, etc. (not shown).

Finally, the output fragment data values may be stored in a suitable tile buffer (not shown) that stores appropriate values, such as the color for each sampling point that the buffer represents (for each sampling point of the tile being basically processed) (8).

Once each tile is processed, the data is passed from the tile buffer 8 to the main memory (not shown) (e.g., to a frame buffer in main memory) for storage, and the entire render output The next tile is processed until enough tiles have been processed to produce a frame (image), and so on.

Of course, other configurations for the fragment processing pipeline are possible.

The above description describes the basic rasterization and rendering process of the graphics processing system shown in Fig. The operation of the graphics processing system shown in Fig. 1 according to an embodiment of the present invention will now be described.

In accordance with the present invention, this embodiment is used to determine whether the processing of another fragment in the graphics processing pipeline can be discontinued (i. E., Because a later fragment is completely overdrawn by a new fragment at the same position, Quot;) or the result of a pass through an initial depth test (4) or a pass through an initial depth test (13).

To this end, as shown in FIG. 1, the initial hierarchical depth and stencil test stage 4 and the initial depth and stencil test stage 13, when each of the patches or fragments of the fragments passes the initial disparity test, (As indicated by dashed lines 9, 10, 11, and 14 in FIG. 1) of the initial dispatch test "pass" event, as well as passing the patch or fragment from the line to the next stage .

In a preferred embodiment, when the patch of the sampling point passes the initial hierarchical depth test (4), the initial hierarchical depth and stencil test stage (4) are located at the (x, y) To the queue 12, the fragment shading stage 6, the rasterizer 3, and the initial hierarchical depth and stencil stage 4 itself (as shown by dotted line 11 in Figure 1) (9, 10, 11). As discussed below, these stages of the graphics processing pipeline utilize the location information to assess whether any fragments currently being handled can have processing to be suspended.

The initial hierarchical depth test pass event is sent to the hierarchical depth and stencil stage 4 and the rasterizer 3 in this embodiment because the rasterizer 3 and the initial hierarchical depth and stencil test stages 4 Is operated in an iterative manner as discussed above, so that if the hierarchical depth and stencil test stage 4 are determined to have already generated and later over-written, such as a patch at the sampling location, overdraw, There may still be patches of sampling points that are still subjected to gridding and initial hierarchical depth and stencil testing processes.

Of course, when transmitting the initial hierarchical depth test event to another stage of the graphics processing pipeline, the initial hierarchical depth (Z) and stencil test stage 4 may also be used for patching the sampling points that have passed the initial hierarchical depth test And to update the depth and stencil buffer 5 using an associated depth value range and / or stencil value. This makes the initial hierarchical depth and stencil tests more efficient, for example, by allowing the buffer to record up to the date of the depth value range of the patches that have undergone (and passed) the initial hierarchical depth and stencil test (4).

This update of the depth buffer or the like is performed in an appropriately conservative manner, avoiding any risk that the update in the processing of the patch or the like may cause an error.

Thus, in this embodiment, when the fragments pass the initial depth test 13, the initial depth and stencil test stage 13 are positioned at (x, y) positions covered by the fragments passed through the test To the queue 12 and the fragment shading stage 6 (as shown by dotted line 14 in FIG. 1). As discussed below, these stages of the graphics processing pipeline again utilize the location information to assess whether any of the fragments currently being handled can have processing to be aborted.

Again, of course, if the initial depth test pass event is transmitted to another stage of the graphics processing pipeline, the initial depth Z and stencil test stage 13 will have an associated depth for the sampling point associated with the fragment that passed the initial depth test Value and / or stencil values to update the depth and stencil buffer 5. This makes the initial and late depth and stencil tests more efficient, for example, by allowing the buffer to record up to the date of the depth value range of the sampling point that has undergone (and passed) the initial depth and stencil test 13 (and passed).

Broadcasting of the excerpt test "Pass" event and updating of the depth buffer and the like are not performed for all patches and fragments passing through the initial hierarchical depth test 4 and the initial depth test 13 in this embodiment, Lt; RTI ID = 0.0 > Fragment < / RTI > This is to prevent accidental dispatching of fragments in the pipeline if later fragments pass the initial depth test.

This embodiment includes an "auto-sensing" configuration within the initial hierarchical depth and stencil test unit 4 and the initial depth and stencil test unit 13 to determine whether an initial depth test ≪ / RTI >

This automatic detection configuration has the following requirements to broadcast (propagate) the initial depth "pass" event: the new patch or fragment must have passed the initial z / s test (and the initial z / / s < / RTI >test); The new patch or fragment must have a blend function with the full rgb write mask (z / stencil already recorded), not depending on the previous rgba value; The shader for a new patch or fragment can not be read from the tile buffer, and the new patch or fragment must not have a forced late update.

This embodiment uses a "auto-sensing" configuration to trigger the delivery of the initial depth test pass event information with respect to patches or fragments passing through the initial hierarchical depth test (4) or the initial depth test (13) The present embodiment can also use the status bit as a contrasting configuration. The status bits are used to turn off the " auto-detect "configuration and instead to initial dispatch test pass event information initiated by setting (with or without setting) additional (e.g., . ≪ / RTI > This may allow the application programmer, for example, to set whether a dispatch test pass event operation is to be performed (by setting the appropriate status bits).

The initial hierarchical depth and stencil test stage (4) and initial depth and stencil test stage (3) perform disparate testing and, if the test passes and the patch or fragment meets the required criteria, Includes combined test and update logic that may be operative to perform dispatch testing such as "broadcasting" information to the appropriate stage of the graphics pipeline or updating depth information in, for example, the depth buffer (s).

In response to the initial depth depth & stencil test stage 4 and the initial depth test "pass" position information that is broadcached by the initial depth and stencil test stage 13, the stage of the information processing pipeline, To determine whether any fragments containing the current request are no longer being processed as a result of the initial discrete test "pass" event. This process passes the (x, y) position of the entire fragment occupying the current pipeline stage to the initial hierarchical depth and the initial excerpt test passed by the stencil test stage 4 or the initial depth and stencil test stage 13 (S) and / or (x, y) position (s) of the patch (identifying the actual depth and any fragments within the current stage that are blocked by a patch or fragment that has passed the stencil test) ≪ / RTI >

Processing of any current fragment having the same (x, y) position as the patch or fragment (s) that passed the initial excerpt test is then paused and is also adapted to some other criteria for stopping the processing of the satisfied fragment . In particular, whether a fragment in a pipeline that is potentially to be discarded (i.e., blocked) should still be processed for some other reason, such as having a side effect that is still required in association with an outstanding block query . If the fragment being blocked does not have a blocking query that is still active attached to it (and there is no other required side effect), the fragment is discarded (its processing is aborted), but the active blocking query (or any other still Side effects required), they are not discarded (i.e., processing continues). This confirmation is performed by the stage of the graphics processing pipeline.

In order to reduce the risk of fragments being erroneously discarded from further processing, the determination of fragments that are no longer to be processed in the event of an initial disparate test "pass" event is performed in a suitably conservative manner.

Each stage of the graphics processing pipeline tests all of the fragments in the stage simultaneously. This allows the pipeline stage to discard fragments at a rate such that the initial dispatch test pass event can cause a potential dispatch possibility.

A fragment in a post processing stage causes its processing to be aborted by " killing "(invalidating) the fragment so identified. To facilitate this, each fragment has its associated "killed" bit (e.g., as part of the associated fragment data), the kill bit does not need to be processed (and can be discarded) ). The pipeline processing stage is configured to identify the kill bits of each fragment they receive for processing (and thereafter do not process or process fragments accordingly).

Alternative configurations, such as having a fragment query with a valid tag that works like a cache releasing a query (cache) line for use with a fragment's invalid tag, may be used instead or together if desired.

Each stage of the graphics processing pipeline to which the initial dispatch test pass event is delivered has a corresponding agent responsible for all fragments in its local domain (i.e., within the scope of the stage or part of the processing stage). Each agent maintains fragment related information in its local domain and marks the fragment as invalid in order to avoid and / or stop unnecessary processing of fragments in response to the initial dispatch test pass event received by the agent Lt; / RTI > The agent is configured to simultaneously test all of the fragments in its local domain.

As shown in FIG. 1, in this embodiment, the graphics processing pipeline includes a queue 12 through which fragments located in front of the fragment shader 6 of the graphics processing pipeline must pass. The queue 12 is configured to be able to maintain one full set of tile sizes of fragments, but other arrangements are of course possible.

The cue 12 is used to determine the number of fragments that may be present in the pipeline after the earliesting test stage (i.e., the depth according to the rank and the stencil tester 4 and the early depth and the stencil tester 13) , Thereby increasing the number of fragments that can be operated in the manner of the present invention. The use of the queue 12 can significantly increase the likelihood that only ultimately visible fragments will reach (and thus be processed by) the fragment shading stage 6 that comes after the queue 12. This is advantageous because fragment shading is typically a relatively expensive process per fragment and, consequently, the smaller the number of fragments entering the fragment shader, the more desirable.

The fragments entering the queue 12 exit the queue in the same order, while the "kill" fragment triggers the freeing of resources when leaving the queue.

From the above it can be seen that the present invention provides a mechanism for further reducing the (ultimately unnecessary) throughput of the hidden surface that can occur in the pipeline graphics processing system, at least in the preferred embodiment. Moreover, the arrangement of the present invention will not intervene when the rendering order is optimal for a traditional rendering pipeline (thus providing a minimal cost compared to an existing rendering pipeline configuration as an optimal rendering order) Optimized state, in which case at least in the preferred embodiment of the present invention, the inverted fragments and hidden surfaces can be removed at points that may be efficient for hidden surface removal, such as in the per-sample per rendering or fractional processing per fragment . If the content to be rendered is such that the classification algorithm is not able to easily detect the best approach to classification (eg, primitives have intersecting or overlapping depth ranges), this can be done more efficiently than classification.

The technique of the present invention is independent of the level of multi-sampled anti-aliasing used, so that higher order multi-sampled anti-aliasing can be used at very low cost.

Claims (20)

A renderer that processes a fragment generated by the rasterizer to generate output fragment data, and a renderer that processes the fragment generated by the rasterizer to generate output fragment data. CLAIMS What is claimed is: 1. A method of operating a graphics processing pipeline comprising a plurality of processing stages, each graphic fragment having one or more sampling points associated therewith,
Performing an initial excerpt test on at least one sampling point associated with a fragment generated by the rasterizer before the fragment is sent to the renderer for processing; And
If at least one sampling point passes the initial excerpt test then the fragment is forwarded for processing and processing of other sampling points in the graphics processing pipeline is suspended as a result of at least one sampling point that has passed the initial excerpt test Determining whether the graphics processing pipeline can be executed.
The method according to claim 1,
And performing an initial excerpt test on both a single sampling point and a patch of a plurality of fragments.
The method according to claim 1,
Further comprising storing a range of expected depth values of a set of sampling positions for a set of primitives prior to rendering the set of primitives.
4. The method according to any one of claims 1 to 3,
Determining whether the processing of another sampling point in the graphics processing pipeline can be suspended as a result of at least one sampling point that has passed the initial sampling test may include determining whether the sampling point and / Comparing the position to a position of at least one sampling point that has passed the initial excerpt test.
4. The method according to any one of claims 1 to 3,
The step of determining whether the processing of another sampling point in the graphics processing pipeline can be suspended as a result of at least one sampling point that has passed the initial extractive test further comprises determining if another sampling point is still to be processed normally And checking other properties of the other sampling points to know if the sampling points are different.
4. The method according to any one of claims 1 to 3,
If the at least one sampling point associated with the fragment passes the initial excerpt test, transmitting the location of the sampling point or fragment past the test to at least one processing stage of the graphics processing pipeline,
Wherein at least one processing stage of the graphics processing pipeline utilizes broadcast location information to evaluate whether any of the sampling points or fragments that are currently processing can have processing to be suspended.
4. The method according to any one of claims 1 to 3,
Performing an initial excerpt test on at least one sampling point associated with a fragment generated by the rasterizer before the fragment is sent to the renderer for processing; And
If at least one sampling point passes the initial excerpt test then the fragment is forwarded for processing and processing of other sampling points in the graphics processing pipeline is suspended as a result of at least one sampling point that has passed the initial excerpt test The step of determining,
Performing an initial depth test on at least one sampling point associated with a fragment generated by the rasterizer before the fragment is forward transmitted through the pipeline for processing, and / or performing at least one fragment on the pipeline Performing an initial depth test on at least one fragment generated by the rasterizer before being forward transmitted through the rasterizer;
If at least one sampling point or at least one fragment passes the initial depth test, the fragment or at least one fragment is forward transmitted for processing and the at least one sampling point or at least one fragment To at least one processing stage of the graphics processing pipeline,
The at least one processing stage of the graphics processing pipeline uses at least one sampling point that has passed the initial depth test or a broadcast information location associated with the at least one fragment so that any sampling points or fragments in the current stage At least one sampling point or at least one fragment that has passed the initial depth test if there is any such sampling point or fragment, and at least one sampling point or at least one fragment that has passed the initial depth test Thereby selectively stopping further processing of sampling points or fragments occupying the same position.
The method according to claim 6,
An initial excerpt pass event information is sent to one or more of an initial excerpt, a rasterizer, and a renderer of a graphics processing pipeline.
4. The method according to any one of claims 1 to 3,
If the initial excerpt test is passed by at least one sampling point, updating the data buffer to accept data relating to the initial excerpt test having any relevant data value for at least one sampling point that has passed the initial excerpt test ≪ / RTI > further comprising:
As a graphics processing pipeline,
A renderer for rasterizing input primitives to generate a graphics fragment to be processed; a renderer for processing the fragments generated by the rasterizer to generate output fragment data; and a rasterizer for processing the fragments before the fragments are transmitted to the renderer for processing. Wherein the graphics processing pipeline includes a plurality of processing stages including an initial test run stage that performs an initial test run with respect to a sampling point associated with a fragment generated by the firearm, each graphic fragment having associated one or more sampling points, ,
In response to at least one sampling point associated with a fragment generated by the rasterizer that has passed the initial extractive test, forward the fragment for processing, and processing of other sampling points within the graphics processing pipeline may be used to perform an initial excerpt test And to determine if it can be stopped as a result of at least one sampling point passing through the graphical processing pipeline.
11. The method of claim 10,
An initial excerpt test stage for performing an initial excerpt test on a patch of a plurality of fragments generated by the rasterizer; And
And performs an initial excerpt test on a single sampling point associated with a fragment generated by the rasterizer.
11. The method of claim 10,
Wherein the graphics processing pipeline is further configured to store a range of expected depth values for the set of sampling locations for the primitive set prior to rendering the primitive set.
13. The method according to any one of claims 10 to 12,
The graphics processing pipeline may be configured to process other sampling points within the graphics processing pipeline by comparing the location of the sampling points and / or fragments currently occupying the pipeline stage with the locations of at least one sampling point that has passed the initial sampling test Is capable of being discontinued as a result of at least one sampling point that has passed the initial excerpt test.
13. The method according to any one of claims 10 to 12,
Wherein the graphics processing pipeline is configured to check other properties of the other sampling points to know if another sampling point should still be processed before stopping the processing.
13. The method according to any one of claims 10 to 12,
The graphics processing pipeline,
If the at least one sampling point associated with the fragment passes the initial excerpt test, sending the location of the sampling point or fragment past the test to at least one processing stage of the graphics processing pipeline,
Wherein the at least one processing stage of the graphics processing pipeline is configured to use broadcast location information to assess whether any sampling points or fragments that are currently processing can have processing to be suspended.
13. The method according to any one of claims 10 to 12,
The initial excerpt test stage performs an initial depth test on the sampling points associated with the fragments generated by the rasterizer before the fragments are sent to the renderer for processing,
The graphics processing pipeline,
In response to at least one sampling point associated with a fragment generated by a rasterizer passing an initial depth test, forwarding the fragment for processing and providing information about the location of the at least one sampling point that has passed the initial depth test To at least one processing stage of the graphics processing pipeline,
Wherein at least one processing stage of the graphics processing pipeline uses the broadcast position information associated with at least one sampling point that has passed the initial depth test to determine if any sampling point in the current stage has passed at least one sampling And to selectively stop further processing of sampling points occupying the same position as at least one sampling point that has passed the initial depth test if any such sampling points are present, Pipeline.
13. The method according to any one of claims 10 to 12,
The initial excerpt test stage performs an initial depth test on a fragment or a patch of a plurality of fragments generated by a rasterizer before a patch of the plurality of fragments is sent to the renderer for processing,
The graphics processing pipeline,
In response to a patch of fragments or fragments generated by a rasterizer passing an initial depth test, a patch of fragments or fragments is forward transmitted through a pipeline for processing and a patch of fragments or fragments that have passed the initial depth test To at least one processing stage of the graphics processing pipeline,
At least one processing stage of the graphics processing pipeline uses broadcast location information associated with a patch of fragments or fragments that have passed the initial depth test to determine whether any fragments in the current stage have passed the initial depth test or patches of fragments And optionally stop further processing of fragments that occupy the same position as a patch of fragments or fragments that have passed the initial depth test if any such fragments are present.
16. The method of claim 15,
Wherein the initial excerpt pass event information is sent to one or more of an initial excerpt test stage, a rasterizer, a queue, and a renderer of the graphics processing pipeline.
13. The method according to any one of claims 10 to 12,
The graphics processing pipeline,
When the initial excerpt test is passed by at least one sampling point associated with a fragment generated by the lister fire, the data buffer accepting data about the initial excerpt test is sent to an arbitrary < RTI ID = 0.0 > Using associated data values of the graphical processing pipeline.
A computer program comprising computer software for performing the method according to any one of claims 1 to 3 when the program is executed in a data processing means.

Images