# XNA Gaussian blur on SlimDX

I am trying to implement the bloom effect, available in XNA http://create.msdn.com/en-US/education/catalog/sample/bloom, but with SlimDX and directX9.

My problems begin with the gaussian blur, instead of a nice fade out effect, all i get are blocky images:

see what "NET" text becomes: http://imgur.com/LgjbB

this is the blur effect code, copied directly from the XNA sample:

``````    void SetBlurEffectParameters(float dx, float dy)
{
// Look up how many samples our gaussian blur effect supports.
int sampleCount = 15; // weightsParameter.Elements.Count;

// Create temporary arrays for computing our filter settings.
float[] sampleWeights = new float[sampleCount];
Vector2[] sampleOffsets = new Vector2[sampleCount];

// The first sample always has a zero offset.
sampleWeights[0] = ComputeGaussian(0);
sampleOffsets[0] = new Vector2(0, 0);

// Maintain a sum of all the weighting values.
float totalWeights = sampleWeights[0];

// Add pairs of additional sample taps, positioned
// along a line in both directions from the center.
for (int i = 0; i < sampleCount / 2; i++)
{
// Store weights for the positive and negative taps.
float weight = ComputeGaussian(i + 1);

sampleWeights[i * 2 + 1] = weight;
sampleWeights[i * 2 + 2] = weight;

totalWeights += weight * 2;

// To get the maximum amount of blurring from a limited number of
// pixel shader samples, we take advantage of the bilinear filtering
// hardware inside the texture fetch unit. If we position our texture
// coordinates exactly halfway between two texels, the filtering unit
// will average them for us, giving two samples for the price of one.
// This allows us to step in units of two texels per sample, rather
// than just one at a time. The 1.5 offset kicks things off by
// positioning us nicely in between two texels.
float sampleOffset = i * 2.0f +1.5f;

Vector2 delta = new Vector2(dx, dy) * sampleOffset;

// Store texture coordinate offsets for the positive and negative taps.
sampleOffsets[i * 2 + 1] = delta;
sampleOffsets[i * 2 + 2] = -delta;
}

// Normalize the list of sample weightings, so they will always sum to one.
for (int i = 0; i < sampleWeights.Length; i++)
{
sampleWeights[i] /= totalWeights;
}

// Tell the effect about our new filter settings.
gaussianBlurEffect.SetValue("SampleWeights", sampleWeights);
gaussianBlurEffect.SetValue("SampleOffsets", sampleOffsets);

}

float ComputeGaussian(float n)
{
float theta = Settings.BlurAmount;

return (float)((1.0f / Math.Sqrt(2.0f * Math.PI * theta)) *
Math.Exp(-(n * n) / (2.0f * theta * theta)));
}
``````

And this is the shader:

``````// Pixel shader applies a one dimensional gaussian blur filter.
// This is used twice by the bloom postprocess, first to
// blur horizontally, and then again to blur vertically.

sampler TextureSampler : register(s0);

#define SAMPLE_COUNT 15

float2 SampleOffsets[SAMPLE_COUNT];
float SampleWeights[SAMPLE_COUNT];

float4 PixelShaderFunction(float2 texCoord : TEXCOORD0) : COLOR0
{
float4 c = 0;
// Combine a number of weighted image filter taps.
for (int i = 0; i < SAMPLE_COUNT; i++)
{
c += tex2D(TextureSampler, texCoord + SampleOffsets[i]) * SampleWeights[i];
}

return c;
}

technique GaussianBlur
{
pass Pass1
{