Abstract:
A tile-based graphics processing pipeline comprising a rasteriser 3, a renderer 6, a tile buffer 10 configured to store rendered fragment data locally to the graphics processing pipeline prior to that data being written out to an external memory, a write out stage 13 configured to write data stored in the tile buffer to an external memory, and a programmable processing stage 14. The programmable processing stage 14 is operable under the control of graphics program instructions to read fragment data stored in the tile buffer 10 on a random access basis, perform a processing operation using the read fragment data, and write the result of the processing operation into the tile buffer 10 or to an external memory.
Abstract:
A graphics processing pipeline 1 includes a rasteriser 3 that tests patches representing respective different regions of a render output against the edges of primitives 2 to determine if the primitive at least partially covers the patch and an early depth test stage 4 that performs early depth tests for primitives in respect of patches of the render output that the primitive has been found by the rasteriser at least partially to cover, by using depth test information 5 associated with a patch indicating the number and distribution of different depth value regions associated with the patch to determine the depth value region or regions associated with the patch that the primitive should be depth tested against, and then performing a depth test or tests for the primitive in respect of the respective determined depth value region or regions associated with the patch.
Abstract:
A data processing system includes an execution pipeline that includes one or more programmable execution stages which execute execution threads to execute instructions to perform data processing operations. Instructions to be executed by a group of execution threads are first fetched into an instruction cache and then read from the instruction cache for execution by the thread group. When an instruction to be executed by a thread group is present in a cache line in the instruction cache, or is to be fetched into an allocated cache line in the instruction cache, a pointer to the location of the instruction in the instruction cache is stored for the thread group. This stored pointer is then used to retrieve the instruction for execution by the thread group from the instruction cache.
Abstract:
A rasterizer and a method of performing rasterization in a graphics processing pipeline are disclosed. A rasterizer of a graphics processing pipeline tests larger patches of a render output to be generated against a primitive to be rasterized, to determine if the primitive covers (at least in part) any smaller patches of the render output that the larger patch encompasses. The larger patch is then sub-divided into any covered smaller patches, and the process repeated. The rasterizer also identifies when a given smaller patch of the render output is found to entirely pass the edge test for an edge of the primitive in question when the larger patch encompassing that smaller patch is tested, notes that event in state information associated with the primitive edge in question, and then uses that state information to skip the testing of the edge in question against the smaller patch of the render output.
Abstract:
When processing a set of tiles to generate an output in a tile based graphics processing pipeline, the pipeline, for one or more tiles of the set of tiles, renders one or more render targets containing data to be used in a processing operation (602), and stores the render targets in the tile buffer (604). It also stores some but not all of the sampling position values for a render target or targets for use when processing an adjacent tile of the set of tiles (606). It then performs a processing operation for the tile using the stored render target or targets (608) and one or more stored sampling position values from another, adjacent tile of the set of tiles (610), to generate an output for the tile (612).
Abstract:
In a tile-based graphics processing system having plural rendering processors, the set of tiles 31 to be processed to generate an output frame 30 for display is partitioned among the different rendering processors by defining respective tile traversal paths 32, 33, 34, 35 for each rendering processor that start at a tile initially allocated to the processor and that, at least for the initial tiles along the path, traverse to spatially adjacent tiles in the output, and that will traverse every tile to be rendered if followed to their end. The next tile for a given rendering processor to process is then selected as being the next tile along its defined path, unless the next tile in the path has already been processed (or is already being processed) by another rendering processor, in which case the next tile to be allocated to the rendering processor is selected to be a free tile further on in the tile traversal path for that processor.
Abstract:
Operating a graphics processing pipeline that includes processing stages including a rasteriser that rasterises input primitives to generate graphics fragments to be processed, each graphics fragment having one or more sampling points associated with it, and a renderer that processes fragments generated by the rasteriser to generate output fragment data for output to a render output, comprising the following steps: (i) determining first information to test whether at least a part of a primitive should be processed further; (ii) using at least some of the first information to decide whether to process at least a part of the primitive further; and if it is decided that at least a part of the primitive is to be processed further: (iii) determining further information to be used in further processing of the primitive; and (iv) further processing at least a part of the primitive using the determined further information.
Abstract:
A rasteriser 10 of a graphics processing pipeline 1 tests larger patches of a render output to be generated against a primitive to be rasterised, to determine if the primitive covers (at least in part) any smaller patches of the render output that the larger patch encompasses. The larger patch is then sub-divided into any covered smaller patches, and the process repeated.The rasteriser 10 also identifies when a given smaller patch of the render output is found to entirely pass the edge test for an edge of the primitive in question when the larger patch encompassing that smaller patch is tested, notes that event in state information associated with the primitive edge in question, and then uses that state information to skip the testing of the edge in question against the smaller patch of the render output.
Abstract:
To encode a texture to be used in a graphics processing system, the texture is first downscaled to generate a lower resolution representation of the texture 41. An upscaled version 42 of the lower resolution version of the texture is then compared to the original texture to determine a set of difference values indicating for each texel the difference between the value of the texel in the upscaled version of the texture and in the original texture 43. An encoded texture data block is then generated for each 8×8 block of texels in the original texture 44. Each encoded texture data block contains a base colour value taken from the lower resolution representation of the texture and a set of index values indicating the difference data from the determined set of difference data to be used when decoding the block of texture data to generate the data values to be used for the texture data elements that the block of texture data represents.
Abstract:
A graphics virtual texturing system in which textures stored in a storage medium of a host system are divided into respective pages that are then loaded into a local memory of a graphics processing system for use. Each page of a graphics texture has an associated fade factor value that can be set by an application that is to use the texture to control the contribution that the page will be used to make to any texturing result that is generated using the texture page in question. The graphics processing system then controls the contribution of texture data from a texture page to texturing result data to be generated in accordance with the fade factor value associated with the texture page in question. This allows texture paging to be done in a more visually pleasing manner than just a binary “page-is-here”/“page-is-not-here” switch.