First I want to provide a bit of context on how DateTime.Now is being called.  My game engine includes a messaging system so that objects can create and publish messages to the game so they can be consumed by subscribed objects.  Each message generates a time stamp for itself using DateTime.Now.  The demo game has been purposefully set up to create 800 objects each of which send out new messages every frame.

The following screenshots are from the profiler run with the DateTime.Now call still in the code.  This first image shows the CPU usage ratio between the full update and draw processes:

The following image shows the call to the constructor containing the usage of DateTime.Now.  Note that the usage for the function calling this code (the blue box on the left) is 35.8%.

Lastly, this image shows the CPU percentage used for the DateTime.Now call.

I was really quite surprised to see how much CPU time the DateTime.Now call was using.  I then removed the call and ran the CPU profiler to see how the results changed.  The first image is of the Game.Run() call again showing the ratio between the update and draw methods.  Already it’s clear that removing the DateTime.Now call has improved things since the CPU usage is split more evenly.

The following image shows the call to the constructor which used to contain the call to DateTime.Now.  Notice that the usage for the code calling this function has dropped from 35.8% to 0.9% which is a massive change!

Because the results of this performance test were so surprising I decided to do a bit of googling around the performance of DateTime.Now and it didn’t take very long to find an article confirming that this call is expensive.  The article also states that using DateTime.UtcNow is much faster however I plan on staying away from using DateTime in my game engine.  You can read the article at http://bit.ly/zTJaaT.

This project uses a simple WCF service to get some text from the database on the server and to store details of clicks within the game in the database.  On the server-side it uses LINQ to SQL to interact with the database for retrieving and adding records.

Before running this sample you should probably do a full rebuild of the solution and then update the service reference in the WindowsGame1 project.  Get it from the link below:

Download: http://www.jason-mitchell.com/Uploads/XNAWCFSample-20_09_2011.zip

I decided to post this project because I’ve been at a loss for what to write about recently and I thought this project was so strange that I thought I should share it.  The project was made in XNA 3.0 or 3.1 and may not work anymore depending on what has changed with Twitter’s API; I really don’t know and I haven’t run the game.

Download: http://www.jason-mitchell.com/Uploads/TwitterTicTacToe_24-08-2011.zip

The idea of this project was pretty simple.  I wanted to get the RGB camera stream of me goofing around and use it as the background in an XNA application.  I also wanted to try out some skeleton tracking functionality to test when my hands are intersecting with hot spots (represented as semi-transparent squares) on the screen.  As it turns out, this project was pretty simple and quick to make and overall I’m really quite impressed with how the SDK is to use.

This project makes use of a couple of simple extension methods I created and is fairly heavily based on the samples which get installed with the Kinect SDK.

Download: http://jason-mitchell.com/Uploads/XNA_And_Kinect-28_06_11.zip

The following code shows the implementation of these extension methods.  I must add that this code is pretty much taken straight out of the samples and that I have just reorganised it to make it a bit easier to use.

public static class KinectExtensions
{
    private static Texture2D texture = null;
    private static Color[] colorData = null;
 
    public static Texture2D ToTexture2D(this PlanarImage image, GraphicsDevice graphicsDevice)
    {
        if(texture == null || colorData == null)
        {
            texture = 
                new Texture2D(graphicsDevice, image.Width, image.Height, false, SurfaceFormat.Color);
            colorData = new Color[image.Width * image.Height];
        }
 
        int index = 0;
        for (int y = 0; y < image.Height; y++)
        {
            for (int x = 0; x < image.Width; x++, index += image.BytesPerPixel)
                colorData[y * image.Width + x] = 
                    new Color(image.Bits[index + 2], image.Bits[index + 1], image.Bits[index + 0]);
        }
 
        texture.SetData(colorData);
        return texture;
    }
 
    public static Vector2 GetScreenPosition(this Joint joint, Runtime kinectRuntime, int screenWidth, int screenHeight)
    {
        float depthX;
        float depthY;
 
        kinectRuntime.SkeletonEngine.SkeletonToDepthImage(joint.Position, out depthX, out depthY);
        depthX = Math.Max(0, Math.Min(depthX * 320, 320));  //convert to 320, 240 space
        depthY = Math.Max(0, Math.Min(depthY * 240, 240));  //convert to 320, 240 space
 
        int colorX;
        int colorY;
        // only ImageResolution.Resolution640x480 is supported at this point
        kinectRuntime.NuiCamera.GetColorPixelCoordinatesFromDepthPixel(ImageResolution.Resolution640x480, new ImageViewArea(), (int)depthX, (int)depthY, (short)0, out colorX, out colorY);
 
        // map back to skeleton.Width & skeleton.Height
        return new Vector2(screenWidth * colorX / 640.0f, screenHeight * colorY / 480f);
    }
}}

The implementation of this seemed pretty simple.  I create a new class called Observable which provides methods for (un)subscribing and a property to access the actual value held by the class.  It uses a generic type to define the the value property so it should work in most cases.  So here is the class:

public class Observable<T>
{
    private readonly List<Action<T>> subscriptions = new List<Action<T>>();
    private T observableValue;
 
    public Action<T> Subscribe(Action<T> callback)
    {
        subscriptions.Add(callback);
        return callback;
    }
 
    public void Unsubscribe(Action<T> callback)
    {
        subscriptions.Remove(callback);
    }
 
    public void UnsubscribeAll()
    {
        subscriptions.Clear();
    }
 
    private void NotifyValueChanged()
    {
        foreach (Action<T> callback in subscriptions)
            callback(observableValue);
    }
 
    public T Value
    {
        get { return observableValue; }
        set
        {
            observableValue = value;
            NotifyValueChanged();
        }
    }
}

The class is really simple so I don’t think its worth stepping through the code and explaining it all.  The only thing I do want to point out is the Subscribe method.  It returns the exact same delegate as was passed into the method.  This is really just for convenience if you use a lambda expression to subscribe and need to hold on to it to unsubscribe from the Observable instance later.

To use this class all you need to do is define a new instance of the Observable type (you can see this in the attached demo project) and then use the Value property to set the data in the class.  For example if you wanted an observable Vector2 instance you would define it as “Observable<Vector2> position = new Observable<Vector2>()” and then set its value by using “position.Value = new Vector2(……)”.

I can see using an approach like this would be useful in a few situations.  First of all I think it would be great for separating a game’s logic from its graphics by allowing the graphics in the game to subscribe to the positions of logical entities however there is a bit of redundant data in this approach.  I have also thought that it could be very useful in developing an artificial intelligence framework.  Elements in the game could subscribe to changes in the state of an AI agent and run some code when it changes.  I’m really just throwing around some ideas here.

Update:
So I had a bit of a thought about the class in this post. It’s all well and good when you want to be notified of every change to a property but at the minute I can’t think of a scenario in XNA when I would want that to happen.  Perhaps maybe a position gets modified multiple times in one update (e.g. moving player and finding a collision then “fixing” the players position) which in my sample would result in loads of code being executed for no real reason.  I’m currently playing with a different approach to implement this kind of process which makes use of a GameComponent to notify all interested objects once per update if something has changed.  I will probably post that when I am happy with it – so far I have removed the need for the Observable class in this article but the objects containing observable values must implement an interface for use with the game component.  At the minute I’m trying INotifyPropertyChanged to avoid adding a custom interface but there seems to be a couple of issues that I need to work out here.

Sample Project: http://www.jason-mitchell.com/uploads/XNAObservableDemo-30_04_2011.zip

The class I created is basically an XNA game component which maintains a dictionary of gestures and an associated list of delegates and provides some obvious methods to add and remove gesture callbacks.  The Update method will take care of reading in the gestures from the touch screen and then calling the delegates for any gesture detected.  The code is listed below:

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input.Touch;
 
namespace GestureHelperTest
{
    public class GestureHelper : GameComponent
    {
        public static GestureHelper Instance { get; private set; }
 
        public static void Initialize(Game game)
        {
            if (Instance != null)
                throw new InvalidOperationException("Only one instance of GestureHelper can be created.");
 
            Instance = new GestureHelper(game);
            game.Components.Add(Instance);
        }
 
        private Dictionary<GestureType, List<Action<GestureSample>>> gestureCallbacks;
 
        private GestureHelper(Game game) : base(game)
        {
            TouchPanel.EnabledGestures = GestureType.None;
            gestureCallbacks = new Dictionary<GestureType, List<Action<GestureSample>>>();
        }
 
        public void AddCallback(GestureType gestureType, Action<GestureSample> callback)
        {
            if (!gestureCallbacks.ContainsKey(gestureType))
            {
                TouchPanel.EnabledGestures |= gestureType;
                gestureCallbacks.Add(gestureType, new List<Action<GestureSample>>());
            }
 
            gestureCallbacks[gestureType].Add(callback);
        }
 
        public void Clear()
        {
            TouchPanel.EnabledGestures = GestureType.None;
            gestureCallbacks.Clear();
        }
 
        public void ClearGesture(GestureType gestureType)
        {
            TouchPanel.EnabledGestures -= gestureType;
            gestureCallbacks.Remove(gestureType);
        }
 
        public override void Update(GameTime gameTime)
        {
            while (TouchPanel.IsGestureAvailable)
            {
                GestureSample gestureSample = TouchPanel.ReadGesture();
 
                if (gestureCallbacks.ContainsKey(gestureSample.GestureType))
                {
                    foreach (Action<GestureSample> callback in gestureCallbacks[gestureSample.GestureType])
                        callback(gestureSample);
                }
            }
 
            base.Update(gameTime);
        }
    }
}

The class is basically implemented as a singleton but with a little bit of a deviation.  I’ve opted to not allow lazy initialization of the class in favour of requiring the user to explicitly initialize it to keep it nice and clean when creating the game component.  Adding the GestureHelper to the components list could be done in the game class but it will basically amount to the same thing (ie requiring the user to perform some initialization step).

In the sample project I’ve created, I provide the following examples of how to handle a gesture with my GestureHelper class:

protected override void Initialize()
{
    GestureHelper.Initialize(this);
    GestureHelper.Instance.AddCallback(GestureType.FreeDrag, gestureSample => position = gestureSample.Position);
    GestureHelper.Instance.AddCallback(GestureType.Hold, gestureSample => scale = 1);
    GestureHelper.Instance.AddCallback(GestureType.Tap, ScaleSquare);
 
    base.Initialize();
}
 
private void ScaleSquare(GestureSample gestureSample)
{
    scale += 0.1f;
}

The first two examples pass lambda expressions to the AddCallback method and the third passes a method.  Once these delegates have been added that’s it!  No more code is needed to handle these gestures!

This class is the result of a bit of experimentation that has been working out well for me.  I’d really appreciate any opinions that others might have on this approach to handling gestures.

Sample Project: http://www.jason-mitchell.com/Uploads/GestureHelperTest-08_04_11.zip

http://blogs.msdn.com/b/shawnhar/archive/2008/08/12/everything-you-ever-wanted-to-know-about-intermediateserializer.aspx

For anyone working with XML and the content pipeline in XNA I strongly recommend taking a read through it!