In FastBloom(Bloom Optimized) shader, what's the difference between "Standard" and "Sgx" blur type?

[bobozzz]

When I use the FastBloom (Bloom Optimized) image effect, I noticed that there are two blur types, which are “standard” and “Sgx”.

When I toggle between them, there is no difference on rendering side. Then I check the shader, both of them are 7 * 7 gaussian blur. The way they do the for loop is different, but they all have 7 times texture reading, so there shouldn’t be dramatic performance difference.

So what’s the difference? And why the second one is named “Sgx”? What does “Sgx” stand for?

[jvo3dc]

I don’t know where sgx stands for, but it’s probably a different type of sampling.

The traditional way of doing a Gaussian is with samples that are uniformly distributed and have different weights based on the Gaussian function. The disadvantage of this is that some samples contribute very little to the end result.

So another way is to apply importance sampling. In that case the weights are all the same, but the distribution is non-uniform. The disadvantage of this is that there are some wider gaps between the samples, which means there is a higher chance of skipping pixels.

The visual difference can be fairly minimal. Not the greatest image, but it shows the idea a bit:

If I’d have to guess, then I guess this is the difference between the two.

[bobozzz]

@jvo3dc

I don’t know where sgx stands for, but it’s probably a different type of sampling.

The traditional way of doing a Gaussian is with samples that are uniformly distributed and have different weights based on the Gaussian function. The disadvantage of this is that some samples contribute very little to the end result.

So another way is to apply importance sampling. In that case the weights are all the same, but the distribution is non-uniform. The disadvantage of this is that there are some wider gaps between the samples, which means there is a higher chance of skipping pixels.

The visual difference can be fairly minimal. Not the greatest image, but it shows the idea a bit:
https://image.slidesharecdn.com/sidibemoduleimage2011-120307023650-phpapp02/95/particle-filters-and-applications-in-computer-vision-54-728.jpg?cb=1331087873

If I’d have to guess, then I guess this is the difference between the two.

Thank you for your reply. I get what you are saying about importance sampling. However, I don’t think the Sgx blur is the importance sampling.

Shader code from FastBloom (I will just copy the horizontal):

standard:
vert:

v2f_withBlurCoords8 vertBlurHorizontal (appdata_img v)
{
v2f_withBlurCoords8 o;
o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
o.uv = half4(v.texcoord.xy,1,1);
o.offs = _MainTex_TexelSize.xy * half2(1.0, 0.0) * _Parameter.x;
return o;
}

frag:

half4 fragBlur8 ( v2f_withBlurCoords8 i ) : SV_Target
{
half2 uv = i.uv.xy;
half2 netFilterWidth = i.offs;
half2 coords = uv - netFilterWidth * 3.0;
half4 color = 0;
for( int l = 0; l < 7; l++ )
{
half4 tap = tex2D(_MainTex, UnityStereoScreenSpaceUVAdjust(coords, _MainTex_ST));
color += tap * curve4[l];
coords += netFilterWidth;
}
return color;
}

Sgx:
vert:

v2f_withBlurCoordsSGX vertBlurHorizontalSGX (appdata_img v)
{
v2f_withBlurCoordsSGX o;
o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
o.uv = v.texcoord.xy;
half offsetMagnitude = _MainTex_TexelSize.x * _Parameter.x;
o.offs[0] = v.texcoord.xyxy + offsetMagnitude * half4(-3.0h, 0.0h, 3.0h, 0.0h);
o.offs[1] = v.texcoord.xyxy + offsetMagnitude * half4(-2.0h, 0.0h, 2.0h, 0.0h);
o.offs[2] = v.texcoord.xyxy + offsetMagnitude * half4(-1.0h, 0.0h, 1.0h, 0.0h);
return o;
}

frag:

half4 fragBlurSGX ( v2f_withBlurCoordsSGX i ) : SV_Target
{
half2 uv = i.uv.xy;
half4 color = tex2D(_MainTex, UnityStereoScreenSpaceUVAdjust(i.uv, _MainTex_ST)) * curve4[3];
for( int l = 0; l < 3; l++ )
{
half4 tapA = tex2D(_MainTex, UnityStereoScreenSpaceUVAdjust(i.offs[l].xy, _MainTex_ST));
half4 tapB = tex2D(_MainTex, UnityStereoScreenSpaceUVAdjust(i.offs[l].zw, _MainTex_ST));
color += (tapA + tapB) * curve4[l];
}
return color;
}

Here is the curve4 both of them use:
static const half4 curve4[7] = { half4(0.0205,0.0205,0.0205,0), half4(0.0855,0.0855,0.0855,0), half4(0.232,0.232,0.232,0), half4(0.324,0.324,0.324,1), half4(0.232,0.232,0.232,0), half4(0.0855,0.0855,0.0855,0), half4(0.0205,0.0205,0.0205,0) };

If we set _Parameter.x to 2, and resolution to 1024 * 768, standard version samples:
uv - 6/1024, uv - 4/1024, uv - 2/1024, uv, uv + 2/1024, uv + 4/1024, uv + 6/1024

sgx version samples:
uv, uv - 6/1024, uv + 6/1024, uv - 4/1024, uv + 4/1024, uv - 2/1024, uv + 2/1024

The only difference to me is

1. the sampling order is different
2. standard shader calculate sampling uv in the fragment shader, but sgx calculate the sampling uv in the vertex shader

I still don’t get what’s the point to have these two blur types. They are pretty much same to me:eyes:

[bobozzz]

I did some more research, so SGX is a GPUs series from PowerVR. It’s used on newer versions of iPhone (starting with the iPhone 3GS).

so I guess there should be something in the standard blur type that cannot be done on the SGX hardware, or there is something special in the SGX blur type that can only be done on the SGX hardware?

[bgolus]

It’s about avoiding dependent texture reads for mobile. Modifying the UVs in the fragment shader makes reading textures much slower on mobile. On desktop it doesn’t matter as much, and not passing extra data from the vertex to the fragment can often save you more time than it takes to do the calculations per-pixel.

Note that the UnityStereoScreenSpaceUVAdjust() function does nothing on mobile platforms so the UVs aren’t being modified.

[bobozzz]

@bgolus

It’s about avoiding dependent texture reads for mobile. Modifying the UVs in the fragment shader makes reading textures much slower on mobile. On desktop it doesn’t matter as much, and not passing extra data from the vertex to the fragment can often save you more time than it takes to do the calculations per-pixel.

Note that the UnityStereoScreenSpaceUVAdjust() function does nothing on mobile platforms so the UVs aren’t being modified.

Thanks! So that means “standard” is targeting for PC and “Sgx” is more for mobile (because Sgx blur type has better optimization)?

And sorry for asking this question (I am still a noob):

About “UnityStereoScreenSpaceUVAdjust”:

#ifdef UNITY_SINGLE_PASS_STEREO
inline float2 UnityStereoScreenSpaceUVAdjustInternal(float2 uv, float4 scaleAndOffset)
{
return saturate(uv.xy) * scaleAndOffset.xy + scaleAndOffset.zw;
}

inline float4 UnityStereoScreenSpaceUVAdjustInternal(float4 uv, float4 scaleAndOffset)
{
return float4(UnityStereoScreenSpaceUVAdjustInternal(uv.xy, scaleAndOffset), UnityStereoScreenSpaceUVAdjustInternal(uv.zw, scaleAndOffset));
}

#define UnityStereoScreenSpaceUVAdjust(x, y) UnityStereoScreenSpaceUVAdjustInternal(x, y)

inline float2 UnityStereoTransformScreenSpaceTex(float2 uv)
{
return TransformStereoScreenSpaceTex(saturate(uv), 1.0);
}

inline float4 UnityStereoTransformScreenSpaceTex(float4 uv)
{
return float4(UnityStereoTransformScreenSpaceTex(uv.xy), UnityStereoTransformScreenSpaceTex(uv.zw));
}
#else
#define UnityStereoScreenSpaceUVAdjust(x, y) x
#define UnityStereoTransformScreenSpaceTex(uv) uv
#endif

I have seen “#ifdef UNITY_SINGLE_PASS_STEREO” a lot in shader, but I am not sure how to use it. That’s for VR right? How to trigger it to on/defined?

[bgolus]

That is for VR, and it’s defined by enabling Virtual Reality Support and Single-Pass Stereo Rendering in the player settings. No additional #pragma multicompile is needed.