JP5483893B2 - Method and apparatus for processing computer graphics - Google Patents

Description

  The present invention relates to computer graphics processing and, more particularly, to a method and apparatus for performing anti-aliasing when processing computer graphics.

  Although the present invention will be described with particular reference to processing 3D graphics, as will be appreciated by those skilled in the art, the present invention is equally applicable to processing 2D graphics.

  As is known in the art, 3D graphics processing usually simplifies 3D graphics processing operations by first dividing the displayed scene into multiple similar basic components (so-called “primitives”). It is executed by making it possible to execute. These “primitives” are usually in the form of simple polygons (polygons) such as triangles and are usually described by defining their vertices.

  If the scene to be displayed is divided into multiple graphics primitives, the graphics primitives are further divided into separate graphic entities or graphic elements, usually referred to as "fragments", as is known in the art. Then, an actual graphics processing operation (rendering operation or the like) is performed on these fragments. Each such graphics fragment represents and corresponds to a given one or more positions within the primitive, in effect data for that position or positions (such as color and depth values). ) Set.

  Each graphics fragment (data element) can correspond to a single picture element in the final display (since a pixel is a singular point in the final picture to be displayed) , Because there can be a one-to-one mapping between the “fragments” operated by the 3D graphics processor and the pixels in the display). However, there is a one-to-one relationship between “fragments” and “pixels”, for example, when certain forms of post-processing, such as downscaling, are performed on the rendered image, especially before displaying the final image. There may be no correspondence.

  Thus, two aspects of commonly performed 3D graphics processing are the "rasterization" of graphics "primitive" (or polygon) position data into graphics fragment position data (i.e., each primitive in the displayed scene (Determining the (x, y) position of the graphics fragment used to represent the), and then “rendering” the “rasterized” fragment for display on the display screen (ie, fragment coloring) , Shading, etc.).

  (In 3D graphics literature, the term “rasterization” or “rasterization” is sometimes used to mean both primitive conversion to fragment and rendering. However, in this document, “rasterization” "Is used to refer only to the conversion of primitive data to fragment addresses.)

  The rasterization process basically involves determining, for an array of sampling points that are overlaid on the scene to be displayed, which of the sampling points in the array the primitive concerned covers. Next, fragments with the appropriate (x, y) position (s) are generated to render the sampling points found to be covered by the primitive.

  The rendering process basically involves deriving the data necessary to display each fragment. Such data typically includes the red, green, and blue (RGB) color values of each fragment (which basically determines the color of the fragment on the display) and the so-called `` alpha '' (transparency) value of each fragment. including.

  As is known in the art, this data typically performs an individual rendering process (step) for each fragment (i.e., the data for that fragment) one after another in a linear or pipelined form. Is derived by Thus, for example, each fragment is initially assigned an initial RGB value and alpha value, for example based on the (x, y) position of the fragment and the color and transparency data recorded for the vertex of the primitive to which the fragment belongs. . Operations such as texturing, fogging, and blending are then performed sequentially on the fragment data. These actions change the initial RGB and alpha values set for each fragment and are appropriate to allow each fragment to display it correctly on the display screen after the last processing action. Have a set of RGB and alpha values.

  One of the problems encountered when processing graphics for display (when displaying computer-generated images) is that the displayed image is quantized to a separate pixel location on the display being used, for example a monitor or printer It is to be done. This limits the resolution of the displayed image and can create unwanted visual artifacts, for example if the resolution of the output display device is not high enough to display smooth lines. These effects are generally referred to as “aliasing”.

  Figure 1 shows the effect of such aliasing. The left side of FIG. 1 shows the image to be drawn, and the right side shows the actual image to be displayed. As can be seen, the desired smooth curve of the white object actually has a zigzag appearance on the display. This is aliasing. (In FIG. 1, each square represents one pixel of the display, and the cross represents a point at each (x, y) pixel location at which the color value of the pixel location is determined (sampled). Pixel A of is drawn completely white because the color sampling point at that pixel location is contained within the white object, but in Figure 1 only the sample cross of the important pixel is drawn, but in practice Note that all pixels are sampled).

  All aliasing artifacts (which may be visible to the naked eye) should be able to be removed by using a sufficiently high resolution display. However, the resolution of electronic displays and printers is usually limited, so many graphics processing systems attempt to remove or reduce aliasing effects using other techniques. Such a technique is usually referred to as an anti-aliasing technique.

  One known anti-aliasing technique is referred to as supersampling or oversampling.

  In such an arrangement, there are multiple sampling points (positions) per pixel in the final display, and separate color samples can be used for each individual sampling point (covered) (e.g., each as a separate fragment). Taken by rendering sampling points). The effect of this is that a different color sample is taken for each pixel sampling point covered by one primitive during the rendering process.

  This means that multiple color samples are taken for each pixel location in the display (one for each pixel sampling point, because separate color values are rendered for each sampling point). . These multiple color samples are combined into a single color for the pixel when the pixel is displayed. This has the effect of smoothing or averaging the color values from the original image at that pixel location.

  Figure 2 shows the supersampling process. In the example shown in FIG. 2, four sample points are determined for each pixel in the display, and separate color samples are taken for each sample point during the rendering process (each such sample is therefore Can effectively be considered a "sub-pixel", where each pixel in the display is composed of four such sub-pixels). The four color value samples (sub-pixels) for a given pixel are then combined (down-filtered) and the final color used for the pixel in the display is the four color samples taken for that pixel. Appropriate average value (blend) of colors.

  This has the effect of smoothing the displayed image and makes aliasing artifacts less noticeable, for example by surrounding the aliasing artifacts with shades in the middle of the colors. This can be seen in Figure 2, where pixel A now has two "white" samples and two "black" samples, so it is 50% "white" in the displayed image. Set. In this way, the pixels near the edge of the white object are blurred to create a smoother edge, for example based on how many samples are found on each side of the edge.

  Supersampling processes screen images at a resolution much higher than what is actually used on the display, and then scales and filters the processed image to the final resolution before it is displayed ( Downsampling). This has the effect of providing an improved image with reduced aliasing artifacts, but requires higher processing power and / or longer processing time. This is because the graphics processing system actually has to process as many fragments as samples (e.g., for 4x supersampling (i.e. 4 samples are taken per pixel location)) Requirements are four times higher than without supersampling).

  Thus, other anti-aliasing techniques have been proposed that have less processing requirements than full supersampling while providing some improvement in image quality.

  One common such technique is referred to as “multi-sampling”.

  In the case of multi-sampling, multiple sampling points are also tested pixel by pixel to determine whether a given primitive covers the sampling points when the image is rasterized into fragments (at the rasterization stage). Determined. Thus, the sampling point coverage of a primitive in a multi-sampling system is determined in a manner similar to a “super-sampling” system (thus the position of the outer geometric edge of a primitive is still effectively “super-sampling” in a multi-sampling system. "Sampling" (oversampling)).

  However, in the rendering process of a multi-sampling system, all sampling points of a given pixel covered by the primitive in question will have the same single common set of fragment data (e.g. depth values, color values, etc.) Assigned (rather than each having its own separate set of fragment data as in the case of supersampling).

  Thus, in multi-sampling, multiple samples are still taken for each pixel that makes up the final display, but separate color values are determined for each sample when rendering a “pixel” (for a full supersampling system). Rather than as), a single color value is determined and applied to all samples of pixels found to belong to the same object in the final image. In other words, multi-sampling calculates a single color value for a given pixel of a given object in the scene, and that color value is applied to all samples (subpixels) of the pixels covered by that object. (Reused) (unlike supersampling where separate color values are determined for each sample).

  Because only a single color value is used for multiple samples of a given pixel, multisampling is less processing intensive than supersampling and can therefore allow faster processing and performance than supersampling. . However, the edges of the object are still sampled at a higher resolution, but the color is not, so there is a degradation in the quality of the displayed image compared to supersampling.

  Regardless, many graphics processing systems use multi-sampling anti-aliasing techniques. This is because multisampling is generally appropriate (and without multisampling or supersampling at all) in the rendered image, without the significant extra processing and computational burden associated with full supersampling. This is because it can provide improved anti-aliasing compared to

  However, the Applicant now understands the shortcomings of existing multi-sampling graphics processing arrangements. This disadvantage is associated with a process called “alpha test” used in many graphics processing systems.

  As is known in the art, many graphics processing systems effectively use a property commonly referred to as “alpha” or “alpha value” to represent the transparency (or other) of the rendered object. . In effect, graphics vertices and fragments are associated with, for example, so-called alpha values, which are similar to the color (red, green, blue) values associated with vertices and fragments, but instead Represents the “transparency” of an object such as a vertex or fragment.

  The alpha value of a given fragment value is derived, for example, from the alpha value defined for the vertices of the primitive to which the fragment belongs, derived from the texture applied to the fragment, or the fragment shader applied to the fragment ( derived from shader (pixel shader) program calculations.

  A common use of alpha values in graphics processing is for "bill-boarding", such as rendering a repeating pattern of backgrounds, such as vegetation in a displayed scene. The alpha value can be used to effectively apply such features to the scene as a texture, which can be less costly than defining a primitive, for example, each of the leaves of the tree.

  Such processing is typically performed by performing a so-called “alpha test” during the rendering process. An alpha test is usually a predefined step in the rendering pipeline that typically compares the alpha value associated with the rendered fragment to the threshold alpha or reference alpha value defined for the scene and the alpha test. Then leaving or discarding the fragment based on the comparison. In other words, the alpha test uses the defined threshold alpha value or reference alpha value to leave or discard the fragment that is being rendered (make sure the fragment is written or not written to the tile or frame buffer) for).

  Applicants have further realized that the result of performing an alpha test when a scene is rendered can introduce edges into the displayed scene. An edge or line can be created, for example, where the alpha value intersects the threshold value compared in the alpha test.

  For example, if an alpha test reference value effectively defines one or more lines across the displayed scene, it means that a given fragment of primitive (for example, has a given alpha value) Can be discarded on one side, but left on the other side of the line. Similarly, if the alpha value associated with a fragment changes incrementally across the surface of the primitive, it also effectively produces a line across the primitive, leaving the fragment on one side of the line and the opposite of the line On the side, fragments may be discarded.

  Thus, these alpha test processes can effectively cause one or more new edges to exist on or within the primitive when the primitive is displayed (where such alpha test Note that the “edge” introduced by is not present in the rasterization stage and is not introduced, but then only occurs during the rendering process when an alpha test is performed).

  In addition, Applicants therefore have anti-aliased such edges introduced by alpha testing in the same way that all other edges are desired to be anti-aliased, such as primitive geometric outer edges. I understood that it is desirable.

  However, in the case of a multi-sampling graphics processing arrangement, as described above, when a fragment is rendered, a single set of fragment data (e.g., color values (R values, G values, B values) and (Alpha value) is derived and used for all sample locations of the pixels covered by a given primitive. Thus, a sampling point for a given pixel can only be associated with a single alpha value, and that alpha value is used for all sample locations for that pixel.

  In other words, in a multi-sampling graphics processing arrangement, only a single alpha value is derived that is commonly used for all samples of a pixel. Thus, when the alpha test is run, each sample has the same alpha value, so either all samples are discarded or all samples are not discarded, and in effect that pixel is alpha The result of the test is either left as a whole or discarded.

  Applicants have understood that this result causes either the entire pixel to be preserved or discarded when the alpha test is performed. Furthermore, this means that the alpha test is effectively performed at pixel level resolution, i.e. every pixel.

  The effect of this is that all edges in the image introduced by the alpha test are not processed in an oversampled (supersampled) form and are therefore not anti-aliased (oversampling (supersampling during the rasterization mentioned above). (As opposed to geometric outer primitive edges that are processed in a sampled form).

  Thus, the Applicant has realized that even in the multi-sampling graphics rendering process, the edges introduced by the alpha test are not anti-aliased and therefore do not look very good.

  (This problem tends not to occur in a fully supersampled graphics processing arrangement, in which case each “sample” effectively has its own color and alpha values. Therefore, alpha testing is performed at a higher supersampled resolution anyway (and therefore anti-aliased), but as mentioned above, supersampling is always desirable or possible And in many cases a multi-sampling graphics processing arrangement is preferred as a trade-off between quality and processing workload).

  Accordingly, Applicants believe that there remains room for improvement over multi-sampling graphics processing systems, particularly with respect to alpha test processing in multi-sampling graphics processing arrangements.

According to a first aspect of the present invention, a method for processing graphics primitives of a displayed image comprising:
Determining whether a graphics primitive covers a sampling point for each set of sampling points of a plurality of sampling points;
Generating a set of graphics fragments to render primitives for display, each graphics fragment corresponding to a set of multiple sampling points found to contain the sampling points covered by the primitive Defining a set of fragment data to be used for the sampling points of the set of sampling points found to be covered by the primitive, and
Rendering the graphics fragment generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Performing an alpha test on one or more fragments as part of the rendering process,
Generating an individual alpha value for each covered sampling point to which the fragment corresponds;
A method is provided that is performed for each covered sampling point by performing an alpha test using the individual alpha values generated for the sampling point.

According to a second aspect of the invention, a system for processing graphics primitives of a displayed image comprising:
Means for determining whether a graphics primitive covers a sampling point for each of a plurality of sets of sampling points of a plurality of sampling points;
A means of generating a set of graphics fragments to render a primitive for display, with each graphics fragment corresponding to a set of multiple sampling points found to contain the sampling points covered by the primitive Means for defining a set of fragment data used for sampling points of a set of sampling points found to be covered by a primitive;
Means for rendering the graphics fragments generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Means for performing alpha testing on one or more fragments as part of the rendering process, and means for performing alpha testing
Means for generating individual alpha values for each covered sampling point to which the fragment corresponds;
And a means for performing an alpha test using the individual alpha values generated for the sampling points individually for each covered sampling point.

  In the present invention, the rendering process manipulates (renders) graphics fragments, each corresponding to a set of multiple sampling points of the displayed image (each set of sampling points is typically as described above, for example). Corresponding to one pixel in the final display).

  The effect of this is that a given fragment has a common single set of fragment data that is used for all sampling points of the set of sampling points to which that fragment corresponds (and is going to be used to render it). Is to define and provide. In other words, the present invention is a multi-sampling graphics processing arrangement.

  However, when alpha tests are performed on fragments as part of the rendering process, a single alpha value and alpha value comparison test is used for the entire fragment, as is the case with prior art multi-sampling systems. Rather, in the present invention, an individual alpha value is generated for each sampling point covered by the fragment to which it corresponds (which is going to be used for rendering), and then an alpha test is performed for each sampling point covered. It is executed individually.

  The effect of this is that the alpha test uses, for each (covered) sampling point, individually (separately) with respect to it, using the individual alpha values generated for that sampling point, i.e. fragments (multiple It is to be performed at the resolution (level) of that sampling point rather than the overall resolution (level) of the set of sampling points.

  This only keeps all of the sampling points of a fragment (of a set of sampling points) together as a result of an alpha test, or discards all together, as in a prior art multi-sampling arrangement, for example. Rather than being able to do so, it is possible to keep or discard the sampling points of the fragments (of a set of sampling points) individually as a result of the alpha test.

  This is especially true in the present invention, despite the fact that the rendering process is a “multisampled” arrangement rather than operating in a fully supersampled form, but still in effect with alpha testing. It means that it can be performed in a manner similar to supersampling (ie, using multiple individual samples per pixel).

  Thus, in effect, the present invention allows (supports) multiple alpha samples per fragment (and thus per pixel of the display) without the need for a fully supersampled system. Thus, the present invention is introduced by alpha testing without the need to have a completely “supersampled” rendering process (and thus without the large workload increase associated with a fully supersampled system). Allows performing anti-aliasing on edges.

According to a third aspect of the present invention, a method for performing an alpha test in a graphics rendering system, wherein the rendered graphics fragments are each a plurality of sampling points of a displayed image covered by a primitive. Are each initially associated with a single alpha value used for the fragment, and the method can be used to test the fragment alpha test,
Generating an individual alpha value for each sampling point covered by the fragment;
A method is provided that includes, for each of the covered sampling points, performing an alpha test using the individual alpha values generated for the sampling points.

According to a fourth aspect of the present invention, a system for performing alpha testing in a graphics rendering system, wherein the rendered graphics fragments are each a plurality of sampling points of the displayed image covered by the primitive. Are each initially associated with a single alpha value used for the fragment,
Means for generating individual alpha values for each sampling point covered by the fragment of interest;
A system is provided that includes, for each sampling point covered, means for performing an alpha test using the individual alpha values generated for the sampling point.

  The set of sampling points taken for the displayed image (and thus associated with each fragment to be rendered) can be selected as desired. As is known in the art, each set of sampling points (and thus each sampling point) represents a different position (x, y position) in the displayed image (the relative positions of the sampling points in each set are the same). (Although it will usually be the same)).

  As is usually the case, when an image is displayed on an output device having a display that includes a plurality of pixels, each set of sampling points is preferably a sampling point of a given pixel (pixel location) of the display. Corresponds to a set of sampling points for a portion of a pixel of the set or display (eg, subpixel). In the latter arrangement, groups of multiple sets of sampling points preferably constitute the entire set of sampling points for one pixel of the display. In these arrangements, each fragment effectively renders fragment data for a given pixel in the display.

  The set of sampling points can represent (cover) the entire area of the displayed image, or, for example, can represent (and cover) only a portion of the entire displayed image. The latter arrangement is, for example, in a tile-based rendering system where separate parts (tiles) of an image (such as a 16x16 pixel tile) are rendered sequentially and then combined to display the final image. Should be used. In this case, multiple sets of sampling points representing the desired tile (portion) of the image are used to process the primitive, and the process should be repeated for other tiles of the image, if necessary. .

  Each set of sampling points includes multiple sampling points (ie, covers multiple sampling locations in the image). The actual number of sampling points can be selected as desired, but 4 is a preferred number.

  The pattern of sample points and the (relative) position (sampling pattern) within each set of sampling points can be selected as desired. Any known suitable anti-aliasing sampling pattern can be used, for example, ordered grid supersampling. Most preferably, a rotated grid supersampling pattern is used. This is because it provides a better sampling effect as is known in the prior art. Thus, each sample point preferably has a unique x and y coordinate in the image.

  In one preferred embodiment, each set of sampling points used to sample an image for a given primitive is the same (i.e., the same number and pattern of sampling points and the same relative position of the sampling points). Use). In this case, the set of sampling points is the same for each fragment.

  In another preferred embodiment, the set of sampling points used to sample the image for a given primitive is, for example, with respect to the number of sampling points and / or the sampling pattern or relative position used for each set of sampling points. Can be changed, and / or different. Most preferably, the set of sampling points can be different between the fragments used to render a primitive.

  In one preferred embodiment, each fragment used to render a primitive corresponds to a different set of sampling points. In such an arrangement, in effect, only a single fragment is generated and used to render the sampling points of each set of sampling points in common, and each fragment is commonly (of different sampling points). ) Renders the sampling point (s) of the set.

  The set of graphics fragments generated to render a primitive must contain enough fragments to properly render the primitive for display. Thus, for example, if it is known that a portion of a primitive is not actually seen in the final display, it should not be necessary to generate a fragment for that portion of the primitive. Equivalently, even if fragments have been generated for a primitive, it is preferred that not all fragments that are not actually seen in the final image are rendered (for example, as known in the art Can be assessed by using an early depth (z) -test).

  The fragment data determined and stored for each fragment and sampling point can be any suitable such data. The data must include at least suitable color data and / or transparency data, such as RGB and alpha values, to allow at least the display pixels to be properly displayed, for example. (It should be understood that references to “color data” in the document include appropriate gray codes or similar data, such as those used for monochrome or black and white displays).

  For at least three-dimensional graphics processing, the fragment data determined and stored preferably also includes the depth (Z) value of the fragment (and thus of the one or more sample locations of interest).

  Other fragment data such as so-called stencil data can also be determined and stored (preferably determined and stored) as appropriate (and desired).

  The fragment data to be rendered must be stored in a suitable fragment data array, as is known in the art. This array must represent, for example, a two-dimensional array of fragment locations that can be suitably processed to display a 2D array of pixels, for example, as is known in the art. The array of fragment data may correspond to, for example, an array of sample locations for the displayed image.

  The alpha value generated for each (covered) sampling point to which a fragment corresponds, used in the alpha test process of the present invention, can be generated in any desired suitable manner.

  Note that in the present invention, individual alpha values are generated for each sample point. In other words, the alpha value is generated separately for each (related) sample point, and the alpha value generation process is performed separately for each sample point (e.g., defining whether each sample point is initially assigned to the fragment) Instead of simply assigning the assigned alpha value).

  Thus, each sample point tends to have its own alpha value generation process and has a generated alpha value for it that is different from the other sampling points to which the fragment corresponds, preferably (In some cases, the alpha value generated for each sample point may be the same depending on, for example, how the alpha value changes across the primitives). Thus, in the preferred embodiment, the alpha value generated for each sampling point is not the same as the alpha value generated for the other sampling points to which the fragment corresponds.

  In a particularly preferred embodiment, the individual alpha value of a sampling point is the alpha value at each sampling point from one or more alpha values associated with that fragment and / or associated with other fragments to be rendered. Generated by estimation. For example, if a fragment is already associated with a given alpha value (e.g., defined for it at the beginning of the rendering process), that fragment's sampling point used in the alpha test process of the present invention. The alpha value of is preferably generated (estimated), at least in part, by using the alpha value defined for the fragment.

  Thus, in a particularly preferred embodiment, the individual alpha value (s) of a fragment's sampling point (s) are determined using the (single) alpha value initially defined for that fragment during the rendering process. Generated.

  In a particularly preferred embodiment, the generated alpha value is preferably defined for the alpha value defined for the fragment and one or more adjacent fragments, preferably directly adjacent fragments of the fragment. Generated using an initial alpha value defined for multiple rendered fragments, such as one or more alpha values.

  In one preferred embodiment, the alpha value of a 2 × 2 block (2 fragment width × 2 fragment height block) of the fragment containing that fragment generates (estimates) the individual alpha value for each sampling point. (Eg, preferably by using a bilinear filtering process or the like). Thus, preferably the initial alpha value defined for the four fragments is used to generate the individual alpha values for the sampling positions.

  Of course, other arrangements are possible. For example, the more initial alpha values defined for a fragment used in the alpha value generation process, the more accurate the alpha value estimate for a given sampling point (but on the other hand, The estimation process can be more processing intensive). For example, the originally set alpha value of a 3 × 3 block of fragments can be used. For example, if desired, it is possible to use alpha values defined for fragments that are further away from the fragment rather than directly adjacent fragments.

  The alpha value of the sampling point can be generated from a single alpha value originally defined or derived for one or more fragments in any suitable desired manner. In effect, the goal is to estimate (re-create) the alpha value at the sampling point whenever possible, and any suitable function that can give an estimate of the alpha value at each sample point. Can be used to do this. Instead, different estimation functions may be better suited to certain situations than others, for example whether the alpha value of the displayed scene changes smoothly across scenes or varies more irregularly. There may be.

  In a particularly preferred embodiment, the fragment sampling point alpha value is compared to taking the original single alpha value defined for the fragment as the alpha value at the center of the fragment and the center point of the fragment Estimating the difference between the alpha values at the sample point in question and multiplying the fragment's original single alpha value to the alpha value's estimated difference to derive the alpha value used for the sample location It is estimated by adding. In other words, in the preferred embodiment, the difference between the alpha value at the sample point and the alpha value at the center of the fragment is estimated and then together with the alpha value originally defined or derived for the fragment Used to generate the alpha value of the sampling point.

  The initial alpha value of the fragment and / or the alpha value used for the center of the fragment can be, for example, a static alpha value, a dynamically changing value, a textured or calculated value as desired, if desired. And so on.

  With these arrangements, the difference between the alpha value at the center of the fragment and the alpha value at the sample location can be derived or estimated in any desired manner. However, in a particularly preferred embodiment, a gradient estimation method is used. In other words, preferably the rate of change of the alpha value (slope (derivative)) with respect to the distance from the center of the fragment to the sample point is estimated or determined and then used to derive the alpha value difference. (Based on the distance of the sample point from the center of the fragment).

  With these arrangements, the rate of change (slope) of the alpha value with respect to distance can be estimated or derived in any suitable manner as desired. In a particularly preferred embodiment, this is done by taking the difference between the alpha values of the appropriate adjacent fragments (and the distance between the midpoints of those fragments).

  So, for example, the rate of change (slope) of the alpha value in the x direction takes the alpha value of two fragments at positions x and x + 1 (or x-1) with respect to each other and the alpha value of the fragment Use the alpha value difference and distance to determine the difference between and the distance along the x-axis between the centers of the two fragments and to determine the estimate of the slope of the alpha value in the x direction This is preferably estimated by this. Preferably, a similar process is used to estimate the slope of the alpha value in the y direction, and these two slopes are then used to estimate the change in alpha value along any line on the screen. Can be used for

  In general, any suitable process for deriving alpha values, such as using known alpha values and alpha value differences, can be used as desired.

  An individual alpha value must be generated for each sampling point covered by the fragment (that fragment is being used to render it). In a preferred embodiment, alpha values are generated only for one or more sampling points that are known to be covered by the primitive, but for all sampling points of the set of sampling points that the fragment corresponds to, they are It is possible to simply generate an alpha value regardless of whether it is covered by the primitive.

  The alpha value generated for each sampling point is used to perform an alpha test for each sampling point. This alpha test can be performed in any desired suitable form, and as is known in the art, the individual alpha values generated for a sampling point are used for alpha testing of that sampling point. Comparison with (eg, preferably pre-determined) each reference alpha value or threshold alpha value defined in (preferably). If desired, more complex tests can be used than simple threshold comparisons.

  The reference alpha or threshold alpha value used for alpha testing can include any suitable or desired such value and can be derived or defined in any suitable desired form. For example, there may be a fixed static threshold alpha value defined for the scene or part of the scene for display as a whole. Instead, the reference alpha value or threshold alpha value is changed dynamically or in some way, for example, depending on the position in the scene (x, y position) or depending on some other parameter or factor. Can be.

  In general, there is a specific alpha value that is defined for a specific alpha test at that sampling point (e.g., either predetermined or derived in use) and that threshold alpha value or The reference alpha value is determined by other sampling points in the same fragment, depending on, for example, whether there is a single fixed reference alpha value for the scene as a whole, or whether the alpha value varies across the scene. And / or can be the same or different value as the reference alpha value used for alpha testing of sampling points of other fragments.

  The result of the alpha test comparison for each individual sample point can be used as desired. In one particularly preferred embodiment, these results are used to determine whether to discard (or not discard) the sample location as is known in the art. In effect, if the alpha test comparison indicates that the sample location must be preserved, the fragment color value, etc. is retained for that sample location (written to the sample location) (e.g., fragment data If (in the array) (i.e. allowed to potentially affect the last color at that sample location) indicates that the alpha test comparison indicates that the sample location should be discarded, the color of the fragment A value or the like is not held for the sample position (not written to the sample position).

  It should be appreciated that in these arrangements, there may be a need for some mechanism to display or record whether a given sampling position has been discarded as a result of an alpha test. This can be achieved in any desired suitable form.

  However, in a particularly preferred embodiment, each graphics fragment has which sampling point in the set of sampling points that it corresponds to (that is, the rendering) that fragment is about to be used to render it. Associated with data indicating the fragment data to be stored (proactively) in the output fragment data array, the sampling points in the set of sampling points to which that fragment corresponds. The system operates to properly store the rendered fragment data in the fragment data array for the selected selected sample location, but not to store the remaining sample locations associated with the fragment.

  In this arrangement, this data indicating the sampling point that the fragment is going to be used to render it is preferably based on, for example, the sampling position that is initially known to be covered by the primitive, It corresponds to these. Preferably, however, the alpha test result is used to modify this data to indicate the sample location that should be discarded as a result of the alpha test.

  Information indicating the sample point that the fragment is about to be used to render it is preferably associated with or part of the fragment data of the fragment that passes through the renderer (such as the fragment's RGB and alpha values) . This is preferably done for each sample position in the set of sample positions associated with the fragment whether the fragment is going to be used to render that sample point (i.e., the fragment's data (proactively) This is the form of a coverage mask that indicates whether sample points must be stored. This mask can be changed as a result of the alpha test of each sampling point and is preferably changed.

  This arrangement is a particularly convenient way of associating a given fragment with an appropriate sample point and has been found to facilitate the operation of the present invention.

  As noted above, the alpha test of the present invention is used in one preferred embodiment to save or discard the sampling position associated with a fragment, but other arrangements and uses of alpha test results. Is possible.

  For example, in a preferred embodiment, in addition to or instead of the above, an alpha test for individual sample locations determines or estimates whether an edge introduced by the alpha test can pass through the fragment of interest. Used for.

  This is, for example, that some of the sample positions of the fragment “pass” the alpha test comparison (eg, exceed the reference alpha value), but other sample positions of the fragment “pass” the alpha test. (E.g., less than a reference value). This should indicate that the edge introduced by the alpha test can or will pass through the fragment.

  Other edge testing arrangements can be used in addition to or instead of the above, such as a geometry-based test to calculate where the edge is. In general, any line function test similar to that performed in normal rasterization can be used for this purpose in addition to or instead of this, if desired.

  Thus, in a preferred embodiment, an alpha test in the form of the present invention is used to assess whether an edge introduced by the alpha test can pass through a fragment.

  In these arrangements, when it is found that the edge introduced by the alpha test can pass through the fragment, in a particularly preferred embodiment, the fragment is rendered once again in a fully supersampled form (rendering). Will be reissued for). This can, for example, loop back to an earlier point in the rendering process (pipeline) and split the fragment into multiple fragments (multiple copies) each representing a single subsample (sampling point) Can be done by.

  This eliminates the need to process the entire scene or primitive in a supersampled form (because only those fragments that are processed in supersampled form are identified as being at risk of lying on the alpha test edge) , Allowing the alpha test edge to be anti-aliased (by "supersampling" it).

  Indeed, the above and other arrangements of the inventive concept can themselves be novel and advantageous.

Thus, according to a fifth aspect of the present invention, there is a method for processing graphics primitives of a displayed image comprising:
Generating a set of graphics fragments to render primitives for display;
Rendering the graphics fragment generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Performing an alpha test on one or more fragments as part of the rendering process,
Generating individual alpha values for one or more sampling points of the one or more fragments;
A method is provided that is performed for each sampling point individually by performing an alpha test using the individual alpha values generated for the sampling point.

According to a sixth aspect of the present invention, there is a system for processing graphics primitives of a displayed image comprising:
Means for generating a set of graphics fragments to render primitives for display;
Means for rendering the graphics fragments generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Means for performing alpha testing on one or more fragments as part of the rendering process, and means for performing alpha testing
Means for generating individual alpha values for one or more sampling points of the one or more fragments;
And a means for performing an alpha test using the individual alpha values generated for the sampling points individually for each sampling point.

According to a seventh aspect of the present invention, a method for performing an alpha test in a graphics rendering system, wherein each rendered graphics fragment initially associates a single alpha value used for the fragment Is an alpha test of one or more fragments,
Generating individual alpha values for one or more sampling points of the one or more fragments;
A method is provided that includes, for each sampling point, performing an alpha test using the individual alpha values generated for the sampling point.

According to an eighth aspect of the present invention, a system for performing alpha testing in a graphics rendering system, wherein each rendered graphics fragment initially associates a single alpha value used for the fragment And
Means for generating individual alpha values for one or more sampling points of a fragment or group of fragments undergoing an alpha test;
A system is provided that includes, for each sampling point, means for performing an alpha test using the individual alpha values generated for the sampling point.

  As will be appreciated by those skilled in the art, these aspects and embodiments of the invention may include any one or more or all of the preferred and optional features of the invention described herein, as appropriate. And preferably include. Thus, for example, preferably, an individual alpha value is generated for each of a plurality of sampling points of the one or more fragments of interest. Similarly, the individual alpha values generated for a sampling point are preferably estimated in the manner described above (and, for example, initially defined or assigned for multiple fragments or multiple of them) Generated using at least part of the alpha value (s)).

  Similarly, the sampling points for which individual alpha values are generated preferably correspond to the sampling points used to determine the coverage of the primitive at the rasterization stage. However, the sampling points used to test for the presence of alpha test edges in these placements (e.g., as described below) are rasterized to test for the coverage (or not covered) of the rendered primitive. It is not necessary to correspond to the sampling points used during.

  For example, an alpha value at one fragment or each fragment corner (i.e. one or more fragment corner (s) sampling points) can be generated, preferably generated, with these placements. (E.g., to determine whether an alpha test edge can pass through a fragment). Taking the alpha value at the corner of the fragment may actually be a more reliable test for some applications.

  Equivalently, sample points (e.g., tests for the presence of alpha test edges) do not have to be individually associated with fragments (carried for fragments), e.g., assess multiple fragment groups or blocks. For example, it can be assessed whether an alpha test edge can pass through a block of fragments (all fragments in the block are then reissued for processing in supersampled form accordingly. (Or will not be reissued).

  In this case, the sample position at which the individual alpha value is generated can correspond to, for example, multiple sample points (eg, preferably block corners) of the block or group of fragments as a whole, preferably Correspondingly, for example, there may be only one (or indeed zero) sample points for one or any given individual fragment within a block. Such an arrangement may be particularly suitable for a rendering system that renders blocks of fragments, such as 2 × 2 blocks of fragments, at a time.

  In these embodiments and aspects of the invention, alpha value comparison (alpha test) can be used for any desired and appropriate purpose.

  In a particularly preferred embodiment, the comparison results are used to assess whether the edge introduced by the alpha test is likely to pass through the fragment or fragments, as described above. . This is preferably done by assessing whether some but not all of the sampling points pass the alpha test (as mentioned above, some sample points pass (stored) Because it implies that an alpha test edge is introduced if some do not pass (should be discarded)). Most preferably, as stated above, any fragment or group of fragments found to contain alpha test edges on this basis is reissued for rendering in a fully supersampled form.

  The alpha test arrangements of these aspects and embodiments of this arrangement can be used for other purposes in addition to or instead of the above. For example, they can be used to hold or discard a fragment or group of fragments based on alpha test results (comparison) as described above.

  Although the present invention has been described above with particular reference to performing alpha testing in graphic rendering, Applicants have applied the principles and techniques of the present invention to other situations and parameters, not just alpha values. For example, preferably the value of a particular parameter or parameters or attributes is not initially defined for a particular sampling point or position, and / or the number of values defined for a given fragment, for example It can also be applied if is less than the number of sample points that must be considered for that fragment.

  This is, for example, in graphics processing, there is a retention or destruction test that is performed on the sample points, such as in the case of an alpha test, and the graphics data (e.g., fragment attributes) initially defined for rendering is This may be especially true if it does not give an exact value for the relevant parameter or parameters being tested at a particular sample point.

  For example, a retention or destruction test must be performed in a fragment shader, for example for a depth value or stencil value for multiple sampling points of a fragment, but with a single depth value originally defined for that fragment or There may be only stencil values. In this case, a depth value and / or stencil value for a particular sampling point is derived in a manner similar to that described above for derivation of the alpha value, and then similar to that described above for the alpha test. Allows more accurate depth or stencil testing at each sampling point (in “anti-aliased” form).

  Thus, it is believed that the present invention can be applied beyond the alpha test within a graphics rendering system.

Thus, according to another aspect of the present invention, a method for performing a parametric test in a graphics rendering system, wherein a parametric test for one or more fragments is performed on one or more of the one or more fragments. Generating individual parameter values for a plurality of sampling points;
A method is provided that includes, for each sampling point, performing a parameter test using individual parameter values generated for the sampling point.

According to another aspect of the present invention, an apparatus for performing a parameter test in a graphics rendering system comprising:
Means for generating individual parameter values for one or more sampling points of one or more fragments;
Means for performing a parameter test individually for each sampling point using the individual parameter values generated for the sampling point.

Similarly, according to another aspect of the present invention, a method for processing graphics primitives of a displayed image comprising:
Generating a set of graphics fragments to render primitives for display;
Rendering the graphics fragment generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Generating individual parameter values during the rendering process for one or more sampling points of one or more fragments;
Using the individual parameter values generated for the sampling points for subsequent processing on the sampling points.

According to another aspect of the invention, a graphics processing system for processing graphics primitives of a displayed image comprising:
Means for generating a set of graphics fragments to render primitives for display;
Means for rendering the graphics fragments generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Means for generating individual parameter values during the rendering process for one or more sampling points of one or more fragments;
Means for using individual parameter values generated for the sampling points for subsequent processing on the sampling points.

  As will be appreciated by those skilled in the art, these aspects of the invention can include, preferably include, any one or more or all of the preferred and optional features of the invention described herein. . Thus, for example, the particular parameter and test preferably includes an alpha value, a depth value, and / or a stencil value at the sampling point (s) for the fragment (s) and the alpha test. A depth test, and / or a stencil test. Similarly, the parameter test is preferably used to determine whether to keep or discard the sampling point.

  Similarly, tests performed on derived parameter values at individual sampling points preferably include one or more individual parameter values generated individually for the sampling points with one or more reference parameters. Including comparing with the value.

  With these arrangements, if desired, both the depth value and the stencil value are derived, and then a comparison test is performed on both parameters (attributes), for example, multiple parameters or attributes at each sampling point. It is also possible to derive (and test) a value.

  Similarly, preferably individual parameter values are generated for each of a plurality of sampling points and / or covered sampling points for the one or more fragments of interest. Similarly, the individual parameter values generated for a sampling point are preferably estimated in the manner described above (and, for example, preferably initially defined for the fragment and / or a plurality of fragments). Generated or at least partially using the parameter value (s) assigned or assigned to it).

  Similarly, the sampling points for which individual parameter values are generated preferably correspond to the sampling points used to determine the coverage of the primitive at the rasterization stage (although this is not essential).

  In general, these aspects and embodiments of the present invention may include, for example, any fragment attribute that may not have a known distribution function across primitives (e.g., a fragment attribute that can be arbitrarily manipulated using textures by a graphics programmer). ) Can be applied. This is because in that case the graphics processing system may initially not be able to derive the exact value of the parameter at each sampling point. Similarly, these aspects and embodiments of the present invention ensure that a value for a given parameter or attribute is desired or required at a sample point, but the value at that sample point is not yet defined. Can be applied.

  Although the present invention has been described primarily with respect to the processing of a single graphics primitive, as will be appreciated by those skilled in the art, the displayed image is usually composed of a plurality of primitives and, therefore, in practice, the book. The method of the invention is repeated for each primitive that makes up the display, so that eventually an appropriate set of fragment data is generated for the entire image (or, for example, in a tile-based rendering system, the relevant portion of the image). Each sampling point of the image needed to be displayed has been generated and the data can then be downsampled, for example for display.

  In a particularly preferred embodiment, the various functions of the present invention are performed on a single graphics processing platform that generates and outputs data that is written to a frame buffer for a display device.

  The present invention is applicable to renderers of any shape or configuration, such as renderers having a “pipeline” arrangement (where the renderer is in the form of a rendering pipeline). In the preferred embodiment, the present invention applies to a hardware graphics rendering pipeline. Various functions and elements of the present invention can be implemented as desired, for example, preferably by suitable functional units, processing logic, processors, microprocessor arrangements, and the like.

  The present invention is applicable to all forms of rendering, including direct mode rendering, lazy mode rendering, tile based rendering, etc., but is particularly applicable to graphics renderers that use lazy mode rendering and especially tile based renderers. is there.

  As will be appreciated from above, the present invention is particularly, but not exclusively, applicable to 3D graphics processors and 3D graphics processing devices, and thus includes the apparatus of the present invention as described herein. It extends to 3D graphics processors and 3D graphics processing platforms that operate according to any one or more of the aspects of the invention described herein. Subject to all the hardware required to perform the specific functions mentioned above, such 3D graphics processors would otherwise be any of the normal functional units that a 3D graphics processor contains, etc. Can include one or more or all.

  All described aspects and embodiments of the invention may, and preferably do, include any one or more or all of the preferred and optional features described herein as appropriate. Will be understood by those skilled in the art.

  The method according to the invention can be implemented at least in part by using software, for example a computer program. Thus, when viewed from a further aspect, computer software and program elements specially adapted to perform the methods described herein when the present invention is installed on a data processing means and program elements on the data processing means. A computer program element comprising computer software code portions that perform the methods described herein when executed, and one or more methods described herein when the program is executed on a data processing system It will be appreciated that there is provided a computer program comprising code means adapted to perform all of the steps. The data processor can be a microprocessor system, a programmable FPGA (field programmable gate array), or the like.

  The present invention, when used to operate a graphics processor, renderer, or microprocessor system that includes data processing means, in combination with the data processing means, provides the processor, renderer, or system with the method of the invention. It also extends to a computer software carrier comprising the above software for performing the steps. Such a computer software carrier can be a physical storage medium such as a ROM chip, a CD ROM, or a disk, or an electronic signal on a wire, an optical signal, or a wireless signal such as to a satellite or the like It can be a signal.

  Further, not all steps of the methods of the present invention need to be performed by computer software, and thus, from a broader aspect, the present invention is capable of at least one of the method steps set forth herein. It will be appreciated that computer software and the software installed on the computer software carrier are provided.

  Accordingly, the present invention can be suitably implemented as a computer program product for use with a computer system. Such embodiments are fixed to a tangible medium such as a computer readable medium, such as a diskette, CD-ROM, ROM, or hard disk, or include but are not limited to an optical communication line or an analog communication line. Can be transmitted to a computer system either via a tangible medium or via a modem or other interface device, either intangible using wireless techniques including but not limited to microwave, infrared or other transmission techniques Can include a series of computer-readable instructions. This series of computer readable instructions implements all or part of the functionality previously described herein.

  Those skilled in the art will appreciate that such computer readable instructions can be written in a number of programming languages for use with many computer architectures or operating systems. Further, such instructions can be stored using any current or future memory technology including, but not limited to, semiconductor, magnetic, or light, or include light, infrared, or microwave Can be transmitted using any current or future communication technology, including but not limited to. Such computer program products can be distributed as removable media with accompanying printed or electronic documents, such as shrink-wrapped software, preloaded into a computer system, for example on a system ROM or fixed disk, or on a network, for example It is contemplated that it can be distributed from a server or electronic bulletin board via the Internet or the World Wide Web.

  The preferred embodiments of the present invention will now be described by way of example only and with reference to the accompanying drawings.

It is a figure which shows the influence of aliasing roughly. FIG. 2 schematically illustrates a supersampling anti-aliasing technique. It is a figure which shows the image displayed schematically. FIG. 4 shows an exemplary sampling pattern used in an embodiment of the present invention. FIG. 2 illustrates an embodiment of a graphics processing platform that can operate in accordance with the present invention. FIG. 4 is an enlarged view of the pixel in FIG. 3. FIG. 4 is a diagram illustrating data associated with a fragment rendered in an embodiment of the present invention. FIG. 3 schematically illustrates an embodiment of an alpha testing arrangement according to the invention. FIG. 6 schematically illustrates data associated with a fragment and modified as a result of an alpha test in the described embodiment of the invention. FIG. 6 schematically illustrates data associated with a fragment and modified as a result of an alpha test in the described embodiment of the invention. FIG. 3 schematically illustrates an embodiment of an alpha testing arrangement according to the invention.

  Preferred embodiments of the invention will now be described in the context of processing 3D graphics for display. However, as will be appreciated by those skilled in the art, the present invention is not limited to processing 3D graphics and has other applications.

  As is known in the art and as described above, when a 3D graphics image is displayed, the image is usually first defined as a series of primitives (polygons), which are then In turn, it is divided (rasterized) into graphics fragments for graphics rendering. During normal 3D graphics rendering operations, the renderer changes (for example) the color (red, green, and blue or RGB) data and transparency (alpha, a) data associated with each fragment, resulting in the fragment being Enable to display correctly. Once the fragment has passed completely through the renderer, the data value associated with it is stored in memory and ready for output for display.

  In particular, the present invention relates to facilitating an anti-aliasing operation when displaying a graphics image. As is known in the art, anti-aliasing is performed by taking multiple samples of the displayed image and then down-sampling these samples to the output resolution of the display.

  FIG. 3 schematically shows a basic anti-aliasing arrangement used in the present embodiment. FIG. 3 represents a portion of the displayed image in this embodiment (since this embodiment is a tile-based rendering system, as described further below) (equivalently, pixel representation to represent the entire display of the image). An array 30 of pixels is schematically shown (although a set can be considered). Each pixel, as shown in FIG. 3, samples the image for that pixel, and thus the four samplings used to determine how the pixel is displayed on the final display Includes a set 31 of points.

  As shown in FIG. 3, the same sampling pattern 31 is used for each pixel in the pixel array 30. In this embodiment, the sampling pattern is a rotating grid sampling pattern, but any other suitable anti-aliasing sampling pattern can be used if desired. FIG. 4 shows an enlarged view of a single pixel showing the location of sampling points within the sampling pattern within the pixel.

  FIG. 3 also shows an image overlaid on the pixel array 30 in the form of a single primitive 32 (where the image is shown in FIG. 3 as including a single primitive for simplicity of illustration). (In practice, it is understood that an image can and will typically contain a number of overlapping primitives, as is known in the art). As can be seen from FIG. 3, the primitive 32 completely overlays some of the pixels in the pixel array 30, but passes only some of the other pixels.

  To process the primitive 32 of the image, the rendering system essentially determines which of the sample points in each set of sample points for each pixel are covered by the primitive 32 at the rasterization stage. The data for these covered sample points is then rendered and stored so that the primitive 32 image can be displayed correctly on the display device.

  The processing of primitive 32 images for display in this form in this embodiment will now be described with reference to FIG. 5, which illustrates an embodiment of a 3D graphics processing platform that can operate in accordance with the present invention. Shown schematically. The 3D graphics processing platform shown in FIG. 5 is a tile-based renderer, but other rendering arrangements can be used as will be appreciated by those skilled in the art (in fact, the present invention is a two-dimensional graphics It is equally applicable to the processing of the process).

  The graphics processing platform shown in FIG. 5 includes a rasterizer 50, which receives graphics primitives for rendering, graphics data having the appropriate location for rendering the primitive data and the primitives. Convert to

  Next, there is a renderer 51 in the form of a rendering pipeline, which receives the graphics fragments for rendering from the rasterizer 50 and applies multiple rendering operations such as texture mapping, fogging, blending, etc. to these graphics fragments. Then, suitable fragment data for fragment display is generated. Rendered fragment data from the renderer 51 is stored in the tile buffer 52 of the rendering pipeline for subsequent processing.

  Tile buffer 52 stores an array of fragment data representing a portion of the image to be displayed, as is known in the art. If each tile has been processed until enough tiles have been processed to display the entire image, the data is exported to the appropriate storage, then the next tile is processed, and so on.

  In the present embodiment, four tile buffers 52 are provided. Each tile buffer stores its fragment data in a 32 × 32 array (ie, corresponding to a 32 × 32 array of sample locations in the displayed image). These tile buffers can be provided as separate buffers or, in practice, all can be part of the same larger buffer. These tile buffers are located on the graphics processing platform (chip) (local to that platform).

  Data from tile buffer 52 is input to downsampling unit 53, from which frame buffer 54 of display device 55 (to the graphics processing platform itself) for display on display device 55, as is known in the art. May not exist). Display device 55 can include a display including an array of pixels, such as, for example, a computer monitor.

  The downsampling unit 53 downsamples the fragment data stored in the tile buffer to a resolution appropriate for the display device 55 (ie, an array of pixel data corresponding to the pixels of the display device is generated).

  In this embodiment, the image sampling points have their own individual fragment data entries in the tile buffer 52. Thus, each 32 × 32 data position tile buffer corresponds to a 16 × 16 pixel array in the displayed image when, for example, 4 × downsampling is used between the tile buffer and the display frame buffer ( In that case, each pixel is effectively associated with 4 sampling points).

  In this embodiment, two of the four tile buffers are used to store the color (red, green, blue) values for each sampling point (one tile buffer can be used for this purpose). One tile buffer is used to store the Z (depth) value for each sampling point, and one tile buffer stores the stencil value for each sampling point. Used to. Of course, other arrangements are possible.

  Each sampling point has its own individual fragment data entry in the tile buffer 52, but in this embodiment, for each individual sample (data) location in the tile buffer 52 (i.e., for each individual sample point). Rather than rendering separate fragments, one fragment is rendered for each set of four sample points corresponding to a given pixel in the image. In other words, a single fragment is used to render all four sample points (and thus one pixel in the image) of a set of sample points together, i.e. a sample point for a given pixel Make sure everything is rendered in common. Thus, once a fragment has been rendered, the rendered fragment data is stored in the appropriate sample location in tile buffer 52 to provide a separate set of fragment data for each individual sample location of the image taken. Stored in multiple copies.

  Thus, in the current example, considering an image that includes the primitive 32 shown in FIG. 3, the rasterizer 50 receives that primitive from the graphics processing system, and then which set of image sampling points (i.e., Determine (virtually which pixels in pixel array 30) contain the sampling points covered by primitive 32 (this can be done in any suitable manner known in the art) . Rasterizer 50 then generates a fragment for each set of sampling points found to contain the sampling points covered by primitive 32. The rasterizer 50 then passes these fragments to the renderer 51 for rendering.

  FIG. 7 schematically illustrates data 70 generated for each fragment before being rendered and passing through renderer 51. As shown in FIG. 7, the data associated with each fragment contains, among other things, the x, y position 71 of the fragment (of the set of sampling points to which the fragment corresponds (in fact, in this embodiment, in the image (Representing the x, y position in the image) Including with. This per-fragment data 72 is used and appropriately modified by renderer 51's rendering unit to provide an output set of fragment data for fragments that are subsequently stored in tile buffer 52, as is known in the art. The

  The data 70 associated with the fragment also includes a coverage mask 73 in the form of a bit array representing each of the sample locations in the set of sample points to which the fragment corresponds. Each position in the bit array coverage mask 73 is set to “1” if the rasterization stage knows that the corresponding sample position is covered by the primitive, and the sample position is not covered by the primitive Is set to "0". This allows the rendering process to know which of the sample points associated with a given fragment are actually covered by that primitive 32, so that the rendering process is rendered for a fragment. It can be ensured that the fragment data used is only used (and stored, for example) for the sample points covered by the primitive.

  This is necessary because not all of the sampling points of a set of sampling points for a pixel are necessarily covered by a primitive, as can be seen from FIG. For example, of the set of sampling points for pixel 33, sampling points 43 and 44 are shown in FIG. 6 which shows an enlarged view of the set of sampling points for pixel 33 of FIG. It can be seen that the sampling points 45 and 46 are not covered by the primitive 32, but are covered by the primitive 32. Thus, the rasterizer 50 generates one fragment for the rendering of the set of sample positions for pixel 33 because that set of sample positions includes two sample positions 43 and 44 that are covered by primitive 32. However, since primitive 32 covers only sample locations 43 and 44, the fragment data to be rendered must be stored in tile buffer 52 only for those sample locations, not for sample locations 45 and 46. Don't be.

  Accordingly, for the set of sample locations for pixel 33 shown in FIG. 6, the rasterizer generates a coverage mask 73 of the form “1100” (as shown in FIG. 7) so that sample locations 43 and 44 are Indicates that it is being rendered by fragment 70, but sample locations 45 and 46 have not been rendered by that fragment (since they are not covered by primitive 32).

  Thus, rasterizer 50 receives primitives 32 for rendering and first determines which set of sampling points (pixels) of array 30 contains the sampling points covered by primitive 32 and then sets these sets of sampling points. For each, a fragment associated with the data in the form shown in FIG. 7 is generated.

  Each fragment is then passed to renderer 51 in turn for rendering. In this embodiment, the fragments are sent to the renderer 51 for rendering in blocks of 2 × 2 fragments, i.e. the rendering engine has fragments (2 pixels wide by 2 pixels high) in 4 fragment (pixel) blocks (2 pixels wide by 2 pixels high). Pixel). Other arrangements are of course possible, such as processing fragments (pixels) alone in the renderer.

  The renderer 51 performs a rendering operation on the received fragment, as is known in the art. These rendering operations include, for example, changing fragment color values (RGB) and transparency values (A) to provide the final rendered fragment data for each fragment. In this embodiment, the renderer 51 includes a texture mapping stage that performs a texture mapping process based on texture position data (s, t) associated with each fragment (which is not shown in FIG. 7).

  In this embodiment, the position in the image that the texture mapping process uses to determine the texture (color) applied to the fragments is the covered sampling that the fragments are commonly used to render them. Selected according to the position of the point in the image, ie, a “weighted” texture sample position is used.

  Of course, other texture sample position arrangements are possible. For example, all texture look-ups can simply be done at the center of the sampling pattern.

  Since each fragment undergoes a single texture lookup, the set of sampling points to which each fragment corresponds commonly undergoes a single texture lookup (i.e., the texturing operation is performed on the sampling points associated with the fragment). It will be appreciated that a set of sampling points is effectively processed in a multisampled manner (used for all sample points in the set).

  Another part of the rendering process of this embodiment is that an alpha test is performed for each rendered fragment. As is known in the art, alpha testing typically involves comparing the alpha value defined for a fragment with a reference alpha value or threshold alpha value defined for alpha testing and then on the basis of that comparison. Storing or discarding the fragment.

  In this embodiment, the alpha test process is described herein despite the fact that each fragment may initially only be defined with a single alpha value as described above. To provide an “anti-aliased” alpha test process in accordance with the present invention.

  8, 9, 10, and 11 illustrate the alpha test process of the present embodiment.

  FIG. 8 schematically shows a 2 × 2 block of pixels 80, 81, 82, and 83 corresponding to pixels 80, 81, 82, and 83 from FIG. Lines 84 and 85 in FIG. 8 correspond to the edges 84 and 85 of the primitive shown in FIG. In FIG. 8, the respective sampling points of each pixel 80, 81, 82, and 83 are also shown. The central points 87, 88, 89, and 90 of each fragment are also shown in FIG.

  As mentioned above, at the first rasterization stage, primitive geometric edges 84 and 85 are used to determine which sampling points of each pixel are covered by that primitive. And 83 for each sampling point. A set of fragments is then generated, each fragment corresponding to a given pixel in the display, defining the appropriate data for that pixel, and indicating which sampling location of each pixel the primitive covers.

  Thus, in the present case, the set of fragments 80, 81, 82, and 83 is a 2 × 2 of pixels 80, 81, 82, and 83 in the rasterization stage, as shown schematically in FIG. Generated for blocks.

  As shown in FIG. 9, the fragment 80 coverage mask 73 indicates that the two sampling locations of the pixel to which fragment 80 corresponds are covered by the primitive, and the fragment 81 coverage mask 73 Indicates that three sampling positions are covered, and so on.

  As also shown in FIG. 9, each fragment 80, 81, 82, and 83 has a single transparency (alpha) value originally defined for it. This value is derived in this embodiment from the alpha value defined for the vertices of the primitive, but can be done in any suitable manner known in the art.

  In the current example, it is assumed that fragment 80 has a transparency (alpha) value of 0.3, 1.0 for fragment 81, 0.0 for fragment 82, and 0.3 for fragment 83. Of course, these values are merely examples.

  In the normal course, these alpha values defined for each fragment either save or discard the fragment (and hence the pixel it corresponds to) as a whole based on the alpha test, as described above. Therefore, it is used for comparison with the reference alpha value defined for the alpha test.

  However, in this embodiment, and according to the present invention, when the alpha test is performed, instead of simply adopting the alpha value originally defined for each fragment to perform the alpha test, instead In turn, an individual alpha value is generated for each of the covered sampling positions that the fragment of interest is using to render it. Thereafter, alpha tests on individual sampling positions are performed.

  This process is illustrated with respect to the derivation of the alpha value of sampling point 86 of fragment 80. The same process is applied for each individual sampling point covered by the primitive for that fragment.

  In order to generate the individual alpha values of the sampling points 86 of the fragment 80, first a single alpha value 0.3 initially defined for the fragment 80 is taken as the alpha value at the center 87 of the fragment 80.

  Thereafter, the difference between the alpha value at the sampling point 86 and the alpha value at the center 87 of the fragment 80 is estimated. This is done by estimating the slope (derivative) of the alpha value with respect to the screen X, Y position (this slope is then the known relative screen X, between the sampling point 86 and the center 87 of the fragment 80). Y distance can be used to derive the relative change in alpha value from center 87 to sampling point 86).

  In this embodiment, the slope of the alpha value with respect to the position (rate of change) is set to the alpha value at the center 87 of the fragment 80 and the alpha value at the center 88 of the fragment 81 (the alpha value defined for fragment 81 is 1.0). ) And the known screen distance at X between the centers 87 and 88 and by deriving the slope of the alpha value in the X direction.

  Similarly, the slope of the alpha value in the Y direction of fragment 80 (the rate of change) is the alpha value at the center 87 of fragment 80 and the alpha value at the center 89 of fragment 82 (the alpha value 0.0 defined for fragment 82). And the Y distance between the fragment centers.

  The generated X and Y derivatives (rate of change) are then multiplied by the screen space X and Y distances between the center 87 of the fragment 80 and the sampling point 86 to obtain the sampling point 86 from the center 87. Gives the change in alpha value up to. This estimated change in alpha value is then added to the alpha value at the center point 87 of the fragment 80 (i.e., the alpha value originally defined for the fragment 80 in this embodiment), thereby providing a sample point 86. An estimate of the “true” alpha value at is derived.

  This process is then repeated for each of the remaining covered sample positions of fragment 80 and also for the covered sample positions of the other fragments (in this case, the alpha value at the center point of the other fragment). For example, in the case of fragment 81, the alpha value at the center 88 of that fragment is the alpha value originally defined for fragment 81 1.0).

  FIG. 11 further shows an alpha value derivation process. As shown in FIG. 11, for a given fragment 100 with sampling positions 101, 102, 103, and 104, the alpha value 105 originally defined for the fragment is taken as the alpha value at the center 106 of the fragment Fragment gradients (deltas) 107 and 108 are derived in the x and y directions and then used with the center point alpha value 105 to give an alpha value at each sampling point.

  Other arrangements that derive and estimate the alpha value of each covered sample location can be used if desired.

  For example, instead of using the X and Y slopes (rate of change) derived for fragment 80 for each of the other fragments 81, 82, and 83 of the 2x2 block of fragments when estimating the alpha value A new set of slope (rate of change) values can be generated individually for each fragment in a similar manner.

  Thus, for example, in the case of fragment 81, the X slope can be derived by considering the alpha value at the center 87 of fragment 80 and the alpha value at the center 88 of fragment 81, It can be derived by considering the alpha value at the center 88 of 81 and the alpha value at the center 90 of the fragment 83.

  For example, the alpha value at the center 88 of the fragment 81 and the alpha value at the center 90 of the fragment 83 can be used to derive the Y slope of the fragment 80, and so on. Similarly, alpha gradients can be derived using the alpha values of fragments further spaced than those shown in FIG. 8 if desired.

  In general, any suitable desired technique for deriving the slope of the alpha value (ratio of change) with respect to the screen space X distance and Y distance can be used. More sophisticated techniques may provide a more accurate estimate of the alpha value at the sample point, while requiring a higher processing workload.

  The individual alpha values estimated for each sample position are then used for alpha test comparison, i.e., they are compared to the threshold alpha value defined for the alpha test. Thus, for example, in the case of sample location 86, the estimated alpha value for that sample location is compared to a reference alpha value defined for alpha testing. This is then repeated separately for each covered sampling location.

  The result of the alpha test comparison for the individual sample points is then used to either keep the sample position or discard it from further processing based on the alpha test comparison. This is done by changing the coverage mask 73 associated with the fragment in question to exclude all covered sampling points that are actually found to be discarded as a result of the alpha test.

  This process is illustrated in Figure 10, where the alpha test comparison results in a straight line (effectively the edge introduced by the alpha test) 91 on which the sample is alpha in the current example. It can be seen that it is discarded as a result of the test, but under the assumption that the sample is retained under the straight line 91, fragments 80, 81, 82, shown in FIG. And 83 resulting fragment data sets are shown.

  The result of this alpha test and alpha threshold, which resulted in edge 91 introduced by the alpha test, changed the coverage mask bit for that sample location from "1" to "0" as shown in Figure 9 By doing so, the coverage mask of fragment 80 is changed to indicate that sampling point 86 is excluded from further processing (ie, did not pass the alpha test). Similarly, regarding the fragment 81, “0000” is now set in the coverage mask of the fragment. This is because the alpha test has discarded all of the sample positions for that fragment covered by the primitive. In the case of fragment 83, two sample positions are discarded by the alpha test, so the coverage mask for that fragment is “1001”.

  In this way, despite the fact that there may only be a single initial alpha value defined for a set of four sampling positions of one pixel as a whole, each alpha test will cover each sampling position covered Each sampling position can then be kept individually as a result of this alpha test or discarded. The effect of this is that all edges introduced by the alpha test are effectively “anti-aliased” (since these edges are processed at the level of the sampling position with respect to that position).

  Once the fragment is rendered, the data needs to be stored appropriately in the tile buffer 52. In accordance with the present invention, the data for each rendered fragment is stored at the appropriate sample location (s) in the tile buffer array as indicated by the coverage mask 73 associated with each fragment. Thus, for example, in the case of fragment 70 illustrated in FIG. 7, the rendered data for that fragment is stored in two of the sample locations in tile buffer 52, but the other associated with fragment 70. It is not stored in the two sample positions.

  The fragment data stored in the tile buffer 52 includes a color value (RGB), a transparency value (A), a depth value (Z), and a stencil value at each sample position as described above. This data can be stored in any suitable form.

  As will be appreciated by those skilled in the art, newly rendered fragment data stored in the tile buffer can be blended with data already stored in the tile buffer, as is known in the art, and typically Need to be blended. Thus, if a given fragment is commonly used to render multiple sample locations (i.e., data from the fragment will be stored in multiple sample locations in the tile buffer) This blending operation must be performed in an appropriate manner to accomplish this, ie, to properly blend the newly rendered fragment data to each appropriate sample location in the tile buffer. Thus, for example, a blending operation can be performed in an appropriate “parallel” fashion, for example, to blend rendered fragment data into a plurality of parallel tile buffers.

  Once this process is complete for all fragments associated with primitive 32, the process can be repeated for subsequent primitives in the image (as described above, an image is usually a single primitive 32). Not just composed of multiple primitives). This process is repeated for all primitives in the image until tile buffer 52 has been stored with the appropriate data for each of its sample locations.

  The data stored in the tile buffer can then be exported to the downsampling unit 53 for export to the frame buffer 54 for downsampling and subsequent display, as is known in the art. This downsampling can be done in any suitable manner. In this embodiment, linear blending of data is used to downsample the data. However, other arrangements are possible if desired.

  If the displayed image contains multiple overlapping primitives, the rendering process determines if any given primitive is actually seen at a given sampling point, as is known in the art. It is also necessary to do. In this embodiment, this is done by comparing the depth (z) values of the fragments as they are rendered, as is known in the art. Specifically, when rendering a new fragment, the depth (z) value associated with that fragment is the depth value of the fragment data already stored for the sample location in the tile buffer 52 to which that fragment corresponds. If the comparison indicates that no new fragment is found, the new fragment is not processed further. On the other hand, if the depth value comparison shows that the new fragment is actually seen instead of the fragment currently stored in the tile buffer 52, the new fragment is rendered and the rendered fragment Data is stored in place of the existing data at the appropriate sample location in tile buffer 52.

  The downsampling unit 53 also applies appropriate gamma correction to the data it outputs to the frame buffer 54.

  Other arrangements and modifications to the invention and the embodiments are of course possible. For example, more than four sample locations per fragment or per pixel for alpha testing and / or alpha value estimation can be used.

  In this embodiment, the estimated alpha test can also be used to assess whether an edge introduced by the alpha test is likely to pass through a fragment or a block of fragments. For example, in the arrangement shown in FIG. 8, for example, the result of an alpha test comparison for fragment 83 indicates that two sample positions are retained, but two are discarded. That is an indication that the edge introduced by the alpha test passes through the fragment. For this type of test, it is also possible to perform a test on the corners of the fragment, rather than using the same sample positions used, for example, for rasterizing the outer geometric edge of the primitive.

  In such an arrangement, where it is found that a fragment or block of fragments is likely to contain edges introduced by alpha testing, in a preferred embodiment, the fragment or fragment block is preferably Reissued for rendering on a fully subsampled basis (in other words, each sample position is treated as a separate fragment, thus including its own individual color and alpha values, etc.) .

  As can be seen from the above, the present invention, at least in its preferred embodiment, provides a system that can anti-aliasing without the need to process primitives to render the edges introduced by the alpha test in a fully supersampled form. provide. For example, unlike a fully supersampled method, the method of the present invention does not require calculating multiple color values per pixel or per fragment for an anti-aliased alpha test arrangement. This means, for example, that the present invention facilitates a reduction in computation in the process, along with the associated power savings, compared to a fully supersampled system.

  This is a preferred embodiment of the present invention, at least a single originally defined for each fragment to be rendered in order to recreate the individual alpha values of a plurality of individual sampling points for the fragment to be rendered. This is accomplished by using alpha values and then performing alpha tests individually on these individual sampling points.

  As noted above, the present invention and embodiments have been described with particular reference to alpha testing in graphics processing systems, but it is desirable to know the present invention for attribute values or parameter values at specific sample points. , These values are equally applicable to other situations where they are not yet defined. Thus, for example, the present invention can be used for depth testing operations and / or stencil testing operations within a graphics processing system, particularly, such as within a fragment shader. In these cases, the methods and techniques described above with respect to alpha testing can be similarly applied with respect to that particular parameter or parameters.

30 pixel array
31 Set of 4 sampling points
32 primitives
33 pixels
43 Sampling points
44 Sampling points
45 Sampling points
46 Sampling points
50 Rasterizer
51 Renderer
52 Tile buffer
53 Downsampling unit
54 Frame buffer
55 Display devices
70 data
71 x, y position
72 Data per fragment
73 Coverage mask
80 pixels
81 pixels
82 pixels
83 pixels
84 lines
85 lines
86 sampling points
87 Center point
88 Center point
89 Center point
90 Midpoint
91 straight line
100 fragments
101 Sampling position
102 Sampling position
103 Sampling position
104 Sampling position
105 Alpha value
106 center
107 Fragment gradient (delta)
108 Fragment gradient (delta)

Claims (19)

A method for performing an alpha test in a graphics rendering system, wherein an alpha test of one or more fragments is performed,
Generating individual alpha values for one or more sampling points of the one or more fragments of interest;
Performing an alpha test using the individual alpha values generated for the sampling points individually for each sampling point.   The method of claim 1, wherein the sampling points for which individual alpha values are generated correspond to the sampling points used to determine the coverage of a primitive in a rasterization stage.   3. A method according to claim 1 or claim 2, wherein the sampling point is for a group of multiple fragments. A method of processing graphics primitives of a displayed image,
Generating a set of graphics fragments to render the primitive for display;
Rendering the graphics fragment generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Performing an alpha test on one or more fragments as part of the rendering process, the alpha test comprising:
Generating individual alpha values for one or more sampling points of the one or more fragments of interest;
Performing an alpha test using the individual alpha values generated for the sampling points individually for each sampling point for which an alpha value has been generated.   5. The method of any one of claims 1 to 4, comprising generating the individual alpha values for the sampling points by estimating the alpha value at each sampling point from the alpha values associated with the fragment. The method described.   Generating the alpha value for the sampling point using an alpha value defined for the fragment of interest and one or more of the alpha values defined for one or more adjacent fragments of the fragment of interest; 6. The method according to any one of claims 1 to 5, comprising the step of:   The method according to claim 1, wherein the alpha test is used to determine whether to discard the sampling point.   Associating each fragment with data indicating which sampling point the fragment is being used to render, and modifying the data to indicate sample locations that are discarded as a result of the alpha test. Using the alpha test results. 8. A method according to any one of the preceding claims.   9. Any of claims 1 to 8, comprising using the alpha test for individual sample locations to assess whether an edge introduced by the alpha test can pass through the one or more fragments of interest. The method according to claim 1. A system for performing an alpha test in a graphics rendering system, the means for generating individual alpha values for one or more sampling points of a fragment or group of fragments undergoing an alpha test;
Means for performing an alpha test using the individual alpha values generated for the sampling points individually for each sampling point. 11. The system of claim 10 , wherein the sampling points for which individual alpha values are generated correspond to sampling points used to determine the coverage of primitives at the rasterization stage. 12. A system according to claim 10 or claim 11 , wherein the sampling point is for a group of multiple fragments. A system for processing graphics primitives of displayed images,
Means for generating a set of graphics fragments to render the primitive for display;
Means for rendering the graphics fragments generated for the primitive to determine a set of rendered fragment data for each rendered graphics fragment;
Means for performing an alpha test on one or more fragments as part of the rendering process, the means for performing the alpha test comprising:
Means for generating individual alpha values of one or more sampling points of the one or more fragments of interest;
Means for performing an alpha test using the individual alpha values generated for the sampling points individually for each sampling point. The means of any of claims 10 to 13 , comprising means for generating the individual alpha values for the sampling points by estimating the alpha value at each sampling point from the alpha values associated with the fragment. The described system. Generating the alpha value for the sampling point using an alpha value defined for the fragment of interest and one or more of the alpha values defined for one or more adjacent fragments of the fragment of interest; 15. A system according to any one of claims 10 to 14 , comprising means for: 16. A system according to any one of claims 10 to 15 , wherein the alpha test is used to determine whether to discard the sampling point. Means for associating each fragment with data indicating which sampling point the fragment is being used to render, and modifying the data to indicate sample locations that are discarded as a result of the alpha test. 17. A system according to any one of claims 10 to 16 , comprising means for using alpha test results. 18. Any of claims 10 to 17 , comprising means for using the alpha test for individual sample locations to assess whether an edge introduced by the alpha test can pass through the one or more fragments of interest. A system according to claim 1. 10. A computer program element comprising a computer software code portion for performing the method of any one of claims 1 to 9 when the computer program element is executed on a data processing means.