Bloom.fx Offset Question

[Deriest]

I don't know anything of code other than just changing variables and seeing the results so my question is going to be dumb to some of you.

I am trying to learn more about graphics programming but I can't learn it just by staring at it so I have a question.

In the enbbloom.fx file there is a section of code that I think is used to sample the image and downscale it to smaller size.

Code: Select all

const float2 offset[4]=
	{
		float2(0.5, 0.5),
		float2(0.5, -0.5),
		float2(-0.5, 0.5),
		float2(-0.5, -0.5)
	};

Then it does this...

Code: Select all

for (int i=0; i<4; i++)
	{
		bloomuv.xy=offset[i];
		bloomuv.xy=(bloomuv.xy*screenfact.xy)+In.txcoord0.xy;
		float4 tempbloom=tex2D(SamplerBloom1, bloomuv.xy);
		bloom.xyz+=tempbloom.xyz;
	}

Here is a diagram I made to visualize what I think this is doing.



Is that code taking the original image (blue-ish color) and re sizing it to the smaller red-ish box?
Is that the size of the end texture used for bloom?

As I said, I know very little of programming and this may make no sense at all.

[kingeric1992]

At any given point(txcoord0), the loop sum over itself and 4 near by pixels with given offset.

Edit: My mistake. It doesn't sum to itself since it doesn't sample at txcoord0. Just 4 offset positions.

[Deriest]

So then the (0,0) in my diagram is the point and the (0.5, 0.5), (0.5, -0.5), (-0.5, 0.5), and (-0.5, -0.5) are the 4 near pixels?

Sorry if I don't understand right away.

[ENBSeries]

It read nearest interpolated pixels to compute blurred. I think better for understanding is my illustration, if you not sure yet:

[Deriest]

Thanks Boris, I think I see now. The (.5, .5) etc. offsets are the white points in the middle of each little square. And those are used to average the colors for that one pixel. It does that for 4 pixels and those 4 pixels are the downscaled texture. Correct?

[prod80]

Deriest
When you take middle of 4 pixels you get average of the 4 pixels returned. When you take middle between 2 pixels you get average of 2 pixels. You can use this to write up more efficient methods with very minimal (actually almost impossible to see) loss in quality with significant better performance.

Ie if you have 4 pixels in a block:

--------
| 1 | 2 |
--------
| 3 | 4 |
--------

If I would sample 1 + 2 + 3 + 4 separately and divide by 4 would be the same as if I would sample the exact point at which the pixels meet. Then you could write this away as a downscaled image (which is what those lines of code do that you posted)

[Deriest]

I saw that link you posted originally prod80 and I bookmarked it but I have to read it a few more times to understand better before I post another question. I feel like my questions have been relatively dumb.

This topic may be too advanced for me at the moment.