public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
    {
        base.Draw(gameTime, spriteBatch);

    //Set the rendertarget to draw the Blinn-Phong shaded scene to
        GraphicsDevice.SetRenderTarget(renderTarget);
        GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);

        Material material = new Material();
        material.DiffuseColor = Color.Red;
        material.AmbientColor = Color.Red;
        material.AmbientIntensity = 0.2f;
        material.SpecularColor = Color.White;
        material.SpecularIntensity = 2.0f;
        material.SpecularPower = 25.0f;

    //Draw all the models
        foreach (ModelData m in models)
        {
            ModelMesh mesh = m.Model.Meshes[0];
            Effect e = mesh.Effects[0];

            e.CurrentTechnique = e.Techniques[m.Technique];
            material.SetEffectParameters(e);
            this.camera.SetEffectParameters(e);
            e.Parameters["World"].SetValue(world * m.Transform);
            e.Parameters["WorldInverseTransposed"].SetValue(Matrix.Transpose(Matrix.Invert(world * m.Transform)));
            e.Parameters["CameraEye"].SetValue(new Vector4(this.camera.Eye, 0));
            // TODO: LightSource Color + Intensity
            e.Parameters["LightSources"].SetValue(lightPositions);

            mesh.Draw();
        }

    //Restore the rendertarget to the backbuffer and clear it.
        GraphicsDevice.SetRenderTarget(null);
        GraphicsDevice.Clear(Color.Black);

    //Pass the standard variable to the spriteBatch vertex shader.
    //The vertex shader isn't used (for as far as I can tell at least) but because the standard
    //vertex shader for spriteBatch is compiled in 2_0 and the God Ray shader in 3_0 I had to implement it
    //manually in order to compile it in 3_0.
        Matrix projection = Matrix.CreateOrthographicOffCenter(0,
        GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height, 0, 0, 1);
        Matrix halfPixelOffset = Matrix.CreateTranslation(-0.5f, -0.5f, 0);
        postProcessing.Parameters["MatrixTransform"].SetValue(halfPixelOffset * projection);

    //Setup all the required data for the shader
        postProcessing.CurrentTechnique = postProcessing.Techniques["Technique1"];
        Vector3 lightPosition = Vector3.Transform(lightPositions[0], world * camera.ViewMatrix * camera.ProjectionMatrix);
        postProcessing.Parameters["lightPosition"].SetValue(new Vector2(lightPosition.X, lightPosition.Y));
    postProcessing.Parameters["Tex"].SetValue(renderTarget);
        postProcessing.Parameters["exposure"].SetValue(0.5f);
        postProcessing.Parameters["decay"].SetValue(0.5f);
        postProcessing.Parameters["weight"].SetValue(0.5f);
        postProcessing.Parameters["density"].SetValue(0.5f);

    //Draw the renderTarget to the screen at the size of the viewport so it fits the screen
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, SamplerState.PointWrap, DepthStencilState.Default, RasterizerState.CullNone, postProcessing);
        spriteBatch.Draw(renderTarget, new Rectangle(spriteBatch.GraphicsDevice.Viewport.X, spriteBatch.GraphicsDevice.Viewport.Y, spriteBatch.GraphicsDevice.Viewport.Width, spriteBatch.GraphicsDevice.Viewport.Height), Color.White);
        spriteBatch.End();

    //Restore some of the changes spriteBatch.Begin() made to the graphics device so the 3D render won't break
        GraphicsDevice.BlendState = BlendState.Opaque;
        GraphicsDevice.DepthStencilState = DepthStencilState.Default;
        GraphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;
    }

sampler2D renderTarget;

#define SAMPLE_AMOUNT 64

Texture2D Tex;
float2 lightPosition;
float exposure;
float decay;
float weight;
float density;

SamplerState State = sampler_state
{
    Texture = <Tex>;
    MipFilter = Point;
    MinFilter = Linear;
    MagFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
};

float4x4 MatrixTransform;

//The default vertex shader of the spriteBatch, implemented manually so it can be compiled in 3_0
void SpriteVertexShader(inout float4 color    : COLOR0,
                        inout float2 texCoord : TEXCOORD0,
                        inout float4 position : SV_Position)
{
    position = mul(position, MatrixTransform);
}

//Copypasted from the tutorial, only changed some variable names
float4 main(float2 texCoord : TEXCOORD0) : COLOR0
{
  // Calculate vector from pixel to light source in screen space.
   half2 deltaTexCoord = (texCoord - lightPosition.xy);
  // Divide by number of samples and scale by control factor.
  deltaTexCoord *= 1.0f / SAMPLE_AMOUNT * density;
  // Store initial sample.
   half3 color = tex2D(State, texCoord);
  // Set up illumination decay factor.
   half illuminationDecay = 1.0f;
  // Evaluate summation from Equation 3 NUM_SAMPLES iterations.
   for (int i = 0; i < SAMPLE_AMOUNT; i++)
  {
    // Step sample location along ray.
    texCoord -= deltaTexCoord;
    // Retrieve sample at new location.
   half3 sample = tex2D(State, texCoord);
    // Apply sample attenuation scale/decay factors.
    sample *= illuminationDecay * weight;
    // Accumulate combined color.
    color += sample;
    // Update exponential decay factor.
    illuminationDecay *= decay;
  }
  // Output final color with a further scale control factor.
   return float4( color * exposure, 1);
}

technique Technique1
{
    pass Pass1
    {
    VertexShader = compile vs_3_0 SpriteVertexShader();
        PixelShader = compile ps_3_0 main();
    }
}