Meanwhile, in Jim “So Evil That Even George Ducks and Covers” Perry-land the Overlocker himself continues to spam his blog. This time, he covers Spy Game Design – Multiplatform Issues/Capability and Spy Game Design – Character Training. Lets see if he can keep up the pace while The Hidden One continues to, well, hide.

First, there’s Michael B. “Concise” McLaughlin of Bob Taco Industries fame. Expect even more words coming from this man and his blog (and now his forums).

Next up comes the John “The Pale Impaled” Defenbaugh, joining Jim “The Closer” Perry, armed with his shut gunshotgun the threads will fall left and right like clay pigeons. Luckily he still ain’t havin’ the permissions.

The third one is MIA currently… [Update: OK, our intelligentintelligence services managed to get ahold of his name now, Dr. Minh-Triet TRAN, but not many more details…]

Lets hope thisthese guys can fulfill the demands of the community…

[Update: Moo]

Meanwhile Andy “Ratava” Dunn ponders self publishing, asking for feedback.

In related news: Shawn Hargreaves put a ring on it (the ring finger), too, so we use this opportunity to also congratulate The Shawn!

P.S.: We place our bets on Andy Dunn to be the next to take the chance…

Anyway, George W. “Bugbear” Clingerman feels unhated and so did Vincente “Bête Noire” Cartas, Chris G. “Daggers Drawn” Williams started something, Andy “Jealous as a Barbary Pigeon” Dunn likes to do the opposite, Charles “Demoniacal” Humphrey ain’t impressed, Jim “Philophilosophos” Perry reviews movies.

George W. “Knockando” Clingerman shares links, has a heart of gold and is in good company.

Glenn “Miltonduff” Wilson returns to XNA while Andy “Inchgower” Dunn keeps on runnin’.

Ed. Stalking is my business and business is bad. Moo?

Now this sample has come from my current XNA toy which is the Blacksun engine I am currently writing in XNA 3.1. It uses deferred lighting, instancing and a post processing framework that I found on a great site here, all I had to do was make it engine ready.

If you want to have a look at the effect in the engine you can see it here.

This sample is just one of the elements from the post processing framework in the engine, there are none of the other goodies in this sample, just the Sun post process. This sample has also been created using the XNA 4.0 CTP, so I only had one render target to work with at the time. This means that you can't see the sun being culled behind objects in the scene as I can't create a depth map as well as the rendered scene, to be honest, I still don't have that bit of the shader 100% anyway

So, what do you get in this sample, well, the sun shader and the lens flare effect all in one post process and done in XNA 4.0. It's a pretty simple effect really, taking the suns position in the world, then just finding its screen coordinates on the render target and render the sun flare texture, then render the texture again over a set of offset texture coordinates to give the lens flare effect.

Lets take a look at the code...

Sun.fx

We have a few variables we can pass to the shader to control this effect, the names I hope are quite self explanatory, well most of them

float3 cameraPosition;

float SunSize = 1500;

float Density = 3;
float Exposure = -.1;
float Weight = .25;
float Weight2 = .125;
float Decay = .5;

float3 lightPosition;

float lightIntensity = 10.0f;
float3 Color = float3(1,1,1);

texture flare;
sampler Flare = sampler_state
{
    Texture = (flare);
    AddressU = CLAMP;
    AddressV = CLAMP;
};

sampler BackBuffer : register(s0);

//depth
texture depthMap;
sampler depthSampler = sampler_state
{
    Texture = (depthMap);
};

struct VertexShaderInput
{
    float3 Position : POSITION0;
    float2 texCoord : TEXCOORD0;
};

struct VertexShaderOutputToPS
{
    float2 texCoord : TEXCOORD0;
};

Those that I guess are not that obvious are Density to Decay and these relate the the lens flare part of the shader and control the number of texture samples to display, density of those samples etc..

So onto the lane flare function that is used in the shader to give the lens flare effect.

float4 DoLenseFlare(float4 ScreenLightPosition,float2 texCoord,bool fwd)
{
    // Calculate vector from pixel to light source in screen space.
    float2 deltaTexCoord = (texCoord - ScreenLightPosition.xy);// Divide by number of samples and scale by control factor.
    deltaTexCoord *= 1.0f / 3 * Density;

    // Store initial sample.
    float3 color = 0;

    // Set up illumination decay factor.
    float illuminationDecay = 1.0f;

    for (int i = 0; i < 3 ; i++)
    {
        // Step sample location along ray.
        if(fwd)
            texCoord -= deltaTexCoord;
        else
            texCoord += deltaTexCoord;

        // Retrieve sample at new location.
        float3 sample = tex2D(Flare, texCoord);

        // Apply sample attenuation scale/decay factors.
        if(fwd)
            sample *= illuminationDecay * Weight;
        else
            sample *= illuminationDecay * Weight2;

        // Accumulate combined color.
        color += sample;

        // Update exponential decay factor.
        illuminationDecay *= Decay;
    }

    return float4(color,1);
}

I can take very little credit for this bit of the code, as I got it from GPU Game 3 Chapter 13 Volumetric Light Scattering as a Post Process, not exactly using it as it was intended, but is does the job I wanted here well enough

So the pixel shader itself that pulls this all together looks like this

float4 PixelShaderFunction(VertexShaderOutputToPS input) : COLOR0
{
    // Get the scene
    float4 col = tex2D(BackBuffer,input.texCoord);// Find the suns position in the world and map it to the screen space.
    float4 ScreenPosition = mul(lightPosition - cameraPosition,VP);
    float scale = ScreenPosition.z;
    ScreenPosition.xyz /= ScreenPosition.w;
    ScreenPosition.x = ScreenPosition.x/2.0f+0.5f;
    ScreenPosition.y = (-ScreenPosition.y/2.0f+0.5f);

    // get the depth from the depth map
    //float depthVal = 1- tex2D(depthSampler, input.texCoord).r;

    // Are we lokoing in the direction of the sun?
    if(ScreenPosition.w > 0)
    {
        float2 coord;

        float size = SunSize / scale;

        float2 center = ScreenPosition.xy;

        coord = .5 - (input.texCoord - center) / size * .5;

        //if(depthVal > ScreenPosition.z-.0003)
        col += (pow(tex2D(Flare,coord) * float4(Color,1),2) * lightIntensity) * 2;

        // Lens flare
        col += ((DoLenseFlare(ScreenPosition,input.texCoord,true) + DoLenseFlare(ScreenPosition,input.texCoord,false)) * float4(Color,1) * lightIntensity) * 5;
    }

    return col;
}

You will see in here that I have left in the code for detecting the depth of objects in the scene for sun culling and just commented it out, when you have a full release XNA 4.0 you will be able to create and pass in the depth map, but it’s not possible in the current CTP.

So what am I doing in the pixel shader, first off we grab the current scene’s color, I then get the position of the light in screen space by multiplying its position by the camera position and then doing the homogeneous divide (ScreenPosition.xyz / ScreenPosition.w) to get the position of the sun (see the Get2DCoords method below for my inspiration for this). Then, if we are looking in the direction of the sun (ScreenPosition.w > 0) then we need to render the sun and or lens flare. I then calculate the size of the sun and find the tex coords required to get the texture from the Flare sampler and then add this with the sun color and raise it to the power of 2, this lightens the light bits and darkens the dark bits, this is then multiplied by the light intensity and the final values doubled again. Then we come to the lens flare, I call this twice: once for each direction of the flare (you will see in the clip there are two) and again tint this to the sun color and multiply by intensity.

Now please feel free to pick my dodgy math’s apart here I know I suck, but it is working and I have not thought much more abut it since writing it

Game Code

First thing we will do is set up a render target and and effect so we can apply our sun as a post process.

RenderTarget2D rt;
Effect effect;

Also some way of representing the sun’s position, color intensity and size

Vector3 sunPosition = new Vector3(100, 200, -1000);
Color sunColor = Color.White;
float sunIntensity = 1f;
float sunSunSize = 1500;

Now we have these variable lined up and ready to use we can initialize both the render target and the effect shader

rt = new RenderTarget2D(GraphicsDevice, GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height);

effect = Content.Load<Effect>("Shaders/PostProcessing/Sun");
effect.Parameters["flare"].SetValue(Content.Load<Texture2D>("Textures/PostProcessing/flare"));
effect.Parameters["Color"].SetValue(sunColor.ToVector3());
effect.Parameters["lightIntensity"].SetValue(sunIntensity);
effect.Parameters["SunSize"].SetValue(sunSunSize);
effect.Parameters["lightPosition"].SetValue(sunPosition);

Now we need to make sure the shader/effect is updated with the required variables. So in our update method we set the following parameters

effect.Parameters["VP"].SetValue(camera.View * camera.Projection);
effect.Parameters["cameraPosition"].SetValue(camera.Position);
//effect.Parameters["depthMap"].SetValue(depthBuffer);

And now for the render, keep in mind that this is all done just for this sample, you will want to encapsulate all this in its own class deriving from DrawableGameComponent or in a post processing framework as shown in the link above.

    GraphicsDevice.SetRenderTargets(rt);
    GraphicsDevice.Clear(<Color.Black);
    base.Draw(gameTime);

    // Post Processing.
    GraphicsDevice.SetRenderTargets(null);

    GraphicsDevice.Textures[0] = rt;
    spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
    effect.Techniques[0].Passes[0].Apply();
    spriteBatch.Draw(rt, new Rectangle(0, 0, rt.Width, rt.Height), Color.White);
    spriteBatch.End();

So, we setup the render target, allow the scene to be drawn (nothing gets drawn in this sample), then we resolve the render target and then apply our effect to the newly captured render target.

As mentioned earlier I have a method I use to get screen coordinates from a 3D screen position, this method I am 99% sure I got (or at least the nuts and bolts of it) from Rocket Commander which was written by Benjamin Nitsche

public Vector2 Get2DCoords(Vector3 myPosition, Base3DCamera Camera)
{
    Matrix ViewProjectionMatrix = Camera.View * Camera.Projection;
    Vector4 result4 = Vector4.Transform(myPosition, ViewProjectionMatrix);

    if(result4.W <= 0)
        return new Vector2(Camera.Viewport.Width, 0);

    Vector3 result = new Vector3(result4.X / result4.W, result4.Y / result4.W, result4.Z / result4.W);

    Vector2 retVal = new Vector2((int)Math.Round(+result.X * (Camera.Viewport.Width / 2)) + (Camera.Viewport.Width / 2), (int)Math.Round(-result.Y * (Camera.Viewport.Height / 2)) + (Camera.Viewport.Height / 2));

    return retVal;
}

As you can see it transforms the position by the ViewProjection matrix to then get the screen position if the result4.W >= 0.

Download the sample project here
Well that’s abut it, and this is my first post on Sgt Conker, hope it’s not my last one Hope you find this useful, if not in it’s own right, then I hope it gives you some ideas for your own shaders…..

Meanwhile, on a Saturday night at 2:20 Pieter “Dajal” Germishuys talks about drinking coffee. The day after Andy “Blonde d'Aquitaine” Dunn runs 50 miles.

Chris G. “Red Angus” Williams fears small people, frags for charity and Goerge W. “Dølafe” Clingerman downplays his contribution.

John “Wagyū” Sedlak needs.

[Ed.: Somehow the relevance of the subjects actions of this very series is not what it used to be, resulting in a sort of dilemma of what to actually share here. Today's nick names ain’t the most inspired either…]

Intermission: most of the personas featured in this series are part of the preferable category mentioned at The Problem With MVPs – and, frankly, I cannot name one that would fall into the other category right now…

Vincente “Curan” Cartas battens in memories of the MVP Summit, Chad “Oswald” Carter repudiates his fetish and Chris G. “Edgar” Williams meets Kharma and has a Game Design Dilemma, asks Nine Questions.

Meanwhile, George W. “Fool” Clingerman is back at work, accepts meetings when there’s coffee and doesn’t know who he is. Richard “Caius” Fine knows himself.

Catalin “A Herald” Zima will be with us for yet another year and so will Pieter “Old Man” Germishuys. But at the end of the week, only George W. “Fool” Clingerman counts.

Meanwhile, George W. “The Frayed Ends of Sanity” Clingerman stares at walls, not goats and Chris G. “Fade to Black” Williams says Good Night.

Glenn “Welcome Home (Sanitarium)” Wilson installs the Windows Phone Developer Tools CTP finally, Jon “Escape” Watte releases a beta of kW X-port 1.4.5 for 3DS Max 2010 and in a desperate move Andy “Harvester of Sorrow” Dunn begs for common sense to be applied during peer review. Following the lead of desperation, Iñaki “Whiplash” Ayucar fulminates against clones, strongly.

John “Motorbreath” Sedlak has a new jacket, with a back, plays games, writes cryptic code. Joel “Ride the Lightning” Martinez loves LINQ and threats to release a game. Finally, Chad “Hit the Lights” Carter is a happy daddy.