XNA

Screening Capturing Your XNA Game

Jason Whitehorn — Sun, 11 Feb 2007 00:44:00 GMT

UPDATE (12/17/2007): My blog has moved. This post is now located at: http://jason.whitehorn.ws/2007/02/10/Screening+Capturing+Your+XNA+Game.aspx

Screen capturing your XNA game on Windows is a straight forward task, unfortunately it is not as easy if your game is running on the Xbox. Luckily Shawn Hargreaves explained an interesting technique for capturing screenshots from Xbox XNA games.

He proposes using System.Diagnostics's Trace method to transfer data from the Xbox 360 to your PC.

Dream, Build, Play... Go!

Jason Whitehorn — Thu, 01 Feb 2007 04:14:00 GMT

UPDATE (12/17/2007): My blog has moved. This post is now located at: http://jason.whitehorn.ws/2007/01/31/Dream+Build+Play+Go.aspx

Dream, Build, Play looks live!!!!

Multithreading for the Xbox 360

Jason Whitehorn — Sun, 28 Jan 2007 00:00:00 GMT

UPDATE (12/17/2007): My blog has moved. This post is now located at: http://jason.whitehorn.ws/2007/01/27/Multithreading+For+The+Xbox+360.aspx

When multithreading on the Xbox 360, here are a few things to keep in mind.

Affinity
In multithreaded programming, programmers often lack the ability to specify the Processor Affinity of a thread. Even when API calls are available to specify a processor, it is usually ignored. The reason for this is that modern operating systems have many processes running, each with many threads. The operating system zealously manages processor affinity in order to maximum some metric.

But what about the Xbox? The Xbox 360's operating system does not manage processor affinity. All threads run on the same processor as their parent unless otherwise stated. This basically means that you, the programmer, are responsible for managing processor affinity of your threads, and therefore your applications overall performance.

Processors
The Xbox 360 has a 3 core processor capable of running 2 hardware threads each. For simplicity sake, think of this as a system with 6 processors. You can set your threads affinity to 4 of the 6 "processors". Each processor is identified by a number, 0 through 5, and processors 0 and 2 are not available for your use.

Now that we have established some basics about multithreading and the Xbox 360, lets look at the single method that makes all of this possible.

SetProcessorAffinity
The SetProcessorAffinity method of the Thread class is the only method needed to manage the processor affinity of your games while running on the Xbox 360. In fact, this method is only available for Xbox 360 projects.

The Game Of Life

Jason Whitehorn — Tue, 23 Jan 2007 07:33:00 GMT

UPDATE (12/17/2007): My blog has moved. This post is now located at: http://jason.whitehorn.ws/2007/01/24/The+Game+Of+Life.aspx

I had been thinking about creating a version of Conway's Game Of Life for XNA, but it would appear that I was beat. I just found this one, which is far nicer looking than anything I could have thrown together.

Xbox 360 Button Icons

Jason Whitehorn — Sun, 21 Jan 2007 23:43:00 GMT

UPDATE (12/17/2007): My blog has moved. This post is now located at: http://jason.whitehorn.ws/2007/01/22/Xbox+360+Button+Icons.aspx

I guess its true that old news is new news if you've never heard it before. In case anyway else missed this, back in September Sinnx at 360P posted Xbox 360 Button Graphics.

Embedding Assets Into Your XNA Game

Jason Whitehorn — Sun, 21 Jan 2007 20:43:00 GMT

UPDATE (12/17/2007): My blog has moved. This post is now located at: http://jason.whitehorn.ws/2007/01/22/Embedding+Assets+Into+Your+XNA+Game.aspx

Currently I am a working on a small XNA project whose solution is composed of 4 projects, a DLL, a Windows Game, a Xbox 360 game, and a level editor. Each projects needs access to my assets (currently just 2d sprites), and has raised the interesting question of how to easily share them between each project.

What I had been doing was adding the assets to the Windows game as pipeline content. After compiling it I would then copy the compiled assets from the bin directory, to the bin directories of the level editor and the Xbox 360 game. While this worked, it was error prone and time consuming.

Instead I found that I can add my assets to the DLL as embedded content, and then load them at runtime. Normally you would have probably loaded content by calling the "Load" method of "ContentManager", like:

            _content.Load<Texture2D>("mySprite");

As stated above, the problem with this solution is that "mySprite" would have had to been compiled into the content pipeline. When your assets are added as embedded content, the above method does not work. Instead, you can load your content like this:

            Assembly asm = Assembly.GetExecutingAssembly();
            Texture2D.FromFile(_graphicsDevice, asm.GetManifestResourceStream("SampleProject.Textures.mySprite.png"));

I have tried this for both PNG and Targa formatted textures, and it works just fine. Now all of my assets are embedded into the same DLL that contains my game engine.

Lisp interpreter for XNA

Jason Whitehorn — Sun, 21 Jan 2007 03:31:00 GMT

UPDATE (12/17/2007): My blog has moved. This post is now located at: http://jason.whitehorn.ws/2007/01/21/Lisp+Interpreter+For+XNA.aspx

I just found a Lisp interpreter for use with XNA. It was created by Jon Watte in C#, and is compatible with both Windows and the Xbox 360.

For those who are unfamiliar with Lisp, it is a high-level functional language created by John McCarthy in 1958. Lisp is commonly used by artificial intelligence researchers, and could come in handy for adding in-game AI to your next XNA project.