If you have anything you want to see in v2 or in the future, please head over to the discussion board, specifically this post: http://scripttd.codeplex.com/discussions/277634 and give your feedback. I probably won’t do anything too unique as this is still supposed to be a general engine, but if you feel there were features important to the Tower Defense genre that were missing from v1.x, please let me know, and vote in the Trello board if they’re already there.

ScriptTD is a project I have been working on for the past year now, although we officially launched a couple of months ago, I’m still working on v2.0. The goal was to create a Tower Defense game engine for Windows Phone 7, allowing people with no coding knowledge to change the data files and art/sounds to create their own Tower Defense game. This was an interesting challenge to work on, and I’m reasonably happy with the first result, however there is still plenty to add and refine.

You can get the source code for the project at http://scripttd.codeplex.com/ and there is quite a bit of information about what each XML file does. I also wrote an article which is located at http://channel9.msdn.com/coding4fun/articles/ScriptTD-Tower-Defense-Made-Easy and covers how to extend the code (C#) to create a new weapon type.

For those interested in trying out the game on their Windows Phone 7 devices, you can get it from the following marketplace link:

http://www.windowsphone.com/en-GB/apps/ee836335-27a7-e011-986b-78e7d1fa76f8

Be aware: it is quite challenging, but free for everyone. The game is compiled for WP7.0, so you don’t have to have Mango to run it.

He currently has two parts complete, covering the UI and UV Mapping, with more on the way.

You can read the series at his blog on the XNA UK User Group here:

Part I – UI and Exporting

Part II – UV Mapping

Part III – Normal Maps

The first step is deciding which side will create the session and which side will join. Considering we only have the option of working with the Xbox 360, and you might not want to include any debug views or information in your Xbox code, the option I chose is to have the Xbox create the session. The code is compatible on both platforms so if you’re willing to add some system to find and join an active session, you can easily change this to create the session on the PC. For the purposes of this article the session will only contain two “Players” and the Xbox will create whilst the PC side joins.

Creating

We start by creating a session, in XNA you can do this with the NetworkSession.Create() command, which creates a NetworkSession object that maintains the session. Then specify session.AllowJoinInProgress to be true, this lets you create the session and at any time join or rejoin from the PC side.

_session = NetworkSession.Create(NetworkSessionType.SystemLink, 1, 2);
_session.AllowJoinInProgress = true;

Another key thing to note here is that you will want to specify the network session type as SystemLink, this lets you sign in with your Creators Club gamer tag on the Xbox, and use a local player on the PC side – no extra accounts!
We then specify a maximum of one local gamer on the Xbox side, and a total of two gamers in the session. (Change as needed)
Finally we handle the session.GamerJoined event and in the handler we start the game if the current session state is set to Lobby.

Receiving

At this time you might want to also create a PacketReader and PacketWriter, as we will be using these to do our communication. These can be created at any time, and are not tied to a session, so it is a good idea to create them once and re-use over multiple sessions/games.

How you want to receive the data is up to you, however I chose to allow the Xbox game to register some callbacks for named commands. That way the PC side can specify the name of the command and send data along, which can be passed through as a byte array. This is rather simple to setup, you simply maintain a Dictionary<string, Action<byte[]>> that contains all of the callback delegates and names. Then when a packet comes in it will have the name of the callback as well as the byte[] data, which lets you gets the callback from the Dictionary and call it, passing in the data as is.

On the PC side you simply send the callback name, length of the byte array and the bytes themselves, ready for the Xbox to accept and use.

I further split this into “Commands” and “Data”, to provide a clear separation of things like console commands, and raw data, but both use the same system of a Action<byte[]> delegate callback.

Joining

When joining, the PC needs to do two things:

1. Search for sessions
2. Join a chosen session

The NetworkSession.Find() method provides a list of available sessions currently running over SystemLink, which is usually going to be just one, however if you’re working in a larger team with multiple systems on the same network, you might want to list them and display the host gamertag, so that you can choose the right one.

Once you have chosen the network session, you pass that to NetworkSession.Join() which creates a NetworkSession object that you can use just like you do on the server – except this time you don’t worry about starting the game.

Updating

Once the session has been created and is up and running, on both platforms you need to call session.Update() in your update loop. This handles the networking side of things and gets/sends the packets as needed.

Once you have updated, you can make use of the PacketReader and PacketWriter objects to receive and send packets respectively. To receive the data, you need to first check if there is data available by checking the session.LocalGamers[0].IsDataAvailable flag. If there is data available, you can call session.LocalGamers[0].ReceiveData() passing in the PacketReader which you can then use to parse the packet and call the appropriate callback.

If you have data you want to send, you just need to call session.LocalGamers[0].SendData(), and pass in the PacketWriter with the data you want to send.

In the background XNA handles the network magic, so you just have to worry about handling the data on either end.

Code

I didn’t have time to put up a complete code sample for this article, however I hope you understand the general technique. Code for something like this really needs to be tailored to your purpose. If you are just writing a debug console or tweak system, you can just use the command system mentioned below. However if you want to write a sync system for your editor, with camera sync and everything else, you will probably want to change how you send and receive data to optimise for what you are sending.

Create

_session = NetworkSession.Create(NetworkSessionType.SystemLink, 1, 2);
_session.AllowHostMigration = false;
_session.AllowJoinInProgress = true;
_session.GamerJoined += (s, e) =>
{
    if (_session.SessionState == NetworkSessionState.Lobby)
        _session.StartGame();
};
_session.GamerLeft += (s, e) => _session.EndGame();

Find

AvailableNetworkSessionCollection sessions = NetworkSession.Find(NetworkSessionType.SystemLink, 1, null);

Join

(‘session’ is an AvailableNetworkSession taken from the collection in Find)

_session = NetworkSession.Join(session);

Update

if (_session != null)
{
    _session.Update();
    if (_writer.Length > 0)
        _session.LocalGamers[0].SendData(_writer, SendDataOptions.None);
    while (_session != null && _session.LocalGamers[0].IsDataAvailable)
    {
        NetworkGamer sender;
        int numBytes = _session.LocalGamers[0].ReceiveData(_reader, out sender);
        if (numBytes > 0 && !sender.IsLocal)
        {
            string methodName = _reader.ReadString();
            int numBytes = _reader.ReadInt32();
            var data = _reader.ReadBytes(numBytes);
            Action method;
            if (!string.IsNullOrEmpty(methodName) && _commands.TryGetValue(methodName, out method))
                method(data);
        }
    }
}

Sending

public void SendCommand(string methodName, byte[] data)
{
    _writer.Write(methodName.ToLower());
    if (data != null)
    {
        _writer.Write(data.Length);
        _writer.Write(data);
    }
    else
    {
        _writer.Write(0);
    }
}

When implementing the light pre-pass algorithm in XNA 4.0, I found that the alpha channel was messing around with my intermediate render targets.
To resolve this, you need to create a custom blend state object (cache it) with the colour and alpha destination and blend states set to BlendState.One.

This should prevent any modulation based on the alpha value in a texture when sampling.

*Edit* Small code sample:

var _alphaBlend = new BlendState()
            {
                AlphaDestinationBlend = Blend.One,
                AlphaSourceBlend = Blend.One,
                ColorDestinationBlend = Blend.One,
                ColorSourceBlend = Blend.One
            };

So today was Academic Day, in particular, for faculty members, who had been invited to hear about what students want, directly from students. (That was the theme)

A couple of weeks previously, Andrew Parsons (@MrAndyPuppy), the local Academic Developer Evangelist asked me to do a presentation on Windows Phone 7, with a split between the experience promised by Microsoft, and developing for the phone. After I learned that I really cannot do a reasonable phone demo in 10 minutes, I cut it down to a demo of pre-made code.

Either way, some big highlights arose today. I managed to get Andy to let me see and use a developer phone, and I must say, awesome, however I cannot go into specifics, nor can I take photos unfortunately.

The other highlight was the awesome keynote presented by Michael Kordahi (@delic8genius) with a special appearance by August De Los Reyos (@augustdlr) presenting his experiences developing User experiences on the Surface, and even the Windows key on the keyboard. Some awesome demos for a theoretical Foxtel experience (Cable TV in Australia) that uses all devices, including a Surface table (jeez they love that thing). They then showed off the big devices for this year, Kinect and Windows Phone 7, and seeing this in person was really awesome. I cannot wait for next week when I will get to try out a device. (Unfortunately they took the device back to Sydney right after the keynote.)

Photos will follow as I can sort them out, and maybe videos depending on what I’m allowed to post, and what connection I can get.

Exciting days remain ahead, I have to present Windows Phone 7 to students on Thursday, and of course I must experience the great TechEd sessions.

The key to deferred rendering and other techniques is the ability to use a depth map to store world position. As we know a depth map consists of floating point values (optimally) and so normally we would use those values with our Clip Space coordinates and the Inverse of the ViewProjection matrix to get the position in World Space.

However there is another way to do this, and the big benefit is that it does not require a matrix multiplication to do so.

Presented by Crytek during a presentation on Atmospheric Scattering, this method uses just a Multiply + Add to get the position in World Space from our depth value at that point. To do this we need to get the far view frustum corners, in View Space, and pass them to the shader.

Getting the Corners

This is easily done in XNA through the BoundingFrustum.GetCorners() method. Note that we only need the far corners, so we can take the last 4 in the 8 element array, and we also need these corners in View space, so be sure to transform them by the View matrix before you pass them through.

private void getFrustumCorners(out Vector3[] corners)
{
    corners = new Vector3[4];

    Vector3[] temp = CurrentCamera.Frustum.GetCorners();
    for (int i = 0; i < 4; i++)
    {
        corners[i] = Vector3.Transform(temp[i + 4], CurrentCamera.View);
    }
}

Since we are in the CPU/XNA code, be sure to also pass the depth of the far clip plane, and the camera’s World matrix. (Simply invert the View matrix if you do not already have a World matrix)

Writing out Depth

Now for some shader code! First in the depth shader, you need to change how you write out the depth value, instead we take the Linear View Space depth, which means that we need to get the Z value from Position * World * View rather than Position * World * View * Projection.

float4x4 wv = mul( World, View );
float4 posVS = mul( pos, wv );

output.Position = mul( posVS, Projection );
output.Depth = posVS.z;

Then in the pixel shader, take this depth value, negate it and divide it by the Far Clipping plane.

output.Depth = 1.0f - ( -depth / FarClip );

Now when you want to reconstruct this, we need to find the correct frustum corner inside the vertex shader. (Note: This code only applies if you are rendering a fullscreen quad)

Preparing and Choosing the Right Corner

The best way to do this is to pass along the array index as a 3rd value with your texture coordinates. If you do not want to modify the vertex type, you can also apply some maths to determine the right index.

For brevity I will assume that the index is provided with the texture coordinates.

Take that ray and multiply it by the camera World matrix, to move the ray into World space, then pass it to the pixel shader.

output.FrustRay = mul( FSQ_GetFrustumRay( tcri.z ), CamWorld );

Getting the Position

Now that you have the ray, simply sample the depth texture for the depth value, and multiply it by the ray. Then take that and add it to the camera position to get the point in world space. (Rather than just a direction)

float depth = 1.0f - tex2D( depthSampler, tc ).x;
float3 pos = CamPosition + depth * frustRay;

Now you have your position!

I will include the technique to do the same thing with arbitrary world geometry when I write an article on Point Lights or Spotlights. At the moment I am working on implementing shadows, and probably won’t touch those topics until I solve some pressing issues.

Final Notes

Here is a code sample for passing the index as a part of the texture coordinate value.

private struct VertexPositionTexCoordRayIndex
{
    private Vector3 position;
    public Vector3 Position
    {
        get { return position; }
        set { position = value; }
    }

    private Vector3 texCoordRayIndex;
    public Vector3 TexCoordRayIndex
    {
        get { return texCoordRayIndex; }
        set { texCoordRayIndex = value; }
    }

    public static int SizeInBytes { get { return sizeof(float) * 6; } }

    public static readonly VertexElement[] VertexElements =
        new VertexElement[] {
            new VertexElement(0, 0, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Position, 0),
            new VertexElement(0, sizeof(float)*3, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 0)
        };

    public VertexPositionTexCoordRayIndex(Vector3 position, Vector3 texcoordRayindex)
    {
        this.position = position;
        this.texCoordRayIndex = texcoordRayindex;
    }
}

VertexPositionTexCoordRayIndex[] verts = new VertexPositionTexCoordRayIndex[4];
verts[0] = new VertexPositionTexCoordRayIndex(new Vector3(-1, 1, 1), new Vector3(0, 0, 0));
verts[1] = new VertexPositionTexCoordRayIndex(new Vector3(1, 1, 1), new Vector3(1, 0, 1));
verts[2] = new VertexPositionTexCoordRayIndex(new Vector3(-1, -1, 1), new Vector3(0, 1, 3));
verts[3] = new VertexPositionTexCoordRayIndex(new Vector3(1, -1, 1), new Vector3(1, 1, 2));

Remember that XNA provides the corners in a different order to just 1,2,3,4, so we can explicitly pass the correct index for the vertex we are working with here, and it will be chosen correctly in the shader.

Apologies for the lack of updates, I am in the process of finishing an internship required for my university course, and it is a challenge to find good time to tackle some XNA issues and write posts.

I am currently working on Directional light shadows for my engine, I have cascaded shadow maps implemented, and now I am just tackling some issues I have encountered, which is taking a while – I also need to find a good filtering method.

If I get bored of trying to fix those annoying issues, I will probably jump into re-implementing point lights, and spotlights, and write something about those.

Some housekeeping notes:

I encountered a pretty big issue with the “Reconstructing position from depth” technique, and I have taken that article down from the blog for now. At the moment my own code uses the old “Multiply my the Inverse of the View Projection matrix”, and probably will continue to until I have time to solve that problem.

I have also updated this blog to WordPress 3.0, so let me know if you encounter any issues.

Back to work.

I have found that the simplest way to integrate these ambient lights into the Light Pre Pass system, and allow for other elements to change the lights throughout the game is to create a new light type that fits into the normal lighting model.

This is probably the simplest type out there, you just create a full screen quad and render it using a shader that writes the colour information directly to the light buffer. All we have to pass to the shader is the colour and intensity. (you could always pre-compute this, but beware of the byte->int32 auto promotion C# does)

Here is the C# class:

public class AmbientLight
{
    public Color Color { get; set; }

    public bool Enabled { get; set; }

    private int intensity = 100;

    public int Intensity
    {
        get { return intensity; }
        set { intensity = value; }
    }

    private Effect shader;

    public AmbientLight(Color col, int intensity)
    {
        this.Color = col;
        this.Enabled = true;
        this.intensity = intensity;
    }

    public void LoadContent(ContentManager content)
    {
        shader = content.Load<Effect>(@"Effects\Lights\l_ambient");
    }

    public void DrawLight(Renderer caller)
    {
        if (!Enabled)
            return;

        shader.Begin();
        shader.Parameters.TrySet("LightColor", Color.ToVector3());
        shader.Parameters.TrySet("Intensity", intensity);

        shader.CurrentTechnique.Passes[0].Begin();
        caller.FSQ.Draw();
        shader.CurrentTechnique.Passes[0].End();

        shader.End();
    }
}

and the shader:

float3 LightColor;
float Intensity;

float4 vs_main(in float4 pos : POSITION) : POSITION
{
    return pos;
}

float4 ps_main() : COLOR
{
    return float4(LightColor * (Intensity / 100), 0);
}

technique AmbientLight
{
    pass p0
    {
        VertexShader = compile vs_2_0 vs_main();
        PixelShader = compile ps_2_0 ps_main();
    }
}

I am in the middle of a crunch at work, and so future posts will be slow until it is all over. (That is why this one took a while to come out) I have not had the chance to do much work on my own XNA code, let alone tutorials.

Thanks for your patience, I cannot wait to get back to XNA. (and I cannot wait for XNA 4.0 with HiDef)