I'm currently messing with the "complex_blur" PP effect from the Post-Processing Collection, and I can't figure out the equation(s?) behind this array:

Code:

---

float2 samples[12]
=	{
		-0.326212, -0.405805,
		-0.840144, -0.073580,
		-0.695914,  0.457137,
		-0.203345,  0.620716,
		 0.962340, -0.194983,
		 0.473434, -0.480026,
		 0.519456,  0.767022,
		 0.185461, -0.893124,
		 0.507431,  0.064425,
		 0.896420,  0.412458,
		-0.321940, -0.932615,
		-0.791559, -0.597705
	};

---

I hope I'm not doing anything wrong if I do add on to this array (make the array larger (add more numbers), make a smoother blur effect in theory, if I understand the code correctly), but if I'm not, then could someone clue me in on how this works? I've tried all 6 (inverse) trig functions on the numbers, and I'm not seeing a pattern.

that gives the positions to the other pixels sourunding the current pixel to lerp with.

Because the coordinates of the image are in the range from 0-1 that are really small numbers. To get a bigger (NOT BETTER!) blur, just multiplicate the used array with a value bigger then 1.

I don't know that shader, but maybe it is a gaussian blur?

I'm guessing that's it (the Wikipedia link), but the math's way above my level. I guess I can't add any more "layers", as it were, to the effect.

Unless there's a way I could use a special kind of graphing calculator to do it...?

you won't get too much passes at least in ps_2_0...so why not just use that blur technique a few times more?

Adding more passes doesn't do any good (in fact it just makes it real slow). I suppose I should probably just post the rest of the code, to help clear things up:

Code:

---

texture entSkin1;

sampler postTex = sampler_state
{
   texture = (entSkin1);
   MinFilter = linear;
   MagFilter = linear;
   MipFilter = linear;
   AddressU = Clamp;
   AddressV = Clamp;
};

float4 Blur_PS(float2 texCoord: TEXCOORD0) : COLOR
{
	float4 color;

	color = tex2D(postTex, texCoord);

	for (int i = 0; i < 12; i++)
	{
		color += tex2D(postTex, texCoord + 0.00625 * samples[i]);
	}

	return color / 13;
}

technique tech_00
{
	pass pass_00
	{
		VertexShader = null;
		PixelShader = compile ps_2_0 Blur_PS();
	}
}

technique tech_01
{
	pass pass_00
	{
		Texture[0] = <entSkin1>;
	}
}

---

so as I told you before just change the factor for the positions..make the 0.00625 bigger... as example to 0.01 or something...

That just makes a bigger blur factor, not a clearer blur. What I want is a clearer blur. I guess I could create another array that is equivalent to 1.5X the first array and then multiply the first array by this other array in the for loop ((samples[ i ] * samples2[ i ])) to get more "passes" (even though these aren't really other passes).

...you could increase the size of the first array and add more random offsets of vector length 1.

Quote:

---

...clearer blur.

---

...

(ignoring the oxymoron "clearer blur"...)

So, I take it I could just add random numbers to the array, and it wouldn't look strange? Because when the for loop is executed, I think it multiplies the sample pixel's distance by the number you specify (in this case 0.00625).