WO2021213664A1

WO2021213664A1 - Filtering for rendering

Info

Publication number: WO2021213664A1
Application number: PCT/EP2020/061417
Authority: WO
Inventors: Baoquan Liu
Original assignee: Huawei Technologies Co., Ltd.
Priority date: 2020-04-24
Filing date: 2020-04-24
Publication date: 2021-10-28
Also published as: CN115280368A

Abstract

A graphics processing system for rendering an image having a plurality of pixels, wherein the system is configured to, for each of at least one of the plurality of pixels: determine a plurality of texels corresponding to the respective pixel, each texel comprising a sub-pixel data point indicating a texture sample value in a texture space; and render the respective pixel by applying a filtering function to the sub-pixel data points in dependence on a selected sampling location x to form a filtered value, where x is a fractional position of a texture coordinate; wherein the filtering function is performed by summing the outputs of a linear interpolation function implemented by the graphics processing system on the sub pixel data points about multiple locations equally spaced from x.

Description

FILTERING FOR RENDERING

FIELD OF THE INVENTION

This invention relates to filtering during rendering, for example for the rendering of soft shadows in a graphics processing unit.

BACKGROUND

The rendering of shadows is very important for video games, because the presence of shadows can not only increase the realism of a rendered image, but can also indicate inter object distances and positions to the viewer.

A simple shadow map algorithm, known as hard shadow, does not use any filtering algorithms (i.e. there are no weighted calculations) and fetches one single nearest texture sample from a shadow map texture to test whether the current rendered fragment is inside the shadow region or not. However, this may result in a poor-quality image, as shown by the shadow indicated at 101 in Figure 1 , which is not realistic.

Filtering shadow map samples is important to reduce jagged artifacts when rendering shadows in modern games. Generally, it is required to reduce aliasing due to under-sampling the geometry being rasterized into the shadow map, but it may also be useful for cases where the shadow map itself is undersampled by the pixel shader.

However, rendering high quality soft shadows using high quality filtering algorithms which involve a large number of texture sampling taps is very demanding, especially for the modern mobile graphics processing unit (GPU).

The shadow algorithms found in modern game engines (for example, Unreal Engine, and Unity 3D engine) usually need to perform texture sampling in a N x N area into the shadow map texture to obtain N x N texel data samples, and then perform a filtering operation on these data samples to get a high quality soft shadow value to shade the final pixel in the pixel shader.

A common filtering technique is Percentage Closer Filtering (PCF), which makes multiple sample taps to a shadow map texture and then perform the shadow tests, and finally filters the results of all the tests.

In order to achieve the simplest soft shadow to achieve light transition across pixels, as a minimal solution four taps of visibility samples, for example a 2 x 2 grid of neighbouring shadow map texels, have to be fetched and also weighted using sub-texel coordinate offsets as weights to generate a smooth light transition result. This is called 2 x 2 bilinear PCF filtering.

Figure 2a shows the improved rendering result when 2 x 2 bilinear PCF is used to produce a soft shadow, indicated at 201. As described above, this shadow map algorithm fetches four texture samples in a 2 x 2 neighbourhood area surrounding the target UV coordinate from a shadow map texture, shown as (s, t) in Figure 2b. 2 x 2 bilinear weighted filtering is then performed to calculate a percentage of whether the current rendered fragment is inside the shadow or not, i.e., whether the surface point is closer to the lit area and, therefore, not in shadow. However, the resulting image is still unrealistic and features zigzag aliasing.

Figure 3a shows the rendering result when 3 x 3 bilinear PCF is used. Many modern games employ 3 x 3 bilinear PCF filtering, which fetches nine texture samples in a 3 x 3 neighbourhood area surrounding the target UV coordinate, shown as (s, t) in Figure 3b. A 3 x 3 bilinear weighted calculation is then performed on the nine samples in a fragment shader in order to obtain a smooth filtered shadow. A triangle-shaped bilinear filtering kernel is employed as filter weights. The resulting rendered image quality is improved and more natural compared to 2 x 2 PCF filtering, as can be seen from the shadow area indicated at 301. Figure 4 shows an enlarged view of the area 301 indicated in Figure 3(a) of the image processed using a 3 x 3 bilinear PCF.

Figure 5 further illustrates the 3 x 3 PCF filtering algorithm which samples a 3 x 3 grid of texels surrounding the target UV coordinate 500. The weight for each of the nine samples is calculated as the covered area in each texel cell by the box 501 which is subtended by the sub-texel offset [alpha, beta] along the X axis and the Y axis respectively. The filtering weights for the nine samples are computed as the percentage coverage in each sample’s texel cell covered by the 2D sampling footprint (shown as the box 501), i.e, the weights are the covered 2D area computed for each texel cell.

For 3 x 3 bilinear PCF, the weight vector A is: [1-alpha, 1, alpha], and C is : [1-beta, 1, beta] along the X axis and the Y axis, respectively; the total area of the 2D sampling footprint (shown as the box 501) is 2 x 2=4, so the final result is divided by 4 to be normalized. Here, alpha and beta are the sub-texel offset along the two axes in the texel space.

For 3 x 3 PCF with bilinear filtering, in two-dimensions and with 3 x 3 data sampling taps, B is given by:

The filter kernel’s footprint area is 2 x 2, which can then be divided for the result to be normalized. In matrix notation, the 3 x 3 bilinear PCF equation can be represented as shown in Equation (2) below. Here, alpha and beta are represented by x and y respectively for easy derivation, i.e., x and y are the sub-texel offsets in the texture space along the X axis and the Y axis, respectively.

Furthermore, A and C also need to be dynamically calculated, since the sub-texel offsets are not fixed for each target pixel. Therefore all of the weights (which are unique for each sample) have to be calculated dynamically because shadow map texels are not located at fixed distances from the sampling locations, i.e., these are dynamic sub-texel offsets, which will be used to calculate the bilinear weights for the nine samples. This is to achieve continuous transitions in the filtered results across pixels, as non-continuous PCF (such as uniform PCF, where one same weight is used for all the nine samples.) is undesirable.

In many modern game engines on mobile platforms, the 3 x 3 PCF for shadow filtering is directly computed on 3 x 3 data samples to get a final high quality filtered soft shadow value.

Although a large kernel PCF can produce very good image quality, as illustrated above, it requires many texture fetching instructions for data sampling, which consumes a lot of data bandwidth. It also requires many weighted calculations for weighted filtering (i.e. many ALU instructions) for the shading of each single fragment. This can be a heavy burden to a mobile GPU’s memory and texture bandwidths and computing capability. Mobile devices require real-time rendering performance, with a high frame-rate and low latency interaction. At the same time, they require low power consumption to extend battery life, and low heat dissipation for user comfort when the device is hand-held for a long periods of time. Such requirements may not be achievable when a high-order filtering algorithm is used for the rendering of high-quality soft shadows.

Therefore, although 3 x 3 PCF filtering allows for smooth shadow transitions, it is very time consuming, as it needs nine texture fetching instructions (as shown in the matrix B) into a shadow map texture, which then need to be filtered using a weighted calculation along both X and Y directions in a 3 x 3 texel-grid, which involves twelve floating point multiplications and eight additions for a single filtering operation, as shown in Equation (2), where two vectors, A and C, each hold three weights, and the matrix B holds nine data samples (in a 3 x 3 texel- grid).

In the shadow filtering method described in US 7106326 B2, the computational unit is configured to access data values from memory and perform filtering operations (such as linear, bilinear, trilinear, cubic or bicubic filtering) on the data values of a neighbourhood (Np x Np ), where Np x Np is the size of the neighbourhood in texels. However, it requires Np x Np data sampling taps and a very complex weighted filtering calculation based on the multiple samples and the dynamic weights.

The approach described in Gruen, “Fast Conventional Shadow Filtering", GPU Pro, A K Peters, 2010, pp. 415-445, may achieve high quality PCF filtering with fewer texture fetches by applying dynamically shifted sampling locations and an extra post-texturing weight for each new sampled texture value. However, for triangle-shaped weighted filtering, it involves solving a complex linear system for each sample in order to calculate the correct post texturing weights and the correct dynamically shifted offset in order to get the new shifted texture sampling coordinates for all new sampling locations. As a result, the calculations for solving the linear system are complicated and may consume too many ALU shader instructions for mobile GPUs.

Higher order filtering, such as bi-cubic filtering, is more complicated due to the greater number of complex weighted filtering calculations, and the dynamical weights for all of the samples are also not easy to calculate, as this involves calculation of high order polynomials. It is desirable to develop a new method for rendering high quality soft shadows that overcomes these problems.

SUMMARY OF THE INVENTION

According to a first aspect there is provided a graphics processing system for rendering an image having a plurality of pixels, wherein the system is configured to, for each of at least one of the plurality of pixels: determine a plurality of texels corresponding to the respective pixel, each texel comprising a sub-pixel data point indicating a texture sample value in a texture space; and render the respective pixel by applying a filtering function to the sub-pixel data points in dependence on a selected sampling location x to form a filtered value, where x is a fractional position of a texture coordinate; wherein the filtering function is performed by summing the outputs of a linear interpolation function implemented by the graphics processing system on the sub pixel data points about multiple locations equally spaced from x.

This may allow for faster shadow filtering in 2D image applications and may produce a smooth image quality result for soft shadows.

The multiple locations may each be spaced from x by an offset of 0.5 of the spacing of the sub-pixels data points in the texture space along each dimension in the texture space. The offset may be +/- 0.5. This may reduce the processing required to render the image.

The number of texels covered by each pixel may be a multiple of three along each dimension in the texture space. The number of texels covered by each pixel may be a multiple of three along each of at least one of X, Y and Z directions in the texture space.

The sum of the outputs of two linear interpolation functions implemented by the graphics processing system at (x-0.5) and (x+0.5) may be approximately equal to a linearly weighted 3-tap percentage closer filtering weighted sum of three function values at integer texture coordinate locations in 1 dimension in the texture space. The system may therefore allow for faster 3 x 3 PCF shadow filtering after extending the 1D solution to 2D image applications. The system may be configured apply the filtering function along multiple orthogonal directions in the texture space. The multiple locations may be each spaced from x along one, two or three orthogonal directions in the texture space. This may allow the method to be applied to PCF filtering in one, two or three dimensions.

The system may be configured to implement the filtering function in one of the GLSL, HLSL and Spir-V languages, or any other suitable shading language. The system is therefore compatible with filtering algorithms and languages used in many modern image processing systems and video games.

The system may be configured to implement the filtering function in a single instruction, or fixed function hardware unit. This may reduce the processing cost required to render the image.

The system may comprise a texture cache configured to store processed sampling results to be re-used by neighbouring pixels in the image. This may further reduce the processing required to render the image.

At least some of the plurality of pixels may represent a shadow of an object in the image. The filtering function may be a PCF filtering function. The filtering function may be a shadow filtering function. The filtered value may be a filtered shadow value. This may allow for faster shadow filtering in 2D image applications and may produce a smooth image quality result for soft shadows.

According to a second aspect there is provided a method for rendering an image having a plurality of pixels, at least some of the pixels representing a shadow of an object in said image, wherein the method comprises, for each of at least one of the plurality of pixels: determining a plurality of texels corresponding to the respective pixel, each texel comprising a sub-pixel data point indicating a texture sample value in a texture space; and rendering the respective pixel by applying a filtering function to the sub-pixel data points in dependence on a selected sampling location x to form a filtered shadow value, where x is a fractional position of a texture coordinate; wherein the filtering function is performed by summing the outputs of a linear interpolation function implemented by the graphics processing system on the sub pixel data points about multiple locations equally spaced from x. The method may allow for faster shadow filtering and may produce a smooth image quality result for soft shadows.

The multiple locations may be each spaced from x by an offset of 0.5 of the spacing of the sub-pixels data points in the texture space. The offset may be +/- 0.5. This may reduce the processing required to render the image.

The number of texels covered by each pixel may be a multiple of three. The number of texels covered by each pixel may be three along each of at least one of X, Y and Z directions in the texture space. The system may therefore simplify 3 x 3 PCF shadow filtering in 2D.

The method may comprise applying the filtering function along multiple orthogonal directions in the texture space. The multiple locations may be each spaced from x along one, two or three orthogonal directions in the texture space. This may allow the method to be applied to PCF filtering in one, two or three dimensions.

According to a third aspect there is provided a computer program which, when executed by a computer, causes the computer to perform the method described above. The computer program may be provided on a non-transitory computer readable storage medium.

BRIEF DESCRIPTION OF THE FIGURES

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

In the drawings:

Figure 1 illustrates the rendering result of a hard shadow algorithm, without any filtering.

Figure 2a shows the rendering result when 2 x 2 bilinear percentage closer filtering (PCF) is used to produce a soft shadow.

Figure 2b illustrates sampling a 2 x 2 grid of texels surrounding the target UV coordinate.

Figure 3a shows the rendering result when 3 x 3 bilinear percentage closer filtering (PCF) is used to produce a soft shadow.

Figure 3b illustrates sampling a 3 x 3 grid of texels surrounding the target UV coordinate.

Figure 4 shows an enlarged view of the rendering result of Figure 3a using 3 x 3 bilinear PCF.

Figure 5 schematically illustrates the 3 x 3 PCF filtering algorithm (sampling a 3 x 3 grid of texels surrounding the target UV coordinate). The weight for each of the nine samples is calculated as the covered area in each texel cell by the box (i.e. , the sampling footprint) which are subtended by the sub-texel offset [alpha, beta] along X and Y axis, respectively.

Figure 6 illustrates a calculation for 3 x 1 linear PCF filtering in 1D at position x by weighting the three neighbouring function values at integer positions (f-i, fo, T) to be filtered, where the filtering weights are calculated based on the sub-texel offsets.

Figure 7 illustrates a flow chart for a method for rendering an image having a plurality of pixels, at least some of the pixels representing a shadow of an object in said image.

Figure 8 shows an example of a graphics processing system.

DETAILED DESCRIPTION OF THE INVENTION

Described herein is a graphics processing system and method which may be used, for example, for rendering high quality soft shadows.

Herein, rendering refers to any form of generating a visible image, for example displaying the image on a computer screen, printing, or projecting.

Without any filtering, a data sample’s value from a shadow map texture is either 1.0 or 0.0. As a result, the rendered shadow in a final image shows strong aliasing. This is because if a data sample’s value is equal to 1.0, it means that the pixel is completely outside of the shadow, while if it is 0.0, it means that the pixel is completely in shadow.

After filtering, a data sample’s value could be a floating point, which lies between 1.0 and 0.0. This is to achieve continuous transitions and thus the pixel can be rendered as a soft shadow in the final image.

A pixel P in image space has a projection area, centered at x in texture space, and, in 3 x 3 PCF, x has a local neighbourhood of 3 x 3 texels, which are the nine texels that are covered by the footprint of the projection area. The PCF filtering function is applied to these nine texels to achieve a filtered value, which is the final shadow value for pixel P. Each texel therefore indicates a texture sample value in texture space. For shading of each pixel, multiple taps of texels may be required because a pixel is in image space, which has a projection footprint in texture space, which covers multiple texels. The filtering is performed in texture space. In the examples described below, the number of texels per pixel is three in each direction or dimension of X, Y, or Z (where present).

The application of the present method in 1D will now be illustrated, and then extended to 2D for soft shadow rendering. It is also possible to extend the method to 3D for 3 x 3 x 3 trilinear PCF filtering for 3D volume data.

Without a loss of generality, it is assumed that the samples of a continuous function f(x) are known at integer texel locations and f(x) needs to be approximately reconstructed from these discrete integer locations as the normalized weighted sum of these discrete samples.

A piecewise linear function reconstruction is defined as follows.

General 1D linear interpolation is a method for estimating the function value f_(i+x) as the normalized weighted sum of two taps of known functional values f_(i) and f_(i+1) at the integer grid locations (i and i+1), where, x∈[0, 1) , i.e. , 1> x ≥ 0, and i ∈ Z being the integer and x being the fractional parts of (i+x), respectively. In order to simplify notation, the i will be omitted in the following notations of (f_i-1,f_i, f_i+1 ) and these values will just be noted as (f_-1, f₀, f₁) .

Similarly to the general 1D linear interpolation, the 1D 3 x 1 linear PCF filtering is a more advanced interpolation, which calculates the weighted sum of three taps of function values (f- ₁, f₀, f₁) at three integer grid locations (-1 , 0, and 1). Here, the 1D filter’s footprint-size (i.e., the 1D sampling footprint) is two (ranging from x-1 to x+1), which is divided for the final result to be normalized.

Figure 6 illustrates the integrating calculation for the weighted sum for the 3 x 1 linear PCF filtering in 1D. The function values (f_-1, f₀, f₁) at the three integer grid locations (-1, 0, and 1) are shown by the bars at 601 , 602 and 603 respectively.

Here, x is the fractional part of texture coordinate (i.e. between the integer texture coordinate positions in the texture space), and is the result of the hardware linear interpolation

function (i.e. the linear interpolation function implemented by the graphics processing system) at offset x between two consecutive integer locations.

The PCF filtered result can be calculated as the sum of the area of the three hatched regions 604, 605, 606, where the area of each region 604, 605, 606 is calculated as the product of the weight and height of each region that is covered by the sampling footprint ranging from x-1 to x+1.

With reference to Figure 6, for an arbitrary offset x∈[0, 1), it was found that the linear interpolation at (x-0.5)∈[-0.5, 0.5) can be expressed as a weighted sum of two function values at two integer locations (-1 and 0), and the linear interpolation at (x+0.5)∈[0. 5, 1.5) can be expressed as weighted sum of two function values at two integer locations (0 and 1). Ierp() is the interpolating function. This is expressed as:

Adding these two items together gives:

Or, equivalently, in notation of matrix operations:

From this derivation, it can be seen that the 3 x 1 PCF filtered result at the sampling location x in 1D is equal to the sum of two general linear-interpolating functions at two locations: (x-

0.5) and (x+0.5), which are already supported by GPU hardware as the linear sampling texture instruction,

In 2D, the 3x3 bilinear PCF filtering will involve 3 x 3=9 taps: The 2D

filter’s footprint size (i.e. , the area of the 2D sampling footprint shown as the box 501 in Figure 5) is 2 x 2=4, which is then divided for the final result to be normalized.

As shown in Equation (2), the filter for 2D bilinear PCF filtering is a separable filter, which means that it can be separated into two 1 -dimensional filters along the X and Y directions, respectively.

To simplify the traditional Equation (2) for 2D rendering, the 1D equation derived above can first be applied along the X direction, and then after obtaining the intermediate result, the 1D equation can be applied again along the Y direction. In notation of matrix operations, the 2D bilinear PCF filtering equation may be simplified by the following derivation:

As a result of the above derivation, it may be seen that the 3 x 3 PCF filtered result at the 2D sampling location (x,y) is equal to the sum of four general 2D bilinear-interpolating functions at four locations with the 2D offsets of ±0.5 along each of the two dimensions to the original 2D sampling location. These functions are already supported by GPU hardware as 2D bilinear sampling texture instructions:

In 3D applications, such as volume rendering, a 3D texture is sampled along the rays, and the sampled values will need to be filtered, where PCF can be very useful to achieve a smooth rendering result.

In 3D, the 3 x 3 x 3 trilinear PCF filtering will involve 3 x 3 x 3 = 27 taps of function values at integer grid locations, and the 3D filter’s footprint (i.e., the volume of the 3D sampling footprint) is 2 x 2 x 2 = 8, which needs to be divided for the final result to be normalized.

The 3 x 3 x 3 trilinear PCF filtered result in 3D can be expressed as the normalized weighted sum of twenty seven function values at twenty seven integer grid locations.

The 3D extension of the PCF interpolation scheme described herein can be derived analogously to the 2D case. Therefore, only the result of this derivation is presented below for 3D:

From Equation (9), it can be concluded that the 3 x 3 x 3 PCF filtered result at the 3D sampling location (x, y, z) is equal to the sum of eight general 3D trilinear-interpolating functions at eight locations with their 3D offsets of ±0.5 along each of the three dimensions to the original 3D sampling location(x, y, z). This 3D trilinear-interpolating function is already supported by GPU hardware as 3D trilinear sampling texture instructions:

Figure 7 summarises a method for rendering an image having a plurality of pixels, wherein the method comprises, for each of at least some of the plurality of pixels. The method comprises the following steps for each of at least one of the plurality of pixels. At step 701, the method comprises determining a plurality of texels corresponding to the respective pixel, each texel comprising a sub-pixel data point indicating a texture sample value in a texture space. At step 702, the method comprises rendering the respective pixel by applying a filtering function to the sub-pixel data points in dependence on a selected sampling location x to form a filtered value, where x is a fractional position of a texture coordinate; wherein the filtering function is performed by summing the outputs of a linear interpolation function implemented by the graphics processing system on the sub pixel data points about multiple locations equally spaced from x.

Some benefits of using this method compared to a method utilizing the conventional Equation (2) are described below.

In 1D, the method requires fewer GPU instructions for both texjnstructions (from three reduced to two), and ALU instructions (from three multiplications and two additions to only two additions and no multiplications).

The benefit of this simplified 2D equation compared to the traditional Equation (2) is that fewer GPU instructions are required, for both texjnstructions (from nine reduced to four) and ALU_instructions (from 9+3=12 multiplications and 6+2=8 additions to only three additions and zero multiplications). The method also requires less register allocation, which means more concurrent GPU threads scheduled in flight. This can result in faster rendering speed and less power consumption.

The 2D equation for 3x3 bilinear PCF described herein can be used to filter shadow map samplings to obtain high quality soft shadow rendering result for video games.

The method of rendering can be deployed onto multiple modern video games in the shaders for soft shadow rendering, by replacing the old fragment shader, which uses Equation (2), with a shader implementing the method described herein. In some implementations, this may result in reduced power consumption by over 30mA on average, i.e. approximately a 5-10% GPU power improvement. The approach for 3 x 3 x 3 trilinear PCF can be used for 3D applications, such as volume rendering, where a 3D texture will be sampled along the rays and the sampled values need to be filtered, where 3 x 3 x 3 trilinear PCF can be very useful to achieve a smooth volume rendering result. It requires fewer GPU instructions in terms of both texjnstructions (from twenty seven reduced to eight) and ALU_instructions (from 27+9+3=39 multiplications and 18+6+2=26 additions, reduced to only seven additions and zero multiplications). There is also less register allocation, which means more concurrent GPU threads scheduled in flight. This can result in faster rendering speed and less power consumption.

The method described herein for PCF filtering therefore involves fewer weighted calculations, especially for 2D and 3D.

Fewer GPU instructions may result in longer mobile battery life, and may also allow for reduced latency and improved frame-rate for complex and demanding game rendering.

This also allows for possible GPU software implementation using shader code. The equations in 1D, 2D or 3D can be implemented in a graphic processing system by a few lines of GPU shader code using shading languages, such as GLSL, HLSL, Spir-V or any other suitable language.

A GPU’s texture unit (TU) module may be modified to implement the 3 x 3 PCF filtering equation by using fixed function hardware via a single instruction, instead of shader code. For example, one ISA intrinsics call may be used to complete a 2D 3 x 3 PCF filtering.

Therefore, the method can be implemented by using fixed function hardware inside a GPU’s TU hardware module. This hardware functionality can be provided to users via a single shader instruction, instead of multiple lines of shader code.

In one implementation, a texture cache may be exploited to store processed sampling results at quad granularity to be re-used by neighbouring pixels. Furthermore, independent-texture- read may also be used (due to the constant offset of 0.5 in the preferred implementation) to perform data pre-fetch to further enhance the rendering performance.

The method described herein may allow for faster and cheaper triangle-shaped linear PCF filtering (with a filter diameter size of three texels) for 1D, 2D, and 3D, respectively, which results in fewer weighted filtering calculations, in terms of both texture sampling instructions and the ALU instructions, than the conventional methods. This may also result in reduced latency and improved frame rate for complex and demanding game rendering.

Figure 8 is a schematic representation of a system 800 configured to perform the methods described herein. The system 800 may be implemented on a device, such as a laptop, tablet, smart phone, TV or any other device in which graphics data is to be processed.

The system 800 comprises a graphics processor 801 configured to process data. For example, the processor 801 may be a GPU. Alternatively, the processor 801 may be implemented as a computer program running on a programmable device such as a GPU or a Central Processing Unit (CPU). The system 800 comprises a memory 802 which is arranged to communicate with the graphics processor 801. Memory 802 may be a non-volatile memory. The graphics processor 801 may also comprise a cache (not shown in Figure 8), which may be used to temporarily store data from memory 802. The system may comprise more than one processor and more than one memory. The memory may store data that is executable by the processor. The processor may be configured to operate in accordance with a computer program stored in non-transitory form on a machine readable storage medium. The computer program may store instructions for causing the processor to perform its methods in the manner described herein.

The system may allow for rendering a high quality 3 x 3 PCF filtered soft shadow at higher performance with fewer weighted filtering calculations on a mobile GPU than conventional methods. As described above, the method may involve fewer texture sampling instructions and ALU calculations than previous methods.

Although the system and method are primarily described above for applications relating to shadow rendering, the system and method may also be applied in other types of image rendering applications.

The applicant hereby discloses in isolation each individual feature described herein and any combination of two or more such features, to the extent that such features or combinations are capable of being carried out based on the present specification as a whole in the light of the common general knowledge of a person skilled in the art, irrespective of whether such features or combinations of features solve any problems disclosed herein, and without limitation to the scope of the claims. The applicant indicates that aspects of the present invention may consist of any such individual feature or combination of features. In view of the foregoing description it will be evident to a person skilled in the art that various modifications may be made within the scope of the invention.

Claims

1. A graphics processing system for rendering an image having a plurality of pixels, wherein the system is configured to, for each of at least one of the plurality of pixels: determine a plurality of texels corresponding to the respective pixel, each texel comprising a sub-pixel data point indicating a texture sample value in a texture space; and render the respective pixel by applying a filtering function to the sub-pixel data points in dependence on a selected sampling location x to form a filtered value, where x is a fractional position of a texture coordinate; wherein the filtering function is performed by summing the outputs of a linear interpolation function implemented by the graphics processing system on the sub pixel data points about multiple locations equally spaced from x.

2. The system of claim 1, wherein the multiple locations are each spaced from x by an offset of 0.5 of the spacing of the sub-pixels data points in the texture space along each dimension in the texture space.

3. The system of claim 1 or claim 2, wherein the number of texels covered by each pixel is three along each dimension in the texture space.

4. The system of any preceding claim, wherein the sum of the outputs of two linear interpolation functions implemented by the graphics processing system at (x-0.5) and (x+0.5) is approximately equal to a linearly weighted 3-tap percentage closer filtering weighted sum of three function values at integer texture coordinate locations along each dimension in the texture space.

5. The system of any preceding claim, wherein the system is configured apply the filtering function along multiple orthogonal directions in the texture space.

6. The system of any preceding claim, wherein the multiple locations are each spaced from x along one, two or three orthogonal directions in the texture space.

7. The system of any preceding claim, wherein the system is configured to implement the filtering function in one of the GLSL, HLSL and Spir-V languages.

8. The system of any preceding claim, wherein the system is configured to implement the filtering function in a single instruction, or fixed function hardware unit.

9. The system of any preceding claim, wherein the system comprises a texture cache configured to store processed sampling results to be re-used by neighbouring pixels in the image.

10. The system of any preceding claim, wherein at least some of the plurality of pixels represent a shadow of an object in the image.

11. A method for rendering an image having a plurality of pixels, wherein the method comprises, for each of at least one of the plurality of pixels: determining a plurality of texels corresponding to the respective pixel, each texel comprising a sub-pixel data point indicating a texture sample value in a texture space; and rendering the respective pixel by applying a filtering function to the sub-pixel data points in dependence on a selected sampling location x to form a filtered value, where x is a fractional position of a texture coordinate; wherein the filtering function is performed by summing the outputs of a linear interpolation function implemented by the graphics processing system on the sub pixel data points about multiple locations equally spaced from x.

12. The method of claim 11 , wherein the multiple locations are each spaced from x by an offset of 0.5 of the spacing of the sub-pixels data points in the texture space along each dimension in the texture space.

13. The method of claim 11 or claim 12, wherein the number of texels covered by each pixel is three along each dimension in the texture space.

14. The method of any of claims 11 to 13, wherein the method comprises applying the filtering function along multiple orthogonal directions in the texture space.

15. The method of any of claims 11 to 14, wherein the multiple locations are each spaced from x along one, two or three orthogonal directions in the texture space.

16. The method of any of claims 11 to 15, wherein at least some of the plurality of pixels represent a shadow of an object in the image.

17. A computer program which, when executed by a computer, causes the computer to perform the method of any of claims 11 to 16.