Graphics processing system

Abstract

The present disclosure relates to graphics processing systems. In particular, it relates to a graphics processor that rasterizes input primitives to generate graphics fragments to be processed, and renders the graphics fragments to generate a first, higher resolution version of a render output. When processing of the render output is stopped before completion of the render output, the first resolution version of the render output is downsampled to a second, lower resolution, and the downsampled data elements at the second resolution and a set of difference values indicative of differences between data elements at the first resolution and the downsampled data elements at the second resolution are written out. When processing of the render output is resumed, these values can then be loaded and used to reconstruct the array of data elements at the first resolution for use in continuing processing of the render output.

Description

Technical Field

[0001] The techniques described in this article relate to the processing of computer graphics, and in particular, to methods for manipulating a graphics processor when generating rendered output. Background Technology

[0002] Normally, graphics processing begins by dividing the graphics processing (rendering) output (such as a frame to be displayed) into multiple similar basic components (so-called "primitives") to make graphics processing operations easier. These "primitives" are usually in the form of simple polygons, such as triangles.

[0003] At this level, primitives are typically defined and represented by a set of vertices. Each vertex of a primitive is already associated with a dataset representing that vertex (such as position, color, texture, and other attribute data). This "vertex data" is then used, for example, when rasterizing and rendering the primitives associated with that vertex, to generate the desired rendering output for the graphics processing system.

[0004] For a given output to be generated by a graphics processing system (e.g., a frame to be displayed), it is typically defined as a set of vertices for that output. The primitives to be processed for that output are then indicated as a set of vertices that include the vertices of the graphics processing output being generated. Typically, the overall output (e.g., the frame to be generated) is divided into smaller processing units (called "draw calls"). Each draw call will have a corresponding set of vertices defined for it and a set of primitives that use those vertices.

[0005] Once primitives and their vertices are generated and defined, they can be processed by the graphics processing system to produce the desired graphics processing output (rendered output), such as frames for display. This essentially involves determining which sample points in an array of sample points associated with the area of ​​the rendered output to be processed are covered by primitives, and then determining the representation that each sample point should have (e.g., based on its color, etc.) to represent the primitive at that sample point. These processes are collectively referred to as rasterization and rendering, respectively.

[0006] Rasterization determines the sampling locations that should be used for primitives (i.e., the (x, y) positions of the sampling points to represent primitives in the output (e.g., the scene to be displayed). This is typically done using the positions of the primitive's vertices. The rendering process then derives the data necessary to represent the primitives at the sampling points (i.e., "shading" the individual sampling points)—such as red, green, and blue (RGB) color values, and "alpha" (transparency) values. This may involve, for example, applying textures, blending sampling point data values, etc. (Sometimes the term "rasterization" is used to refer to both converting primitives into sampling locations and rendering both. However, in this article, "rasterization" simply refers to converting primitive data into sampling point addresses.)

[0007] These processes are typically performed by testing multiple groups of one or more sample points, and then, for each group of sample points found to include a sample point that is inside (covered) the primitive in question, generating a discrete graphics entity, often referred to as a "fragment," for which graphics processing operations (such as rendering) are performed. Thus, the covered sample points are effectively processed into fragments that will be used to render the primitive at the sample point in question. A "fragment" is a graphics entity that has undergone rendering processing (rendering pipeline). Depending on how the graphics processing system is configured, the individual fragments generated and processed can, for example, represent a single sample point or a group of multiple sample points.

[0008] Therefore, a "fragment" is actually a set of graphical data (as associated with it) that is interpolated to one or more output space sampling points of the primitives. A fragment may also include per-primitive and other state data required to color the primitives at the sampling point in question (fragment location). The size and location of individual graphical fragments can generally be the same as the "pixels" of the output (e.g., the output frame) (because pixels are singularities in the final display, there can be a one-to-one mapping between the "fragments" operated on (rendered) by the graphics processor and the pixels of the display). However, there may be cases where there is no one-to-one correspondence between fragments and display pixels, for example, when a particular form of post-processing is performed on the rendered image before displaying the final image.

[0009] There are also cases where, because multiple fragments at a given location (e.g., from different overlapping primitives) may influence each other (e.g., due to transparency and / or blending), the final pixel output may depend on multiple or all fragments at that pixel location.

[0010] Accordingly, there may be a one-to-one correspondence between sampled points and display pixels, but more typically, there may not be a one-to-one correspondence between sampled points and display pixels, because rendered sample values ​​may be downsampled to generate output pixel values ​​for displaying the final image. Similarly, when multiple sampled point values ​​at a given location (e.g., from different overlapping primitives) influence each other (e.g., due to transparency and / or blending), the final pixel output will also depend on multiple overlapping sample values ​​at that pixel location.

[0011] One form of graphics processing uses what is called “tile-based” rendering. In tile-based rendering, the output of a 2D rendering (i.e., the output of the rendering process, such as the output frame to be displayed) is rendered as multiple smaller areas, often referred to as “tiles”. In such an arrangement, the rendering output is typically divided (by area) into rendering tiles of regular size and shape (they are typically squares or rectangles, for example). (Other terms commonly used for “tile-based” and “tile-based” rendering include “chunking” (the rendered tiles are called “chunks”) and “bucket” rendering. For convenience, the terms “tile” and “tile-based” will be used below. However, it should be understood that these terms are intended to cover any and all alternative and equivalent terms and techniques in which the rendering output is rendered as multiple smaller areas.)

[0012] These tiles are typically rendered individually, and then the rendered tiles are reassembled to provide a complete rendering output (e.g., a frame for display). The rendering of the tile primitives is typically performed using, for example, a geometric dataset representing the primitives and state data indicating the operations to be performed when rendering the primitives.

[0013] One problem encountered when processing graphics for display (when displaying computer-generated images) is that the displayed image is quantized to the discrete pixel locations of the display being used (e.g., a monitor or printer). This limits the resolution of the displayed image and can produce unwanted visual artifacts, for example, when the resolution of the output display device is insufficient to display smooth lines. These effects are commonly referred to as "aliasing."

[0014] Figure 1 This illustrates the aliasing effect. Figure 1 The left side shows the image to be drawn, while the right side shows the actual image displayed. As can be seen, the desired smooth curve of the white object appears jagged on the monitor. This is aliasing. (In) Figure 1In this diagram, each square represents a pixel on the display, and a cross represents a point at each (x, y) pixel location. The color value at that pixel location is determined (sampled). For example, Figure 1 Pixel A in the image is drawn as pure white because the color sample point at that pixel location falls within a white object. It should be noted that in... Figure 1 (The image only shows the sample crosshairs on the pixels of interest; however, in reality, all pixels are sampled.)

[0015] By using a display with a sufficiently high resolution, all aliasing artifacts visible to the naked eye can be removed. However, the resolution of electronic displays and printers is often limited, so many graphics processing systems use other techniques to attempt to remove or reduce the effects of aliasing. These techniques are often referred to as anti-aliasing techniques. One known anti-aliasing technique is called supersampling or oversampling.

[0016] In this arrangement, each pixel of the final display has multiple sampling points (positions), and a separate color sample is obtained for each (overlaid) individual sampling point (e.g., by rendering each sampling point as a separate fragment). The effect of this is that, during the rendering process, different color samples are obtained for each sampling point of the display pixel covered by the primitive.

[0017] This means taking multiple color samples for each pixel of the display (one sample for each sampling point of the pixel, because a separate color value is rendered for each sampling point). Then, when displaying the pixel, these multiple color samples are combined into a single color for that pixel. This has the effect of smoothing or averaging the color values ​​of the original image at the pixel location in question.

[0018] Figure 2 An example of oversampling processing is shown. In Figure 2 In the example shown, four sampling points are determined for each pixel in the display, and a separate color sample is obtained for each sampling point during the rendering process. (Therefore, each such sample can be effectively considered as a "subpixel," and each pixel in the display is composed of four such subpixels.) The four color value samples (subpixels) of a given pixel are then combined (downfiltered) so that the final color used for a pixel in the display is the appropriate average (mixing) of the colors of the four color samples obtained for that pixel.

[0019] This has the effect of smoothing the displayed image and, for example, reducing the prominence of aliasing artifacts by surrounding them with intermediate color shading. This can be achieved in... Figure 2As can be seen, pixel A now has two "white" samples and two "black" samples, and is therefore set to, for example, 50% "white" in the displayed image. In this way, based on, for example, finding out how many samples fall on each side of the edge of the white object, the pixels around the edge are blurred to produce a smoother edge.

[0020] In practice, oversampling processes the screen image at a resolution much higher than the resolution actually used for the display, and then scales and filters (downsamples) the processed image to the final resolution before displaying it. The effect of this is to provide an improved image with reduced aliasing artifacts, but it requires much more processing power and / or time because the graphics processing system actually has to process as many samples as the number of samples (making, for example, for 4× oversampling (i.e., where four samples are taken for each display pixel), the processing requirements will be four times higher than without oversampling).

[0021] Therefore, other anti-aliasing techniques have been proposed, which still provide some improvement in image quality but require less processing than full supersampling. A common technique of this kind is called "multisampling".

[0022] In the case of multisampling, multiple sampling points are tested again for each display pixel to determine whether a given primitive covers the sampling points when the image is rasterized into fragments (at the rasterization level). Thus, the sampling point coverage of primitives in a multisampling system is determined in a similar manner to that of an "oversampling" system (therefore, in a multisampling system, the location of the outer geometric edges of primitives is still effectively "oversampled").

[0023] However, in the rendering process of a multisampling system, all sampled points of a given display pixel covered by the primitive in question are assigned to the same single common color value dataset (instead of, as in the case of supersampling, each color value has its own separate dataset).

[0024] Therefore, in multisampling, instead of determining individual color values ​​for each sample when rendering "pixels" (as is the case with full supersampling systems), multiple samples are again taken for each pixel that makes up the final display. Instead, a single color value is determined and applied to all samples of the display pixel that are found to belong to the same object in the final image. In other words, multisampling computes a single color value for a given display pixel for a given object in the scene, and applies (reuses) that color value to all samples (subpixels) of the display pixels covered by that object (as opposed to supersampling, which determines individual color values ​​for each sample).

[0025] Because multiple sampling uses only a single color value for multiple samples of a given display pixel, it is less intensive than oversampling, and therefore can achieve faster processing and performance compared to oversampling.

[0026] Generally speaking, any appropriate level of multisampling or oversampling (e.g., 4×, 8x, 16x) can be performed, and modern graphics processing systems are typically configured to support various levels of multisampling and / or oversampling as needed.

[0027] When such multisampling / supersampling techniques are implemented in a tile-based graphics processing system, the renderer can thus process multiple sample points per display pixel (e.g., four sample points per display pixel for 4× MSAA) to determine the appropriate data (e.g., color) values ​​for the sample points. The output fragment data values ​​are then written to an appropriate (e.g., tile (color, etc.)) buffer, and from that buffer, for example, the fragment data values ​​can be output to a frame buffer for display when the output is desired. The depth values ​​of the output fragments are also appropriately written to the Z-buffer within the tile buffer.

[0028] Therefore, the tile (color, etc.) buffer and the Z buffer will respectively store the appropriate color, etc., or Z value of each sample point represented by the buffer (essentially, each sample point of the tile being processed). Thus, the tile buffer stores a set of multisampled fragment data at a first “full” (multisampled) resolution (i.e., using multiple sample points per display pixel), which actually represents a portion of the rendered output (the area corresponding to the tile in question).

[0029] When writing out the fragment data, for example, to generate the rendering output at the desired (lower) resolution (i.e., by downsampling the multisampled fragment data of the display pixels into individual pixel values), the multisampled fragment data from the tile buffer is typically first input to a downsampling (multisample resolve) unit, which performs the desired downsampling to the desired (lower) resolution, and then the data elements representing the desired (lower) resolution of the rendering output are output, for example, to an output buffer, such as the frame buffer of the display device.

[0030] However, the applicant believes that there is still room for improvement in graphics processing. Summary of the Invention

[0031] According to one aspect of this disclosure, a method is provided for operating a graphics processor when generating rendered output, the graphics processor comprising:

[0032] A rasterizer circuit that rasterizes input primitives to generate graphic fragments to be processed, each graphic fragment having a set of one or more sampling points associated with it; and

[0033] A renderer circuit that renders a graphic fragment generated by the rasterizer circuit to generate rendered fragment data of the graphic fragment, and the renderer circuit is operable to generate a first higher resolution data element array representing the rendered output, and when writing out the rendered output, downsampling the first resolution data element array to generate a second lower resolution data element array representing the rendered output.

[0034] The method includes the following steps:

[0035] The graphics processor generates the rendering output by processing graphics primitives to generate a data element array representing the first resolution of the rendering output; and

[0036] Store data elements representing the first resolution of the rendered output;

[0037] The method further includes the following steps:

[0038] The graphics processor stops generating the rendering output, and while the graphics processor is doing so, it performs the following operations:

[0039] The stored data elements of the first resolution in the rendering output are downsampled to generate a data element array representing the second resolution of the rendering output;

[0040] A set of differences is determined, indicating the difference between the data elements representing the first resolution of the rendered output and the generated array of data elements representing the second resolution of the rendered output; and

[0041] The data element array representing the second resolution of the rendered output, together with the determined difference set, is written to memory; and

[0042] The graphics processor resumes the processing of the rendered output; and when the graphics processor does so, it performs the following operations:

[0043] Load the data element array representing the second resolution of the rendered output and the determined set of differences from the memory;

[0044] Using the loaded second-resolution data array and the loaded difference set, the data array representing the first-resolution rendering output is reconstructed; and

[0045] When processing of the rendered output continues, the reconstructed data element array representing the first resolution of the rendered output is used.

[0046] According to another aspect of this disclosure, a non-transitory computer-readable storage medium for storing computer software code and a graphics processing system including a graphics processor are also provided. Attached Figure Description

[0047] Now, by way of example only and with reference to the accompanying drawings, several embodiments of the technology described herein will be described, wherein:

[0048] Figure 1 The effect of aliasing is illustrated schematically;

[0049] Figure 2 The oversampling anti-aliasing technique is illustrated schematically.

[0050] Figure 3 The image to be displayed is shown schematically;

[0051] Figure 4 An implementation of a graphics processing pipeline that operates according to the techniques described herein when performing 4× MSAA is shown;

[0052] Figure 5 The data flow according to an implementation of the technique described herein is illustrated schematically when the generation of rendering output is paused;

[0053] Figure 6 The illustration schematically shows the storage of data during the pause of rendering output generation, according to an embodiment; and

[0054] Figure 7 This illustration schematically shows the data flow according to an implementation of the technique described herein when the generation of previously paused rendering output is to be resumed.

[0055] Where appropriate, use the same labels for the same features and components in the diagram. Detailed Implementation

[0056] A first embodiment of the technology described herein includes a method for operating a graphics processor when generating rendered output, the graphics processor comprising:

[0057] A rasterizer circuit that rasterizes input primitives to generate graphic fragments to be processed, each graphic fragment having a set of one or more sampling points associated with it; and

[0058] A renderer circuit that renders a graphic fragment generated by the rasterizer circuit to generate rendered fragment data of the graphic fragment, and the renderer circuit is operable to generate a first higher resolution data element array representing the rendered output, and when writing the rendered output, downsampling the first resolution data element array to generate a second lower resolution data element array representing the rendered output.

[0059] The method includes the following steps:

[0060] The graphics processor generates the rendering output by processing graphics primitives to generate a data element array representing the first resolution of the rendering output; and

[0061] Store data elements representing the first resolution of the rendered output;

[0062] The method further includes the following steps:

[0063] The graphics processor stops generating the rendering output, and while the graphics processor is doing so, it performs the following operations:

[0064] The stored data elements of the first resolution in the rendering output are downsampled to generate a data element array representing the second resolution of the rendering output;

[0065] Determine a set of differences, the set of differences indicating the differences between data elements representing the first resolution of the rendered output and the generated array of data elements representing the second resolution of the rendered output; and

[0066] The data element array representing the second resolution of the rendered output, together with the determined difference set, is written to memory; and

[0067] The graphics processor resumes the processing of the rendered output; and when the graphics processor does so, it performs the following operations:

[0068] Load the data element array representing the second resolution of the rendered output and the determined set of differences from the memory;

[0069] Using the loaded second-resolution data array and the loaded difference set, the data array representing the first-resolution rendering output is reconstructed; and

[0070] When processing of the rendered output continues, the reconstructed data element array representing the first resolution of the rendered output is used.

[0071] A second embodiment of the technology described herein includes a graphics processing system comprising a graphics processor, the graphics processing system comprising:

[0072] A rasterizer circuit that rasterizes input primitives to generate graphic fragments to be processed, each graphic fragment having a set of one or more sampling points associated with it; and

[0073] A renderer circuit that renders a graphic fragment generated by the rasterizer circuit to generate rendered fragment data of the graphic fragment, and the renderer circuit is operable to generate a first higher resolution data element array representing the rendered output, and when writing the rendered output, downsampling the first resolution data element array to generate a second lower resolution data element array representing the rendered output.

[0074] The graphics processor is configured to perform the following operations:

[0075] The rendering output is generated by processing graphic primitives to generate a data element array representing the first resolution of the rendering output; and

[0076] Store data elements representing the first resolution of the rendered output;

[0077] The graphics processor is also configured to perform the following operations when it stops generating the rendering output before completing the rendering output:

[0078] The stored data elements of the first resolution in the rendering output are downsampled to generate a data element array representing the second resolution of the rendering output;

[0079] Determine a set of differences, the set of differences indicating the differences between data elements representing the first resolution of the rendered output and the generated array of data elements representing the second resolution of the rendered output; and

[0080] The data element array representing the second resolution of the rendered output, together with the determined difference set, is written to memory; and

[0081] The graphics processor is also configured to, when the graphics processor resumes processing of previously stopped rendering output:

[0082] Load the data element array representing the second resolution of the rendered output and the determined set of differences from the memory;

[0083] Using the loaded second-resolution data array and the loaded difference set, the data array representing the first-resolution rendering output is reconstructed; and

[0084] When processing of the rendered output continues, the reconstructed data element array representing the first resolution of the rendered output is used.

[0085] The techniques described herein relate to processing graphics primitives to generate rendered output. In particular, the techniques described herein relate to a method (and apparatus) for graphics processing, wherein the rendered output is generated by first generating a higher resolution representation of the rendered output, but then “downsampling”, for example, at a desired output resolution (e.g., for display), to resolve the first higher resolution representation of the rendered output into a second lower resolution representation of the rendered output.

[0086] A typical example of this is when performing anti-aliasing techniques such as multi-sampling anti-aliasing (MSAA) or supersampling, as described above, where multiple samples (sample points) are stored and processed per output display pixel (e.g., four sample points per display pixel for 4× MSAA), and where, when rendering of a fragment of display pixels is complete, the multiple samples are "downsampled" to give a single pixel value for the rendered output. This downsampling is often referred to as a "resolve" process. For example, the simplest "resolve" process is to take the average (or weighted average) of the data values ​​of the multiple samples associated with the display pixel. However, other resolve processes can also be used.

[0087] Therefore, in this embodiment, the first higher-resolution representation of the rendered output is a "multisampled" version of the rendered output, wherein multiple (e.g., four) sample points are stored for each display component (pixel) in the rendered output. Thus, the data elements of the first higher-resolution version of the rendered output represent the corresponding data values ​​of each of these multiple sample points. When the rendered output is to be written, this multisampled representation of the rendered output is then downsampled to generate a second lower-resolution (parsed) representation of the rendered output, and then this lower-resolution (parsed) version of the rendered output is written. Therefore, in this embodiment, the second lower-resolution representation of the rendered output is a "single-sampled" version of the rendered output, wherein only a single sample point is stored for each display component (pixel).

[0088] For example, in an implementation, for the case of 4× MSAA, the first higher resolution representation of the rendered output uses four data elements (corresponding to four corresponding sampling positions) for each data element of the second lower resolution representation of the rendered output (the data elements of the second lower resolution version correspond to display pixels). However, the techniques described herein are certainly not limited to 4× multisampling, but any level of multisampling / supersampling (e.g., 8x, 16x, etc.) can be applied as needed.

[0089] Other arrangements are also possible, and the techniques described herein can generally be applied to any of the following situations: first, a rendering output is generated at a first higher resolution, in a manner similar to that described above (but not necessarily for the purposes of MSAA), and then the rendering output is downsampled.

[0090] The techniques described in this article specifically address situations where the generation of render output can be stopped (e.g., because it is necessary to switch to processing another render output, and / or because it is necessary to generate and / or provide additional data to enable processing of a larger portion of that render output), but the generation of render output can be resumed at a later time.

[0091] The applicant has recognized that this is a situation where, during graphics processing, it may be necessary to stop and resume processing a given render output. For example, in cases where limited memory is reserved for the data structures required to process the render output, that memory may fill up before the complete data structure of the render output is generated. In such cases, it may be desirable to process the existing data structures of the render output (in order to effectively "flush" those data structures in memory), and then generate the new data structure of the render output in question, and so on. Therefore, in this case, the render output being generated may, for example, be generated as a series of "incremental" processes, wherein the first portion of the render output data is processed, followed by a pause and / or processing of some other render output, and then a return to the initial render output to complete (or at least continue processing of that initial render output).

[0092] For example, this might occur in a tile-based graphics processing system, where processing of one tile might be paused and then switched to processing of another tile, and so on, with processing alternating between different tiles, for example, because different tile data structures are generated and used. Thus, in an implementation, the rendering output being generated is a region (e.g., a tile) of the overall output (such as a frame to be displayed) being generated by the graphics processor (therefore, the graphics processor is a tile-based graphics processor).

[0093] The applicant further recognizes that a given rendering output may have been processed only partially (e.g., a larger rendering output may have been divided into tiles for rendering purposes), making it necessary to restore the processing of that rendering output (e.g., tiles) at a later time. Then, it may be necessary to retain the data structures generated so far as part of the processing of the rendering output so that when the processing of the rendering output in question is restored, the generated data structures can be reused and the process can continue.

[0094] The applicant further recognizes that, on the one hand, the rendering output is partially processed and the processing of that rendering output is to be continued at a later time, and on the other hand, the portion of processing away from the rendering output is to retain the resulting rendering output values ​​for use when resuming the processing of the rendering output.

[0095] The technique described in this article solves this problem by storing the data generated from that part of the rendering output when processing of the partially completed rendering output is stopped, so that the data value can be recovered when processing of the rendering output is resumed.

[0096] For example, in the case of MSAA, the full resolution data values ​​of all multisampled samples for that part of the render can be written when the generation of the render output is stopped, and then the full resolution samples of that part of the render can be restored when rendering of the render output area in question resumes. However, this would involve relatively high data transfer and storage bandwidth.

[0097] To address this issue and reduce required storage bandwidth, instead of writing out the current multisample values ​​in a "full" manner when "partial" (incremental) rendering exists (e.g., cleanup as described above), the technique described herein instead performs the necessary parsing operations on the samples according to their current condition when writing out the processed data of the "partial" rendering, i.e., when the generation of the rendering output is stopped (paused). This results in writing out the final parsed "downsampled" version of the rendering output and a set of difference (e.g., incremental) values ​​indicating the difference between the data elements of the downsampled version of the rendering output and the data element array of the full multisampled version of the rendering output.

[0098] In other words, for all the sampling locations being processed, instead of writing out all the data elements of the first higher resolution of the rendered output generated so far (the complete multisample values ​​(at multisample resolution)), the technique described herein resolves the rendered output to the desired lower sampling resolution according to the current actual situation of the rendered output, and writes out the resolved (downsampled) data array representing the lower resolution of the rendered output in a complete manner, and a set of differences indicating the differences between the data elements representing the (first) lower resolution of the rendered output and the generated data element array representing the (second) higher resolution of the rendered output, which can then be used, for example, in the process of restoring the rendered output, to reconstruct the data element array representing the first resolution of the rendered output.

[0099] Therefore, the applicant has recognized that it is possible and will be possible to recover the higher resolution (multisampled) representation of the rendered output from the parsed lower resolution representation of the rendered output, and in a reasonably efficient manner, by storing and using data indicating the differences between the two representations, so that the complete data elements of the higher resolution representation of the rendered output written out for later (re)use can be omitted.

[0100] This reduces the amount of data that needs to be written when there is "partial" (incremental) rendering (cleaning). For example, in the implementation, for the case of 4× MSAA, instead of writing out the complete array of 4× sample values ​​for each pixel, an array of data elements representing the parsed (downsampled) pixel values ​​of the corresponding pixel in the rendered output is written out, along with a set of 4× sample values, but each sample value is represented by a difference (rather than the "complete" sample value).

[0101] This has the advantage of reducing storage requirements and bandwidth when processing is interrupted midway through rendering, for example, because it is not necessary to write out the complete resolution data values ​​(and therefore they can be discarded), thus making the overall processing more efficient.

[0102] This also means that if the data elements of the generated render output that have been processed up to the point of stopping render output generation are not actually needed when the generation of the render output can be resumed, then there is no need to load the data values ​​written to memory (and therefore this is not done in the implementation). For example, if it is determined that there are no other primitives of the render output to be processed when processing can be resumed, then rendering is complete because the parsing operation has already been performed, and no further processing is needed for that render output. Therefore, by performing the "early" parsing operation, i.e., at the moment when the processing of the render output stops, the technique described herein can help avoid unnecessarily loading data back from memory, thereby further reducing storage bandwidth.

[0103] In contrast, when implementing MSAA in a more conventional tile-based rendering system, the set of multiple sample points can only be parsed once the tile rendering is complete, and then the parsed (downsampled) pixel values ​​are written back to memory at that level. Since the tile rendering and processing are complete, there is no need to write multiple samples of full resolution back to memory, so they can simply be discarded.

[0104] However, the techniques described in this paper recognize that such downsampling may not be as efficient when tiles may be rendered “partially” (incrementally) (i.e., when not all geometry is available and processed).

[0105] Therefore, in the technique described herein, the parsing operation is performed at the moment when the generation of the rendering output is paused (stopped). Simultaneously, a set of interpolations is generated, which can be used with the parsed version of the rendering output to recover a higher-resolution version of the rendering output. This still allows multiple samples at full resolution to be discarded without writing them out, thus helping to reduce storage bandwidth.

[0106] On the other hand, if there are other primitives in the rendered output that are yet to be processed, and further processing of these primitives may require the full-resolution output values ​​from the partial processing of the rendered output so far (as described above), then the downsampled data values ​​and differences can be loaded and used to restore the full-resolution version of the rendered output, which can then be used to continue processing the rendered output. Therefore, a higher resolution can still be restored (if needed) when resuming the processing of the rendered output.

[0107] The graphics processors described in this article typically include rasterizers and renderers.

[0108] The rasterizer (rasterizer circuitry) can be configured to operate in any suitable and desired manner, for example, as in a known rasterization layout. The rasterizer should generate the graphic fragments for processing based on which sample points (or sets of sample points) in the sample point array are covered (at least partially) by the area, given primitives, etc., of the rendered output received by the rasterizer.

[0109] In an implementation, the rasterizer generates graphic fragments of individual sample points covered by the primitives (and each) being rasterized, and / or graphic fragments of multiple groups of sample points (e.g., sample masks): the multiple groups of sample points found to include sample points covered by the primitives (and each) being rasterized (as well as sample points that were originally not removed from processing for another reason, such as because the primitives failed an early depth test). Accordingly, the fragments generated by the rasterizer can represent a single sample point (or associated with that sample point) or multiple sample points as needed. In an implementation, the fragments represent a group of multiple sample points, in which a group of four sample points (and in which, in another implementation, a 2 × 2 array of sample points) is used.

[0110] The renderer (renderer circuitry) of the graphics processor should be operable to render (color) graphics fragments received by the renderer to generate desired output graphics fragment data. The renderer may contain any suitable and desired rendering components and may be configured in any suitable and desired manner. Thus, for example, the renderer may include a fixed-function rendering pipeline, including one or more fixed-function rendering stages (circuits), such as a texture mapper, a blender, a fogging unit, etc. In implementations, the renderer includes fragment shaders (shader pipelines) (i.e., programmable processing circuitry operable and programmable to perform fragment coloring procedures on fragments to render those fragments).

[0111] The renderer processes the received fragments and generates output rendered fragment data. In one implementation, the rendered fragment data is then written to an output buffer (such as a frame buffer) in external memory for use (e.g., displaying frames on a monitor). The rendered fragment data can be written to the (external) output buffer via an intermediate buffer such as a tile (e.g., color) buffer (as is the case in tile-based graphics processing systems).

[0112] The rendering output to be generated can include any rendering output to be generated by the graphics processor. Therefore, the rendering output to be generated can, for example, include all or part of the tiles to be generated in a tile-based graphics processor, and / or frames of fragment data to be output.

[0113] As mentioned above, in the implementation, the rendering output being generated is a region (e.g., a tile) of the overall output (such as a frame to be displayed) being generated by the graphics processor (therefore, the graphics processor is a tile-based graphics processor).

[0114] The applicant has recognized that in a tile-based graphics processing system, it may be desirable to switch from processing one tile to processing another or more tiles, and then return to continue processing the earlier tiles, and so on. This may occur, for example, when the amount of memory available for the tile data structures to be used when rendering the tiles is limited, making it possible, for example, to process tiles whose relevant data structures have only been partially completed in order to free up the memory space occupied by those data structures. However, this means that only the tile has been partially processed, and therefore it may be necessary to resume processing of the tile at a later time, for example, when a new data structure containing previously unprocessed new data of the tile has been generated, and so on.

[0115] The cessation of processing on the render output can be triggered in any suitable and desired manner, thereby triggering the storage of data elements of a downsampled version of the render output and the set of differences, for example, as described above.

[0116] For example, this stop can be triggered by the exhaustion of the current data structure of the rendering output being processed. For instance, in the case of a tile-based graphics processing system, various data structures for a tile are prepared to enable its generation. When the graphics processor is triggered to process the tile, the tile's data structure may be incomplete (not containing all the data required to fully process the tile). Therefore, in this case, the graphics processor will process the (incomplete) data structure of the tile it receives, but once these data structures are complete, the graphics processor then needs to wait for a new data structure containing further data for the tile to become available (to be processed) before it can continue processing the tile.

[0117] For example, this stop can also be triggered when the graphics processor needs to switch to generate different overall rendering outputs (e.g., frames). This might occur, for instance, in the case of background switching for virtual reality time warp operations, where, for example, a "time warp" frame is rendered at full frame rate (e.g., 60 fps), and the full frame of the VR application is rendered during the "time warp" shutdown period, then the time warp is preempted as needed. Then, when preemption occurs, a portion of the frame will be encountered. This operation can also be triggered by interaction with other data, such as geometry caches, for example, when it is desirable to keep geometry in the cache at the expense of pixel throughput.

[0118] Various other arrangements are also possible.

[0119] In the techniques described herein, when generating rendered output, a first, higher-resolution version of the rendered output is maintained and stored. This can be stored, for example, in a common manner, such as in a tile buffer. These tile buffers should be stored in appropriate (local) memory of the graphics processor and / or accessible to the graphics processor, such as, and in embodiments, the graphics processor's (local) RAM or (local) RAM associated with the graphics processor. Therefore, in embodiments, the step of the graphics processor storing data elements representing the first resolution of the rendered output includes storing the data elements of the first resolution in the graphics processor's (local) memory and / or in (local) memory accessible to the graphics processor.

[0120] The tile buffers can be stored in different physical memories, but in this implementation, the tile buffers are stored in the same physical memory.

[0121] The tile buffer stores values ​​such as fragment colors to be applied to the rendered output and can be configured in any suitable and desired manner. The tile buffer should, and indeed in implementation, store the values ​​of colors, etc., at each sampled location of the rendered output (e.g., a tile). Therefore, the tile buffer for a tile should, and indeed in implementation, store the current values ​​of colors, etc., at each sampled location within the tile in question. The values ​​of colors, etc., stored in the tile buffer should, and indeed in implementation, be stored and updated as primitives are rasterized / rendered to generate new fragment output data.

[0122] Therefore, in the embodiments, the data elements in the technology described herein include fragment data in the form of values ​​such as color for sampling positions to be used in the rendering output. In the embodiments, during the generation of the rendering output, the fragment data (color, etc.) values ​​are multisampled and stored accordingly in a first higher resolution (multisampling) format, and then parsed to give individual fragment data (color, etc.) values ​​for each pixel of the rendering output.

[0123] In this implementation, the depth values ​​are also multisampled and can be stored, for example, in a Z-buffer within the tile buffer in a similar manner. In this implementation, the multisampled depth values ​​are also processed in the same way.

[0124] When processing of the rendering output in question is stopped, thereby triggering the writing of fragment data values ​​(e.g., color values ​​and depth values) of a portion of the rendering output to memory, a downsampled version of the rendering output is written to memory. This downsampling can be performed in any suitable and desired manner, for example, and in the embodiments, it is performed in a normal manner for the graphics processor and graphics processing system in question. For example, the step of a graphics processor downsampling data elements of a first resolution of the stored rendering output to generate a data element array representing a second resolution of the rendering output includes averaging the data elements of the first resolution. However, downsampling may include other suitable parsing operations as needed.

[0125] The data elements of the downsampled version of the rendered output can be written out in their original format. Alternatively, the array of data elements representing the second resolution of the rendered output can be written out in an encoded (compressed) format, as needed. Various suitable encoding schemes exist for this purpose.

[0126] In the technique described herein, a set of differences indicating the difference between data elements representing a first resolution of the rendered output and the generated array of data elements representing a second resolution of the rendered output, and a downsampled version of the rendered output are also described. This difference is configured such that the set of differences and the downsampled version of the rendered output together enable the recovery of a first higher resolution (multisampled) representation of the rendered output. Therefore, it should be appreciated that the data elements of the first higher resolution representation of the rendered output stored by the graphics processor during the processing of graphics primitives do not need to be written to memory at this time (and are not written to memory) and can be discarded.

[0127] In the techniques described herein, the difference can indicate the difference between data elements representing a first resolution of the rendered output and the generated array of data elements representing a second resolution of the rendered output in any suitable and desirable manner, making it possible to recover a first higher resolution representation of the rendered output using the difference.

[0128] In this implementation, the stored difference represents only the (signed) difference (increment) between the parsed data value and the following data value: the data value of the (multisampled) set of data elements to which the parsing (downsampling) operation was applied to obtain the parsed data value (e.g., for 4× MSAA, in this implementation, the difference data represents the difference between the parsed pixel value and the value of the 4× sample points associated with that pixel). Therefore, in this implementation, the difference set represents the difference between the downsampled data elements representing the second resolution of the rendered output and the stored data elements representing the first resolution of the rendered output.

[0129] Therefore, the difference data can be appropriately determined based on, for example, the level of multisampling applied and / or the parsing (downsampling) operation applied. For example, where the parsing operation involves averaging a set of multisampled values, the difference could thus be a set of differences (increments) from that average. However, other arrangements are of course possible, and the encoding of differences can be performed in more complex (or less complex) ways as needed. For example, differences relative to each other (and differences relative to the parsed data values) can also be encoded. In this case, one data element from the multisampled data elements (e.g., representing the first sampling position) can be considered as a reference value, and the difference (increment) relative to that reference value can then be calculated. Another example is calculating the difference relative to the median sample value.

[0130] The set of differences can be written in their original format or in an encoded (compressed) format.

[0131] The memory into which the downsampled version of the rendered output and the higher-resolution interpolation set are written can be any suitable and desired memory of the graphics processor (and graphics processing system), or any suitable and desired memory available to the graphics processor (and graphics processing system). In an embodiment, this memory is a suitable memory (main memory) of the graphics processor or a suitable memory (main memory) available to the graphics processor, for example, as part of an overall graphics processing system (data processing system) in which the graphics processor is a component. Thus, in an embodiment, the downsampled version of the rendered output and the higher-resolution interpolation set are written together to a suitable DRAM (or other main memory) of the overall graphics (data) processing system. Other arrangements are, of course, also possible.

[0132] Of course, a downsampled version of the rendered output can be written to the same or different memory as the higher resolution difference set, as long as they can be recovered together in an appropriate manner.

[0133] Similar to the lower-resolution version of the parsed render output and the high-resolution interpolation set, in this implementation, when the processing of the render output is stopped before the render output is completed, any other data structures that need to be restored when the processing of the render output is resumed are also appropriately written to memory.

[0134] Once the graphics processor stops processing the rendering output in question (and the data structures have been written to memory), the graphics processor can then perform other processing, such as some or all of the processing of another rendering output (such as different tiles of a frame).

[0135] Then, at a later point in time, the graphics processor will be triggered to resume processing of the rendering output, which has only been partially completed. Again, this resumption of processing of the rendering output can be triggered as needed, for example, based on the existence of a new data structure containing new data for the rendering output (e.g., tiles) now ready for processing, a background switch based on VR time warp, etc.

[0136] When resuming processing of the rendered output area, the graphics processor can operate to load a downsampled version of the rendered output and a higher resolution difference set from memory, and use the downsampled version and difference set to recreate (restore) the higher resolution version of the rendered output. The higher resolution version can then be loaded, for example, into the tile (color) buffer of the rendered output so that those buffers can be used when processing of the rendered output continues.

[0137] However, the applicant further recognizes that in some cases, when resuming the processing of the rendered output, it may not be necessary to load a downsampled version of the rendered output or a higher-resolution interpolation set from memory. This may be the case, for example, when the graphics processor is capable of determining whether any further graphics primitives of the rendered output require processing. If no further graphics primitives of the rendered output require processing, there is no need to load the data values ​​of that rendered output, and therefore this is not done in the implementation.

[0138] Therefore, in the implementation, the step of loading the data element array representing the second resolution of the rendering output and the determined difference set from the memory can be conditionally performed depending on whether there are other graphic primitives to be processed in the rendering output.

[0139] If no other primitives for the rendered output in question exist, the generation of the rendered output is thus completed. Therefore, there is no need to load (any) data from the rendered output back, saving storage bandwidth in this case. This works because, in the technique described herein, the necessary parsing operation has already been performed, i.e., the rendered output has been written in the desired parsed format while the generation of the rendered output is paused.

[0140] In one implementation, the step of loading the data element array representing the second resolution of the rendering output and the determined difference set from the memory includes: determining whether there are other primitives to be processed in the rendering output, and loading the data element array representing the second resolution of the rendering output and the determined difference set only when it is determined that there are other primitives to be processed in the rendering output.

[0141] It is reasonable to believe that this conditional loading of such data from memory is novel and has its own advantages.

[0142] Therefore, another embodiment of the technology described herein includes a method for operating a graphics processor when generating rendered output, the graphics processor comprising:

[0143] A rasterizer circuit that rasterizes input primitives to generate graphic fragments to be processed, each graphic fragment having a set of one or more sampling points associated with it; and

[0144] A renderer circuit that renders a graphic fragment generated by the rasterizer circuit to generate rendered fragment data of the graphic fragment, and the renderer circuit is operable to generate a first higher resolution data element array representing the rendered output, and when writing the rendered output, downsampling the first resolution data element array to generate a second lower resolution data element array representing the rendered output.

[0145] The method includes the following steps:

[0146] The graphics processor generates the rendering output by processing graphics primitives to generate a data element array representing the first resolution of the rendering output; and

[0147] Store data elements representing the first resolution of the rendered output;

[0148] The method further includes the following steps:

[0149] The graphics processor stops generating the rendering output, and while the graphics processor is doing so, it performs the following operations:

[0150] The stored data elements of the first resolution in the rendering output are downsampled to generate a data element array representing the second resolution of the rendering output;

[0151] Determine a set of differences, the set of differences indicating the differences between data elements representing the first resolution of the rendered output and the generated array of data elements representing the second resolution of the rendered output; and

[0152] The data element array representing the second resolution of the rendered output, together with the determined difference set, is written to memory; and

[0153] When the graphics processor is able to resume processing the rendered output, the graphics processor:

[0154] Determine whether there are other primitives in the rendered output that need to be processed; and when it is determined that there are other primitives in the rendered output that need to be processed,

[0155] Load the data element array representing the second resolution of the rendering output and the determined difference set, and use these data element arrays and difference sets when continuing the processing of the rendering output.

[0156] Another embodiment of the technology described herein includes a graphics processing system comprising a graphics processor, the graphics processing system comprising:

[0157] A rasterizer circuit that rasterizes input primitives to generate graphic fragments to be processed, each graphic fragment having a set of one or more sampling points associated with it; and

[0158] A renderer circuit that renders a graphic fragment generated by the rasterizer circuit to generate rendered fragment data of the graphic fragment, and the renderer circuit is operable to generate a first higher resolution data element array representing the rendered output, and when writing the rendered output, downsampling the first resolution data element array to generate a second lower resolution data element array representing the rendered output.

[0159] The graphics processor is configured to perform the following operations:

[0160] The rendering output is generated by processing graphic primitives to generate a data element array representing the first resolution of the rendering output; and

[0161] Store data elements representing the first resolution of the rendered output;

[0162] The graphics processor is also configured to perform the following operations when it stops generating the rendering output before completing the rendering output:

[0163] The stored data elements of the first resolution in the rendering output are downsampled to generate a data element array representing the second resolution of the rendering output;

[0164] Determine a set of differences, the set of differences indicating the differences between data elements representing the first resolution of the rendered output and the generated array of data elements representing the second resolution of the rendered output; and

[0165] The data element array representing the second resolution of the rendered output, together with the determined difference set, is written to memory; and

[0166] The graphics processor is also configured to, when the graphics processor is able to resume processing of the rendered output:

[0167] Determine if there are other primitives in the rendered output that need to be processed; and

[0168] When it is determined that there are other primitives to be processed for rendering output, a data array representing the second resolution of the rendering output and a determined set of differences are loaded, and these data arrays and sets of differences are used as the processing of the rendering output continues.

[0169] As will be apparent to those skilled in the art, these aspects of the technology described herein may and do indeed include any one or more or all of the optional features of the technology described herein in the implementation.

[0170] In these implementations, when it is determined that there are other primitives to be processed in the rendering output in question, i.e., when data does need to be loaded to recover a higher resolution version of the rendering output, for example, in the manner described above, when the generation of the rendering output (e.g., tiles) is to be recovered, a parsed version of the rendering output, along with differentially encoded multisamples for that parsed version, is read back from memory.

[0171] For example, the complete multisample values ​​can then be regenerated using the parsed (downsampled) face and multisample difference and stored in an appropriate (e.g., tile) buffer for (re)use when the output (e.g., the tile) is generated while continuing to render the output.

[0172] Then, when it is time to restart the processing of the rendering output, the parsed rendering output and difference data stored in memory are used to restore a higher resolution version of the rendering output that was in accordance with the actual situation at the moment when the generation of the rendering output stopped, and the restored (previously stored) parsed rendering output and difference data are used to generate a new version of the higher resolution rendering output for use when the rendering output is processed again.

[0173] In the case of a tile buffer, this can be accomplished, and in an implementation, by the following steps: loading the stored data elements from memory, reconstructing the higher-resolution version of the data elements of the rendered output using the difference data, and then loading the higher-resolution version of the rendered output back into the tile (e.g., color, etc.) buffer and the Z-buffer for use when processing the rendered output continues. Therefore, once the stored parsed data elements and differences are read in, a first higher-resolution version of the rendered output can then be appropriately reconstructed, for example, by adding the downsampled values ​​to the individual differences in the differences, where the differences are encoded in this manner.

[0174] This will accordingly recreate the tile buffer in the state it was in when processing of the rendering output was stopped. Therefore, in the case of pausing tile rendering, the techniques described herein can be used (and are used for) restoring the (multisampled) tile buffer of the tile in the implementation.

[0175] Previously saved data elements can be used to create a tile buffer for use when processing continues rendering the output in any appropriate and desired manner. In this implementation, DMA (direct memory access) processing is used to read in the stored data elements and differences, but other arrangements are of course possible. For example, the processing core (shader core) of the graphics processor can also perform the loading of the stored data elements and differences.

[0176] Similar to the current color (tile) buffer and Z buffer of the rendered output when processing of the rendered output is stopped, in the implementation, any other data structures that need to continue processing of the rendered output (e.g., tiles) are also restored from their previously saved values ​​in a timely and appropriate manner.

[0177] Once the color (tile) buffers and any other data structures of the rendering output being processed have been properly created (restored), the processing of the rendering output can then be resumed in the implementation. Therefore, once the data elements written to memory have been loaded and used to reconstruct a higher-resolution version of the rendering output for use while continuing the processing of the rendering output, the graphics processor will resume the processing of the primitives of the rendering output, including properly rasterizing and rendering the primitives, in order to continue generating the rendering output.

[0178] Therefore, upon receiving a new primitive to be processed, the first higher resolution rendering output (e.g., the first higher resolution rendering output stored in the tile buffer) is updated. Then, as described above, if rendering of the associated tile is paused again, the updated tile buffer and the updated difference dataset can be written out again (and / or once the rendering of the tile is complete, in which case there is no need to write out the difference data (although it can still be written out, but it will then be discarded)).

[0179] Therefore, in this implementation, after loading back the downsampled data elements representing the second resolution of the rendered output and the associated differences from memory, as well as the rendered output for reconstructing the first resolution (i.e., refilling the tile buffer), the generation of the rendered output continues through the following steps: processing new graphics primitives to store the new data elements of the first resolution of the rendered output, thereby updating the rendered output of the first resolution (updating the tile buffer). If the graphics processor stops generating the rendered output, the data elements of the first resolution of the updated rendered output are then downsampled to determine the updated data elements representing the second resolution of the rendered output, and an updated set of differences is determined. This updated set of differences and the downsampled data elements are then written out, for example, in the same manner as described above, so that the rendered output of the first resolution can be recovered when the graphics processor resumes processing the rendered output.

[0180] As can be appreciated from the above, at least in the implementation, the techniques described herein will involve partially processing a first rendering output (e.g., a tile), then pausing the processing of the first rendering output while processing another rendering output (e.g., a tile), and then resuming the processing of the first rendering output, and so on, for example, in which switching repeatedly occurs between processing different rendering outputs.

[0181] Therefore, in implementation, the method of the technique described herein includes (and the graphics processor is configured accordingly):

[0182] The graphics processor stops processing the first rendering output, and while the graphics processor does so, it performs the following operations:

[0183] The stored data elements of the first resolution in the first rendering output are downsampled to generate a data element array representing the second resolution of the first rendering output;

[0184] A set of differences is determined, indicating the difference between the data elements representing the first resolution of the first rendered output and the generated array of data elements representing the second resolution of the first rendered output; and

[0185] The data element array representing the second resolution of the first rendering output, along with the determined difference set, is written to memory; and

[0186] After stopping the processing of the first rendering output, the following operations are performed:

[0187] The primitives are processed to generate different second rendering outputs; the primitives are also processed to generate a data element array representing the first resolution of the second rendering output; and

[0188] Store data elements representing the first resolution of the second rendering output;

[0189] The graphics processor stops processing the second rendering output, and while the graphics processor does so, it performs the following operations:

[0190] The stored data elements of the second rendering output at the first resolution are downsampled to generate a data element array representing the second resolution of the second rendering output;

[0191] A set of differences is determined, indicating the difference between the data elements representing the first resolution of the second rendered output and the generated array of data elements representing the second resolution of the second rendered output; and

[0192] Write the data element array representing the second resolution of the second rendering output, together with the determined set of differences, to memory.

[0193] When the generation of the second output is stopped, the graphics processor can then switch back to processing the first rendering output as needed, and so on.

[0194] In this case, in the implementation, the first rendering output and the second rendering output include corresponding different tiles of the overall rendering output being generated (loaded frames to be displayed).

[0195] Accordingly, the processing of two or more render outputs (e.g., tiles) can be interleaved in this way. Similarly, the processing of a given render output can be stopped and resumed multiple times (more than once), for example, until the render output has been completed.

[0196] Like rasterizers and renderers, a graphics processor and the graphics processing pipeline it executes may include, and should include, other processing circuitry and stages typically present in the graphics processor and processing pipeline, such as tile buffers (and other buffers), depth testers, write-back units, mixers, etc.

[0197] The graphics processor may also include, and in some embodiments, one or more memory and / or memory devices for storing data described herein (such as fragment data, rendered fragments and output data, difference data, and other state information) and / or storing software for performing the processing described herein, and / or communicating with said one or more memory and / or memory devices. The graphics processor may also communicate with a host microprocessor and / or with a display for displaying images based on data generated by the graphics processor.

[0198] The techniques described herein can be used regardless of the form of output that the graphics processor can provide. Thus, for example, they can be used when the rendered output is intended to form an image (frame) for display (e.g., on a screen or printer) (and this is the case in the implementation). However, the techniques described herein can also be used when the rendered output is not intended for display, for example, when the rendered output is a texture that the graphics processor is using to generate (e.g., in a "render to texture" operation), or, in fact, when the output that the graphics processor is using to generate is any other form of data array.

[0199] The various functions of the technology described herein can be performed in any desired and suitable manner. For example, the functions of the technology described herein can be implemented in hardware or software as needed. Thus, for example, the various functional components, processing levels, and "means" of the technology described herein can include suitable one or more processors, one or more controllers, functional units, circuits, circuit systems, processing logic, microprocessor layouts, etc., capable of operating to perform various functions, such as dedicated hardware components (processing circuits / circuit systems) and / or programmable hardware components (processing circuits / circuit systems) that can be programmed to operate in a desired manner.

[0200] It should also be noted that, as those skilled in the art will recognize, the various functions of the techniques described herein can be copied and / or executed in parallel on a given processor. Similarly, various processing levels can share processing circuitry / circuit systems, etc., if desired.

[0201] The techniques described herein can be applied to graphics processing unit (GPU) systems, GPUs, and GPU pipelines of any suitable form or configuration. The techniques described herein are particularly applicable to tile-based GPUs and GPU systems. Thus, in this embodiment, the GPU is a tile-based GPU.

[0202] For any hardware subject necessary to perform the specific functions discussed above, a graphics processor may otherwise include one or more or all of the common functional units, circuits, etc., included in that graphics processor.

[0203] Those skilled in the art should also recognize that all the described embodiments of the technology herein may, where appropriate, include any one or more or all of the optional features described herein.

[0204] The methods described herein can be implemented at least in part using software (e.g., computer programs). Thus, it can be seen that, when viewed from other embodiments, the techniques described herein include: computer software, which, when installed on a data processor, is specifically adapted to perform the methods described herein; a computer program component including computer software code for performing the methods described herein when the program component is run on a data processor; and a computer program including code adapted to perform all steps of the methods described herein, or all steps of one of the methods, when the program is run on a data processing system. The data processing system may be a microprocessor, a programmable FPGA (Field-Programmable Gate Array), etc.

[0205] The techniques described herein are also extended to computer software carriers that, when used to operate a graphics processor, renderer, or microprocessor system including a data processor, cause the steps of the methods described herein to be performed in conjunction with said data processor, said processor, renderer, or system. Such computer software carriers can be physical storage media, such as ROM chips, CD-ROMs, RAM, flash memory, or disks, or they can be signals, such as electronic signals transmitted through wires, optical signals such as satellite signals, or radio signals.

[0206] It should also be recognized that not all steps of the methods described herein require execution by computer software, and thus, according to another broad implementation, the techniques described herein include computer software for performing at least one step of the methods set forth herein and such software installed on a computer software carrier.

[0207] Therefore, the techniques described herein can be suitably implemented as computer program products for use with computer systems. Such implementation may include a series of computer-readable instructions fixed on a tangible medium such as a non-transitory computer-readable medium (e.g., floppy disk, CD-ROM, ROM, RAM, flash memory, or hard disk). Such implementation may also include a series of computer-readable instructions that can be invisibly transmitted to a computer system via a modem or other interface device through a tangible medium (including, but not limited to, optical or analog communication lines) or using wireless technologies (including, but not limited to, microwave, infrared, or other transmission technologies). This series of computer-readable instructions specifically implements all or part of the functions previously described herein.

[0208] Those skilled in the art will recognize that such computer-readable instructions can be written in many programming languages ​​for use with many computer architectures or operating systems. Furthermore, such instructions can be stored using any current or future memory technology (including, but not limited to, semiconductor, magnetic, or optical memory technologies) or transmitted using any current or future communication technology (including, but not limited to, optical, infrared, or microwave communication technologies). It is envisioned that such computer program products can be distributed as removable media (e.g., shrink-wrapped software) with accompanying printed or electronic documentation, pre-installed with computer systems (e.g., on system ROM or a fixed disk), or distributed from servers or electronic bulletin boards via networks (e.g., the Internet or the World Wide Web).

[0209] Several implementations of the technology described herein will now be described.

[0210] When displaying computer graphics, they are typically first defined as a series of primitives (polygons), which are then sequentially divided (rasterized) into graphic segments for rendering. During normal graphics rendering, the renderer modifies the color (red, green, and blue, RGB) and transparency (alpha, a) data associated with each segment to ensure that the segment is displayed correctly. Once the segment has been fully processed by the renderer, its associated data values ​​are stored in memory, ready for output for display.

[0211] This embodiment specifically relates to facilitating anti-aliasing operations, particularly when displaying computer graphics images. Anti-aliasing is performed by acquiring multiple samples of the image to be displayed and then downsampling those samples to the output resolution of the display.

[0212] Figure 3 (This schematically illustrates the basic anti-aliasing arrangement used in this embodiment.) It shows that the sampling mask 34 is repeatedly applied to the image to be displayed. Each application of the sampling mask 34 corresponds to a pixel of the image to be displayed.

[0213] Each sampling mask includes a set of sampling points that will be used to sample the image of the output pixel in question and, accordingly, determine how that pixel should be displayed on the final display.

[0214] Figure 3 An image is also shown as a single primitive 32 overlaid on the sampling mask array 30. (It should be appreciated here that, for simplicity, in...) Figure 3 The image has been shown as comprising a single primitive. In reality, an image (or other output) may, and often will, comprise many overlapping primitives. (As can be seen from...) Figure 3As can be seen, primitive 32 covers some of the sampling masks in the sampling mask array 30, but only passes through a portion of some other sampling masks.

[0215] In order to process primitive 32 of the image, the rendering system essentially determines at the rasterization level which sampling points in each sampling point set of each sampling mask application are covered by primitive 32, and then renders and stores the data of those covered sampling points so that the image of primitive 32 can be correctly displayed on the display device.

[0216] Now, refer to Figure 4 The image processing of the primitive 32 displayed in this manner in this embodiment is described. Figure 4 A graphics processing pipeline 1 that can operate according to the techniques described herein is illustrated schematically. Figure 4 The graphics processing pipeline 1 shown is a tile-based renderer that generates tile arrays of render output data, such as the output frames to be generated. (As those skilled in the art will appreciate, other rendering arrangements may be used if desired.)

[0217] (In tile-based rendering, instead of efficiently rendering the entire output (e.g., a frame) all at once in immediate mode, the output (e.g., a frame to be displayed) is divided into multiple smaller sub-regions, commonly referred to as "tiles". Each tile (sub-region) is rendered individually (usually one after another), and then the rendered tiles (sub-regions) are recombined to provide the complete output, such as a frame for display. In such an arrangement, the output is typically divided into sub-regions (tiles) of regular size and shape (which are typically squares or rectangles, for example), but this is not necessary.)

[0218] The render output data array can typically be an output frame intended to be displayed on a display device (such as a screen or printer), but it can also include, for example, intermediate data intended to be used in a later rendering pass (also known as "render to texture" output).

[0219] Figure 4 The main components and pipeline stages of the graphics processing pipeline 1 related to the operation of this embodiment are shown. As those skilled in the art will appreciate, there may be... Figure 4 Other components of the graphics processing pipeline not shown in the examples. It should also be noted here that... Figure 4 This is merely illustrative, and in practice, for example, the functional units and pipeline stages shown can share effective hardware circuitry / systems, even when... Figure 4 They are schematically shown as separate levels. It should also be recognized that, as Figure 4Each of the stages, components, and units in the illustrated graphics processing pipeline can be implemented as needed, and accordingly, for example, includes appropriate circuitry / circuit systems and / or processing logic for performing the necessary operations and functions.

[0220] Figure 4 The pipeline stage is schematically shown after the generation of graphic primitives (polygons) 2 for input to rasterization processing. Thus, at this point, the graphic data (vertex data) has undergone fragment front-end operations 8 (such as transformation and lighting operations (not shown)) and a primitive setting stage (not shown) to set the primitives to be rendered in response to commands and vertex data provided to the graphics processor.

[0221] like Figure 4 As shown, this part of the graphics processing pipeline 1 includes multiple stages, including rasterization stage 3, early Z (depth) and stencil test stage 4, fragment shader 6, late Z (depth) and stencil test stage 7, blending stage 9, tile buffer 10, and downsampling and write-back (multi-sample parsing) stage 11.

[0222] In particular, Figure 4 The diagram schematically illustrates the operation of graphics pipeline 1 when performing 4× MSAA (however, of course, any desired level of MSAA can be applied, such as 8x, 16x, etc.). Therefore, as... Figure 4 As shown, due to the performance of 4×MSAA, rasterizer 3 takes a sample mask with four sampling locations (i.e., a 4× sample mask) for the output application to be generated (test) and associates the individual fragments it generates for rendering with a set of four sample points corresponding to the sample mask for a given application. In other words, a single fragment is used to render all four sample points in the sample point set of a given application that co-render the sample mask (and the corresponding pixels in the output) at once.

[0223] Therefore, in this example, we consider including Figure 3 The image of primitive 32 shown is received by rasterizer 3 from the fragment front-end processing stage 8 of the graphics processing system. Rasterizer 3 then determines which sets of sample points in the image (i.e., which applications of the sample mask 34 in array 30) include sample points covered by primitive 32. (This can be performed in any suitable manner known in the art.) Rasterizer 3 then generates fragments for each application of the sample mask found to include sample points covered by primitive 32. Thus, rasterizer 3 generates fragments associated with sets of four sample points. The rasterizer then outputs those fragments to subsequent stages of the graphics processing pipeline 1 for processing.

[0224] The rasterization stage 3 of the graphics processing pipeline 1 operates to rasterize the primitives (e.g., the image to be displayed) that make up the rendering output into individual graphic fragments for processing. To do this, the rasterizer 3 receives the graphic primitives 2 for rendering, rasterizes the primitives for sampling points, and generates graphic fragments with appropriate positions (representing appropriate sampling positions) for rendering the primitives.

[0225] In this embodiment, the sample tester of rasterizer 3 is configured to test a sample mask containing four sample points per clock cycle (i.e., actually test the set of four sample points that will be associated with the fragment if at least one of these four sample points is within the primitive, then the fragment will be generated for the set of these four sample points), and thus rasterizer 3 “naturally” supports 4× MSAA.

[0226] The rasterizer generates fragments for each application that is found to include primitives in the sampled mask. These fragments are then forwarded to the rest of the pipeline for processing.

[0227] As is known in the art, the early Z / stencil level 4 performs a Z (depth) test on the fragments it receives from rasterizer 3 to see if any fragments can be discarded (culled) at this level. To do this, the early Z / stencil level compares the depth values ​​of the fragments (and their associated fragments) emitted from rasterizer 3 with the depth values ​​of already rendered fragments (which are stored in a depth (Z) buffer as part of tile buffer 10) to determine whether new fragments will be occluded (or not) by already rendered fragments. Simultaneously, an early stencil test is performed.

[0228] The early depth and template test 4 is configured to perform depth and template tests on four samples per clock cycle, and therefore "naturally" supports 4× MSAA.

[0229] Then, the fragment that passes the early Z-test and stencil test at level 4 is sent to fragment shading level 6. Fragment shading level 6 performs appropriate fragment processing operations on the fragment that passes the early Z-test and stencil test in order to process the fragment and generate appropriate fragment data, etc., for rendering output (e.g., for displaying the fragment).

[0230] This fragment processing can include any suitable and desired fragment shading processing, such as executing a fragment shader program on the fragment, applying textures to the fragment, applying fog to the fragment, or other operations to generate appropriate fragment data. In this embodiment, fragment shading level 6 takes the form of a shader pipeline (programmable fragment shader). However, it is also possible, as needed, to use fixed-function fragment shading units or other arrangements that replace fixed-function shading units.

[0231] Fragment shader 6 is configured to process all sample points associated with the fragments it receives in parallel, that is, to process the individual fragments it receives as a whole.

[0232] Fragment coloring level 6 has an associated variation interpolator (variation position evaluator) 12, which is used to determine the correct variation value for the current fragment. For some interpolation modes, such as centroid mapping, the variation interpolator uses the fragment's associated overlay mask to select the correct position within the fragment to interpolate the varied data. Therefore, the variation interpolator 12 is configured to process all sample points associated with the received fragment in parallel, so as to select the correct interpolation position for centroid mapping, regardless of whether the fragment has four or eight associated sample points.

[0233] Then, there is a "post-processing" fragment Z and stencil test level 7, which performs a pipeline depth test, specifically for the shaded fragment, to determine whether the rendered fragment is actually visible in the final image. This depth test uses a Z-buffered value to determine whether the fragment data of the new fragment should replace the fragment data of the already rendered fragment, by comparing the depth value of the fragment (and its associated value) emanating from fragment shader level 6 with the depth value of the already rendered fragment (e.g., stored in a depth buffer), for the position of the fragment stored in the Z-buffer of tile buffer 10. This post-processing fragment depth and stencil test level 7 also performs any necessary "post-processing" alpha and / or stencil tests on the fragment.

[0234] The later depth and template test level 7 is also configured to perform depth and template tests on four samples per clock cycle, and thus "naturally" supports 4× MSAA.

[0235] Then, as needed, the fragments that have passed the later fragment test stage 7 are subjected to any necessary blending operations in the mixer 9 along with the fragments already stored in the tile buffer 10. Any other remaining operations necessary for the fragments (such as dithering, etc.) (not shown) are also performed at this stage.

[0236] Mixer 9 is configured to mix four samples per clock cycle, and thus "naturally" supports 4× MSAA.

[0237] Finally, the (mixed) output fragment data (values) are written to tile buffer 10, from which they can be output, for example, to frame buffer for display. The depth values ​​of the output fragments are also appropriately written to the Z buffer within tile buffer 10. (The tile buffer and Z buffer will respectively store the appropriate color, etc., or Z value, of each sample point (essentially, each sample point of the tile being processed) represented by the buffer.) The tile buffer stores a batch of fragment data representing a portion of the rendered output (e.g., an image to be displayed).

[0238] In this embodiment, three tile buffers are provided. Each tile buffer stores its fragment data (i.e., a 32 × 32 array corresponding to the sampling positions in the output to be generated (e.g., in the image to be displayed) in a 32 × 32 array). Each 32 × 32 data position tile buffer can corresponding to (and will “naturally” support) a 16 × 16 pixel “tile” of a frame to be displayed, for example, with a 4× anti-aliasing effect (i.e., 4 samples per pixel).

[0239] These tile buffers can be set as separate buffers, or they can actually all be part of the same larger buffer. They reside on the graphics processing pipeline (on the chip) (locally).

[0240] In this implementation, two of the three tile buffers are used to store the color (red, green, blue) values ​​of each sample point (one tile buffer could be used for this, but two might be better), and one tile buffer is used to store the Z (depth) value and template value of each sample point. Other arrangements are, of course, also possible.

[0241] Data from tile buffer 10 is input to downsampling (multi-sample parsing) unit 11 and output (written back) from there to output buffer 13 (which may not be on the graphics processing platform itself), such as the frame buffer (not shown) of a display device. (The display device may, for example, include a display comprising a pixel array, such as a computer monitor or printer.)

[0242] The downsampling unit 11 downsamples the fragment data stored in the tile buffer 10 to an appropriate resolution of the output buffer (device) (i.e., to generate a pixel data array corresponding to the pixels of the output device) to generate an output value (pixel) 14 for output to the output buffer 13.

[0243] The downsampling unit 11 in the graphics processing pipeline 1 of this embodiment is configured to downsample four sampling position values ​​from the tile buffer 10 to a single output value 14, for example, for output to the output buffer 13, in one downsampling operation (clock cycle). Therefore, in this embodiment, the downsampling and write-back unit 11 is configured to "naturally" support 4× anti-aliasing.

[0244] This downsampling can be performed in any suitable manner. In this embodiment, linear mixing of the data is used to downsample the data. However, other arrangements are also possible as needed. If required, the downsampling unit 11 can also apply appropriate gamma correction to the data output to the output buffer 13, or this can be done, for example, as a fragment coloring operation or in any other suitable and desired manner.

[0245] Once a tile of the rendered output has been processed and its data has been exported to main memory (e.g., a frame buffer in main memory (not shown)) for storage, the next tile is processed, and so on, until enough tiles have been processed to generate the full rendered output (e.g., a frame (image) to be displayed).

[0246] Other arrangements for the graphics processing pipeline 1 are of course possible. For example, while the graphics processing pipeline 1 described above is configured to "naturally" support 4× multisampling, it is common practice to configure the graphics processing pipeline 1 to support various levels of multisampling / oversampling in a similar manner.

[0247] Implementations of the techniques described herein will now be described in more detail. This implementation particularly relates to the operation of a tile-based graphics processor operating a graphics processing pipeline 1, for example, as described above, when the processing of a tile being rendered is interrupted, making it necessary to resume the processing at a later time.

[0248] This is exemplified by incrementally rendering tiles (e.g., using multiple passes per tile), where multiple passes of a tile are scattered throughout the processing of other tiles. This operation can occur, for example, when the amount of data that can be generated to process a tile is limited, such that tile processing only begins after some, but not all, of the data required to fully process the tile has been generated, and that tile processing must be paused once the initially generated data structure has been used, resumed when further data for processing the tile is generated, and once more data for processing the tile has been generated, and so on. This operation can be repeated for multiple tiles that make up the overall rendering output (e.g., a frame to be displayed).

[0249] therefore, Figure 5The left side illustrates the processing of tiles during a single such processing pass. As shown, during this processing pass (step 50: "Is this processing pass finished? – No"), a drawing call to be processed is received (step 51), and then the primitives within the drawing call are processed, for example, in the manner described above (step 52), fragment data (color, etc., and depth) is generated and then written into the tile buffer 10 (step 53).

[0250] At the end of the current processing pass (step 50: "Is the current processing pass finished? – Yes") (this may not be the end of processing for the tile in question, and in this embodiment it is not the end of processing for the tile in question, so that rendering of the tile is merely paused to resume at a later time), the data currently stored in the tile buffer 10 is then passed to the write-back (multi-sample parsing) stage 11, which then parses the data in the tile buffer according to the current situation (step 54). Then, a full resolution difference set is calculated, representing the difference between the parsed data (from step 54) and the data currently stored in the tile buffer (step 55). Then, the parsed buffer is written to memory (step 56), and the difference dataset is written out (step 57).

[0251] Therefore, when rendering of a tile is paused, partial parsing is performed on the data currently stored in tile buffer 10, and then the parsed face is written to memory along with the difference dataset for the full resolution of the parsed face, so that the full tile buffer can then be reconstructed (e.g., instead of trying to write the data values ​​from tile buffer 10 in a complete manner at the multisampled resolution).

[0252] That is, such as Figure 6 As shown, at the moment the rendering of the tile is paused, the complete multisampled data value S stored in the tile buffer 10 is not written out. 0,0 S 0,1 Instead of writing out the parsed pixel values ​​R0, R1, etc. at a lower resolution, the difference (δ) between these values ​​and the full resolution is written out. 0,0 δ 0,1 This allows for the reconstruction of the complete multisampled data value S. 0,0 S 0,1 For example, in cases where the parsing operation includes averaging, the parsed pixel value R0 is the sum of four sample points S associated with the display pixel having pixel value R0. 0,0 S 0,1 S 1,0 S 1,1 The average value is calculated, and the difference is calculated as the increment of the average value R0.

[0253] Therefore, in this case, the parsed pixel value 66 is added to the difference array 67, thereby enabling the reconstruction of the multisampled data value 63 at full resolution. However, other arrangements are also possible, depending on the parsing operation and / or how the differences are encoded.

[0254] like Figure 7 As shown, when processing of the tile in question resumes (step 70), the stored data can be loaded from memory (step 73) and used accordingly to restore the multisampled tile buffer (step 74). Specifically, when resuming tile processing, the parsed data and the full-resolution difference can be read back together and used to restore the full-resolution tile buffer, which is then used when continuing to generate the rendering output (step 75). Therefore, when other primitives to be processed are received, these primitives are appropriately rasterized and rendered to update the tile buffer, and the updated tile buffer is then finally passed to the downsampling unit to generate the rendering output (either during the next pause in rendering output generation or upon completion of tile processing).

[0255] At the moment the generation of rendering output is paused, the graphics processor may not know which tiles (if any) have been rendered. Therefore, in this embodiment, the parsed buffer and difference data are always written at this moment.

[0256] However, it is possible that the rendering of individual tiles has actually been completed at this moment (but this has not yet been determined).

[0257] Therefore, in this embodiment, the graphics processor is able to operate to detect whether a single block has any other primitives to be rendered. If no other primitives exist, there is no need to load a full-resolution sample into the block buffer. Thus, in this embodiment, when the graphics processor is able to resume processing of a block or block set, it checks whether there are any further graphics primitives to be rendered for that block (or block set). If not (step 71 – “No”), the block processing is completed (step 72), and no data needs to be loaded from memory. On the other hand, if there are additional primitives to be processed (step 71 – Yes), processing is resumed, for example, as described above.

[0258] In fact, the advantage of this implementation is that, since the parsing operation is performed when the generation of rendering output is paused, there is no need to load the data back from memory when the data is not actually needed, thus saving bandwidth.

[0259] This allows for pausing / resumpting rendering output generation as needed, while reducing storage bandwidth requirements. For example, when tile rendering is paused, the full-resolution data value is not written to memory and can be discarded at that moment. If there are other primitives to be processed for the tile in question, the parsed data and the difference can be loaded back and used to repopulate the full-resolution tile buffer to continue rendering the tile. On the other hand, if there are no other primitives to be processed, rendering is complete because the parsing operation has already been performed.

[0260] The foregoing detailed description has been presented for purposes of illustration and description. It is not intended to be exclusive or to limit the technology described herein to the precise forms disclosed. Many modifications and variations are possible in light of the foregoing teachings. The described embodiments were chosen to best illustrate the principles of the technology described herein and its practical application, thereby enabling others skilled in the art to best utilize the technology described herein in various embodiments and with various modifications as suited to the intended particular use. The scope of protection is intended to be defined by the appended claims.

Claims

1. A method of operating a graphics processor in generating a rendered output, the graphics processor comprising: rasteriser circuitry to rasterise inputted graphics primitives to generate graphics fragments to be processed, each graphics fragment having associated therewith a set of one or more sample points; and renderer circuitry to render graphics fragments generated by the rasteriser circuitry to generate rendered fragment data for the graphics fragments, and operable to generate an array of data elements representing a higher first resolution of the rendered output, and, in writing out the rendered output, to downsample the array of data elements of the first resolution to generate an array of data elements representing a lower second resolution of the rendered output; the method comprising the steps of: the graphics processor generating the rendered output by processing graphics primitives to generate the array of data elements representing the first resolution of the rendered output; and storing data elements representing the first resolution of the rendered output; the method further comprising the steps of: the graphics processor ceasing to generate the rendered output, and, in doing so: downsampling the stored data elements of the first resolution of the rendered output to generate the array of data elements representing the second resolution of the rendered output; determining a set of difference values indicative of differences between the data elements representing the first resolution of the rendered output and the generated array of data elements representing the second resolution of the rendered output; and writing out the array of data elements representing the second resolution of the rendered output to a memory together with the determined set of difference values; and the graphics processor resuming processing of the rendered output; and, in doing so: loading from the memory the array of data elements representing the second resolution of the rendered output and the determined set of difference values; using the loaded array of data elements of the second resolution and the loaded set of difference values to reconstruct the array of data elements representing the first resolution of the rendered output; and using the reconstructed array of data elements representing the first resolution of the rendered output when resuming processing of the rendered output.

2. The method of claim 1, wherein, the step of loading from the memory the array of data elements representing the second resolution of the rendered output and the determined set of difference values comprises first determining whether there are further graphics primitives of the rendered output to be processed, and, in determining that there are further graphics primitives of the rendered output to be processed, loading the array of data elements representing the second resolution of the rendered output and the determined set of difference values; whereas, in determining that there are not further graphics primitives of the rendered output to be processed, the graphics processor does not load from the memory the array of data elements representing the second resolution of the rendered output or the determined set of difference values.

3. The method of claim 1, wherein, The set of difference values represents a difference between the data elements at the second resolution representing the rendered output and the stored data elements at the first resolution representing the rendered output.

4. The method of claim 1, wherein, The array of data elements at the first resolution represents a multi-sampled version of the rendered output, wherein a plurality of sample locations are stored for each display pixel in the rendered output.

5. The method of claim 4, wherein, The array of data elements at the second resolution represents a single-sampled version of the rendered output, wherein a data element in the array of data elements at the second resolution representing the rendered output corresponds to a display pixel in the rendered output.

6. The method of claim 1, wherein: the graphics processor is triggered to stop processing the rendered output because a current data structure of the rendered output being processed is exhausted; and the graphics processor is triggered to resume processing the rendered output because there is a new data structure of the rendered output being processed that contains new data.

7. The method of claim 1, wherein, The rendered output to be generated comprises a tile of an overall output being generated by the graphics processor.

8. The method of claim 1, comprising the steps of: The graphics processor stops processing a first rendered output, and while the graphics processor is doing so: down-samples the stored data elements at the first resolution for the first rendered output to generate an array of data elements at the second resolution representing the first rendered output; determines a set of difference values indicating a difference between data elements at the first resolution representing the first rendered output and the generated array of data elements at the second resolution representing the first rendered output; and writes out the array of data elements at the second resolution representing the first rendered output to memory along with the determined set of difference values; and after stopping processing of the first rendered output, the graphics processor: processes primitives to generate a different second rendered output, the primitives being processed to generate an array of data elements at the first resolution representing the second rendered output; and stores data elements at the first resolution representing the second rendered output; The graphics processor stops processing the second rendered output, and while the graphics processor is doing so: down-samples the stored data elements at the first resolution for the second rendered output to generate an array of data elements at the second resolution representing the second rendered output; determines a set of difference values indicating a difference between data elements at the first resolution representing the second rendered output and the generated array of data elements at the second resolution representing the second rendered output; and writes out the array of data elements at the second resolution representing the second rendered output to memory along with the determined set of difference values.

9. The method of claim 1, wherein, The step of continuing processing of the rendered output comprises receiving new primitives of the rendered output to be processed, and storing updated data elements at the first resolution for the rendered output, The method further includes a step of the graphics processor secondarily stopping generation of the render output, and when the render output is secondarily stopped from being generated, the graphics processor downsamples the stored updated data elements of the first resolution of the render output to determine data elements representing the second resolution of the render output, determines an updated set of difference values representing a difference between the downsampled data elements representing the second resolution of the render output and the stored data elements of the first resolution of the render output, and writes the downsampled data elements representing the second resolution of the updated render output to memory along with the determined updated set of difference values.

10. A non-transitory computer readable storage medium storing computer software code that, when executed on a processor, performs a method of operating a graphics processor, the graphics processor comprising: rasterizer circuitry that rasterizes input primitives to generate graphics fragments to be processed, each graphics fragment having a set of one or more sample points associated with the graphics fragment; and renderer circuitry that renders graphics fragments generated by the rasterizer circuitry to generate rendered fragment data for the graphics fragments, and the renderer circuitry is operable to generate an array of data elements representing a higher first resolution of a render output, and when the render output is written out, downsample the array of data elements of the first resolution to generate an array of data elements representing a lower second resolution of the render output; the method of operating the graphics processor comprising the steps of: the graphics processor generating the render output by processing graphics primitives to generate an array of data elements representing the first resolution of the render output; and storing the data elements representing the first resolution of the render output; the method further comprising the steps of: the graphics processor stopping generation of the render output, and when the graphics processor does so, the following operations are performed: downsampling the stored data elements of the first resolution of the render output to generate an array of data elements representing the second resolution of the render output; determining a set of difference values indicating a difference between the data elements representing the first resolution of the render output and the generated array of data elements representing the second resolution of the render output; and writing the array of data elements representing the second resolution of the render output to memory along with the determined set of difference values; and the graphics processor resuming processing of the render output; and when the graphics processor does so, the following operations are performed: loading the array of data elements representing the second resolution of the render output and the determined set of difference values from the memory; reconstructing an array of data elements representing the first resolution of the render output using the loaded array of data elements at the second resolution and the loaded set of difference values; and when resuming processing of the render output, using the reconstructed array of data elements representing the first resolution of the render output.

11. A graphics processing system comprising a graphics processor, the graphics processing system comprising: rasterizer circuitry to rasterize input primitives to generate graphics fragments to be processed, each graphics fragment having a set of one or more sample points associated with the graphics fragment; and renderer circuitry to render graphics fragments generated by the rasterizer circuitry to generate rendered fragment data for the graphics fragments, and operable to generate an array of data elements representing a higher first resolution of a render output, and when writing out the render output, downsample the array of data elements at the first resolution to generate an array of data elements representing a lower second resolution of the render output; the graphics processor configured to: generate a render output by processing graphics primitives to generate an array of data elements representing the first resolution of the render output; and store data elements representing the first resolution of the render output; the graphics processor further configured to, when the graphics processor stops generating the render output before completion of the render output: downsample the stored data elements at the first resolution of the render output to generate an array of data elements representing the second resolution of the render output; determine a set of difference values indicative of differences between the data elements representing the first resolution of the render output and the generated array of data elements representing the second resolution of the render output; and write out the array of data elements representing the second resolution of the render output to a memory together with the determined set of difference values; and the graphics processor further configured to, when the graphics processor resumes processing of a previously stopped render output: load the array of data elements representing the second resolution of the render output and the determined set of difference values from the memory; reconstruct an array of data elements representing the first resolution of the render output using the loaded array of data elements at the second resolution and the loaded set of difference values; and when resuming processing of the render output, use the reconstructed array of data elements representing the first resolution of the render output. the graphics processor configured to, when loading the array of data elements representing the second resolution of the render output and the determined set of difference values from the memory, first determine whether there are further graphics primitives of the render output to be processed, and when it is determined that there are further graphics primitives of the render output to be processed, load the array of data elements representing the second resolution of the render output and the determined set of difference values; 12. The system of claim 11, wherein, the graphics processor further configured to, when resuming processing of the render output: reconstruct an array of data elements representing the first resolution of the render output using the loaded array of data elements at the second resolution and the loaded set of difference values; and when resuming processing of the render output, use the reconstructed array of data elements representing the first resolution of the render output. And the graphics processor does not load from the memory a data element array representing the second resolution of the render output or the determined set of difference values when it is determined that there are no other graphics primitives of the render output pending processing.

13. The system of claim 11, wherein, The set of difference values represents a difference between a data element representing the second resolution of the render output and a stored data element representing the first resolution of the render output.

14. The system of claim 11, wherein, The data element array at the first resolution represents a supersampled render output, wherein data elements of the data element array at the first resolution correspond to a plurality of supersampled sample points.

15. The system of claim 11, wherein, The data element array at the second resolution represents a resolved render output, wherein data elements of the data element array at the second resolution correspond to display pixels in the render output.

16. The system of claim 11, wherein: the graphics processor stops processing the render output triggered by an exhaustion of pending data structures of the render output being processed; And the graphics processor resumes processing the render output triggered by a presence of a new data structure of the render output ready for processing containing new data.

17. The system of claim 11, wherein, The render output pending generation comprises a tile of an overall output being generated by the graphics processor.

18. The system of claim 11, comprising: The graphics processor stops processing of a first render output, and when the graphics processor does so, the following is done: downsampling stored data elements of the first resolution of the first render output to generate a data element array representing the second resolution of the first render output; determining a set of difference values indicating a difference between data elements representing the first resolution of the first render output and the generated data element array representing the second resolution of the first render output; And writing out the data element array representing the second resolution of the first render output to memory along with the determined set of difference values; And after stopping processing of the first render output, the following is done: processing primitives to generate a different second render output, the primitives processed to generate a data element array representing the first resolution of the second render output; And storing data elements representing the first resolution of the second render output; The graphics processor stops processing of the second render output, and when the graphics processor does so, the following is done: downsampling stored data elements of the first resolution of the second render output to generate a data element array representing the second resolution of the second render output; determining a set of difference values indicating a difference between data elements representing the first resolution of the second render output and the generated data element array representing the second resolution of the second render output; And writing out the data element array representing the second resolution of the second render output to memory along with the determined set of difference values.

19. The system of claim 11, wherein, continuing processing of the render output includes receiving a new primitive of the render output to be processed and storing updated data elements of the first resolution of the render output, the graphics processor is further configured to secondarily stop generation of the render output and, when generation of the render output is secondarily stopped, to downsample the stored updated data elements of the first resolution of the render output to determine data elements representing the second resolution of the render output, determine an updated set of difference values representing a difference between the downsampled data elements representing the second resolution of the render output and the stored data elements of the first resolution of the render output, and write the downsampled data elements representing the second resolution of the updated render output to memory along with the determined updated set of difference values.

Images