RandomChaos

Generic XNA - Threading for Windows & XBox 360

Nemo Krad — Fri, 15 Aug 2008 10:55:00 GMT

OK, I went back to my old threading code to port it to the 360 so I could start playing about with processor affinity (as promised last time) and found the compact framework for the 360 was a bit thin on the ground for parameterized threading, so I have re written the whole thing and it will now play on both the PC and the 360 and also included processor affinity for your 360 projects and there is very little interface change so if you were using the code for your Windows games you can just replace the threading code wit this and you wont have to alter any of your calls to it.

So, what did I do??

Pretty much ripped the lot out and started again. The ThreadManagers innards have been totally re done, now instead of having a shed load of Dictionaries holding mutex's and the like we now just have three, one for the thread starters, one for the threaded code and one for the threads them selves.

    /// <summary>
    /// This is the Thread manager.
    /// </summary>
    public class ThreadManager : GameComponent
    {

        /// <summary>
        /// List of ThreadStart used to start the treads.
        /// </summary>
        private Dictionary<int, ThreadStart> threadStarters = new Dictionary<int, ThreadStart>();
        private Dictionary<int, ThreadCodeObj> threadedCodeList = new Dictionary<int, ThreadCodeObj>();
        /// <summary>
        /// List of runnign threads.
        /// </summary>
        private Dictionary<int, Thread> threads = new Dictionary<int, Thread>();

        /// <summary>
        /// Managers GameTime to be passed onto the threads.
        /// </summary>
        static GameTime gameTime;
        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="game">Calling game class</param>
        public ThreadManager(Game game) : base(game)
        { }

        /// <summary>
        /// Overiden Update call, loads manager gameTime varaible.
        /// </summary>
        /// <param name="gameTime"></param>
        public override void Update(GameTime gameTime)
        {
            ThreadManager.gameTime = gameTime;

            for (int t = 0; t < threadedCodeList.Count; t++)
                threadedCodeList[t].Update(gameTime);

            base.Update(gameTime);
        }

        /// <summary>
        /// Method to add a thread to the maanger.
        /// </summary>
        /// <param name="threadCode">Code to be executed in the thread.</param>
        /// <param name="threadInterval">Time period between each call in miliseconds</param>
        /// <returns>Index of thread, first one added will be 0 next 1 etc..</returns>
#if XBOX
        public int AddThread(ThreadCode threadCode, int threadInterval,int affinityIndex)
#else
        public int AddThread(ThreadCode threadCode, int threadInterval)
#endif
        {
            int retVal = threads.Count;

#if XBOX
            ThreadCodeObj thisThread = new ThreadCodeObj(threadCode, threadInterval,affinityIndex);
#else
            ThreadCodeObj thisThread = new ThreadCodeObj(threadCode, threadInterval);
#endif

            threadedCodeList.Add(threadedCodeList.Count, thisThread);
            threadStarters.Add(threadStarters.Count, new ThreadStart(thisThread.Worker));
            threads.Add(threads.Count, new Thread(threadStarters[threads.Count]));

            threads[threads.Count - 1].Start();

            return retVal;
        }

        /// <summary>
        /// Method to kill a single thread.
        /// </summary>
        /// <param name="index"></param>
        public void KillThread(int index)
        {
            threadedCodeList[index].KillThread(threads[index]);
        }

        /// <summary>
        /// Method to start a thread
        /// </summary>
        /// <param name="threadCode"></param>
        /// <param name="threadInterval"></param>
        /// <param name="index"></param>
        public void StartThread(ThreadCode threadCode, int threadInterval, int index)
        {
            if (threadedCodeList[index].stopThread)
            {
                threads[index] = new Thread(threadStarters[index]);
                threadedCodeList[index].stopThread = false;
                threads[index].Start();
            }
        }

        /// <summary>
        /// Method to tidy up unfinished threads.
        /// </summary>
        /// <param name="disposing"></param>
        protected override void Dispose(bool disposing)
        {
            for (int t = 0; t < threads.Count; t++)
                KillThread(t);

            base.Dispose(disposing);
        }
    }

The real change has been in the ThreadCodeObj, this now holds most of your threading information.

/// <summary>
    /// This is the delegate to be used for passing the code to be called in the tread.
    /// </summary>
    /// <param name="gameTime">GameTime</param>
    public delegate void ThreadCode(GameTime gameTime);

    /// <summary>
    /// This class holds the required data for the code to be called in the thread.
    /// </summary>
    internal class ThreadCodeObj
    {
        public ThreadCode CodeToCall = null;

        /// <summary>
        /// Mutex to stop thread clashes.
        /// </summary>
        private static Mutex mutex = new Mutex();
        /// <summary>
        /// Used to make the thread wait.
        /// </summary>
        private ManualResetEvent threadStopEvent = new ManualResetEvent(false);
        /// <summary>
        /// Bool to control imediate stopping of thread loop.
        /// </summary>        
        public bool stopThread = false;
        /// <summary>
        /// Interval thread will wait befoer next cycle.
        /// </summary>        
        private int threadIntervals = 1;

#if XBOX 
        int processorAffinity;
#endif

        public GameTime gameTime;

#if XBOX
        public ThreadCodeObj(ThreadCode code,int interval,int affinity)
        {
            CodeToCall = code;
            threadIntervals = interval;
            processorAffinity = affinity;
        }
#else
        public ThreadCodeObj(ThreadCode code, int interval)
        {
            CodeToCall = code;
            threadIntervals = interval;
        }
#endif
        public void Update(GameTime gameTime)
        {
            this.gameTime = gameTime;
        }
        public void Worker()
        {
#if XBOX
            Thread.CurrentThread.SetProcessorAffinity(new int[] { processorAffinity });
#endif
            do
            {
                try
                {
                    mutex.WaitOne();

                    if (gameTime != null)
                        CodeToCall(gameTime);

                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
            while (!threadStopEvent.WaitOne(threadIntervals, false) && !stopThread);
        }
        public void KillThread(Thread thread)
        {
            if (!stopThread)
            {
                mutex.WaitOne();
                stopThread = true;
                thread.Join(0);
                mutex.ReleaseMutex();
            }
        }
    }

At the top of the source file I have also included an affinity map so you know what processors you have access to, or should be using. XNA does not stop you from using a CPU/Core but you don't want to be running your threads on CPU cores that are already busy, it's why you are threading in the first place, because you have to.

#if XBOX
    ///
    /// Processor affinity map.
    /// Index CPU CORE Comment
    /// -----------------------------------------------------------------------
    ///   0    1    1  Please avoid using. (used by 360)
    ///   1    1    2  Game runs here by default, so avoid this one too.
    ///   2    2    1  Please avoid using. (used by 360)
    ///   3    2    2  Part of Guide and Dashboard live here so usable in game.
    ///   4    3    1  Live market place downloads use this so usable in game.
    ///   5    3    2  Part of Guide and Dashboard live here so usable in game.
    /// -----------------------------------------------------------------------  
    ///
#endif

The sample solution is the same as the last one, but just uses this method now and you can download this here.

A visible collection of particles of water or ice suspended in the air, usually at an elevation above the earth's surface in XNA

Nemo Krad — Fri, 08 Aug 2008 11:30:00 GMT

Well if I had just put, "Another Cloud Clip!" you would not have looked at this post. Anyway, her is some more of the same, but not quite the same, well, almost the same. In this clip I show multiple cloud layers each with differing tones of gray (I think it gives the cloud fields depth), also a splattering of around 100 clouds and then the cloud fields again but with some basic formation and dissipation effects in there.

[Go to the site to view embedded media]

Now as ever it looks a little laggy, I can't help this, but what I intend to do next time is to try and dig out my camera and film the cloud system off my TV to show how quick it is in my XBox 360, I would have done that this time around but it is dead... No RROD, it powered up, I get the normal green lights, one for power the other for my controller but I get no sound or video, which kind of detracts from game play a bit...

So next time, I hope to have a 360 clip up, quality will suck as it will be taken on my hand held camera, but with any luck you will see it run without lag.

Gamefest 2008

Nemo Krad — Fri, 08 Aug 2008 10:32:05 GMT

Well managed to go! It was great, well the bits I saw as I didn't get there till around 11:00, but got to see most of Frank Savages talk on Threading in XNA which was interesting and threw up a few tips, also the talk on Live networking by Mitch Walker was very insightful.

Now one talk that I did find changed my out look on an area of XNA was Frank Savages talk on the Content Pipeline. Now I knew you could do a fair bit with it, have played a little with it my self, but WOW! There is SO much in there to play with. An example he gave was when creating your levels in your modelling tool, use spheres for markers in the level for things like spawn points, event triggers etc.. label these spheres so you know what they are pertaining to, then you can write your own content override to get this data out of the model, use the centre of the sphere to mark the point, store it in an array of points and then store it in the tag of the Model (remember to remove this excess data prior to passing it on to the base class) It was so obvious yet I had not even thought about it, so much other stuff we could do in there too, I have been using it to store bounding box data as well as vertex data (not needed since 2.0 I don't think), but this could also include collision normals, further bounding data, breaking the model up into a number of spheres for greater collision accuracy, and that's just models, anything else that falls under the content project can be manipulated, this is still all pretty basic stuff, but I am sure you can imagine how much control we now have over our content.

Well after all that exciting stuff, we had a break for lunch, I then went to the Community Games on XBox Live talk (after debating with myself if I should stay for the XBLA talk) and it was quite informative, nothing there I didn't really know or heard about already, other than the, "If your games kills anyone who plays it, it's your fault!" bit, well they didn't put it quite like that, but you are liable for your game I guess, being the publisher and the developer all in one... As you can imagine a lot of people in the room seemed to be industry folk and so there questions were more around the realms of IPR infringement and how they will now stop there developers moon lighting to make money with XNA. Oh and someone asked about people writing XBox time bomb's, malicious code that would get through the peer review as it only goes off at Christmas or Halloween, what I find odd about that is the limited access you have to both the network and the hardware on the 360, guess you could fill a hard drive or maybe flash up naughty pictures for a day, but I guess that's going to get you and your 360's mac address banned for life....but then I guess there are some odd folk out there...you know who I mean....yes you there...no, not you, you...

So then came the party after....I say party, but was just a gathering of the attendees for free booze and food, oh a blast on Geometry Wars and other titles around the room to, no Schitzoid which I found odd, would have thought they would have had a copy of that running at an XNA conference. Met some guys from Beatnick Games Ltd (Hi Robin) who are a start up writing a game in XNA, think they want us to play test the beta, so guess we are waiting for them to give us access now so we can rip it apart...

Shame I missed the keynote and the What's new in XNA 3.0 talk, would have been good to catch those.

All in all good stuff, I think I may now have an addiction to games dev conferences....ah, my personality flaws shining out again, first XNA now this....

Thanks to Leaf and Robin for sorting stuff out and making sure I did not get lost on the tube ride back to St Pancs...

Anyone getting sick of clouds yet?

Nemo Krad — Fri, 18 Jul 2008 14:45:00 GMT

[Go to the site to view embedded media]

So, here is the system (still not finished) with the skysphere and my infantile physics system. Again footage taken on my poop laptop so bit slow, but on my 360 it's a steady 60FPS.

I think the flying ship gives a better perspective than the terrain, also I have altered the cloud shader to take into account the time of day, you will see at night fall the clouds are no longer bright white.

As ever comment and ratings welcome.

Speech in you Windows XNA Games

Nemo Krad — Thu, 17 Jul 2008 13:44:53 GMT

I found this while messing about with the media player in XNA, just noticed there is some legacy code in the download from it :( Anyway, how to get speech into your games, it's dead easy really, you just need to have .NET Framework 3.0 and you have all you need.

NOTE: You don't need XNA 3.0 for this just the .NET 3.0 Framework on your system.

First off you need to add the System.Speech assembly to your project references, then in your Game1.cs add the following:

using System.Speech.Synthesis;

and in your Game1 class add:

SpeechSynthesizer synth = new SpeechSynthesizer();

Now, all you have to do is call the synth.SpeackAsync() method passing the text you want to have spoken. I used this:

synth.SpeakAsync("Hello, Welcome to the Random Chaos Generic X N A Speech Sample." +
                                " This sample is hosted by; the X N A U K User Group. Thanks " +
                                "to Leaf and Robin for letting me host my blog here and I hope " +
                                "you find my samples useful.");

This will use the default voice that is set up on your PC (see Control Panel->Speech). But you can also access the other two voice types that ship with the OS (XP, not sure about Vista). To do this try any one of these:

synth.SelectVoice("LH Michael");
synth.SelectVoice("LH Michelle");
synth.SelectVoice("Microsoft Sam");

I prefer "LH Michael", reminds me of Stephen Hawking and I think it's a little clearer than the other two.

I know, not the best chat in the world, but it's free lol

Yes, more clouds...

Nemo Krad — Thu, 03 Jul 2008 21:59:00 GMT

[Go to the site to view embedded media]

Yes, been playing some more with the clouds. I have had the last clip playing on the 360 and it not drop below 60 fps, on my laptop I get about 7fps, and yes, my laptop sux!!

So I have now put it with my dynamic sky sphere, and I think it looks pretty good. In the clip I am showing a few large clouds in a huge bounding volume against the sky sphere, then a large cloud field against the sky sphere showing the transfer from day to night and back again. I have not implemented lighting on the clouds but I think it still looks nice, the final bit of the clip is both bits together with an added mushroom cloud in the middle.

Still much to do and as ever, very little time, but I am getting there I think, all though slowly :)

3D Clouds in XNA - Another Update

Nemo Krad — Thu, 12 Jun 2008 22:41:00 GMT

[Go to the site to view embedded media]

Well I have kind of been letting this code sit for a while, not looked at it as of late, then this week decided to have another play with it, kind of hoping I can put it to bed.

So I have not started to use Ninians sprite sheet, the sheet is full of alphas, so instead of getting them off the sheet and then just sending them to the screen, set the base colour of the sprite then multiply its alpha by the RGB returned from the sprite sheet. This I think gives a more natural cloud look. I still have some performance issues, but have managed to speed up the draw order sort and that has helped a little. I have also put in some terrain so you have a point of reference, was a bit odd just looking at clouds hanging there in the sky..

I still have tones I want to do with this yet. I think the next thing will be imposters, then an editor so you can create a cloud field or set of clouds and be able to save them to disk and re use them as an when you like. Naturally more optimizations and some lighting in the shader.

Hop you like the clip, ratings, and comments are welcome as ever.

Generic XNA - Threading for Windows

Nemo Krad — Sun, 01 Jun 2008 18:23:00 GMT

Well I have done some basic threading in my job, basic stuff and thought I would try and put the basic threading I have done into an XNA Game Component. I am not saying this is how you should do your threading, my method is certainly not the only way to thread processes either and more than likely not the best. I think though that if you are new to development and you want to thread part of your game then I think this may be of some use to you.

What is a thread?

OK, there are a few links out there that describe what a thread is better than I could, so here are a few links for reference:-

Research Microsoft Andrew D. Birrel (not read this yet, looks v good though)

MSDN (Again, I should read this too...)

ThreadManager

This is a simple manager, you can pass methods to it that you want to have processed in a thread of there own. You can have as many threads as you like, BUT, it's probably best to keep your threads down to as few as possible, don't go threading processes because you can.

So, on to the code. The ThreadManager class is derived from (as most my samples) from GameComponent. The threading method I use requires four components, ParameterizedThreadStart if you don't need to pass parameters to your thread start method then you can use ThreadStart; these are how we bind our method to a Thread, Thread this is the actual thread class used to start and stop the thread, ManualResetEvent this class is used to manage the call interval for the thread and the Mutex class which is used to ensure there are no thread clashes. I wanted to be able to add as many threads as I wanted in my ThreadManager so I have put these class instances into Dictionaries. Also in this implementation I wanted to be able to manage how often the thread code was ran and also to be able to kill a thread at will. To do this I added two other dictionaries to hold what threads I want to stop and one for the interval between thread calls.

/// <summary>
/// This is the Thread manager.
/// </summary>
public class ThreadManager : GameComponent
{
    /// <summary>
    /// List of ParameterizedThreadStart used to start the treads.
    /// </summary>
    private Dictionary<int, ParameterizedThreadStart> threadStarters = new Dictionary<int, ParameterizedThreadStart>();
    /// <summary>
    /// List of runnign threads.
    /// </summary>
    private Dictionary<int,Thread> threads = new Dictionary<int,Thread>();
    /// <summary>
    /// Used to make the thread wait.
    /// </summary>
    public static Dictionary<int, ManualResetEvent> threadStopEvent = new Dictionary<int, ManualResetEvent>();
    /// <summary>
    /// Mutex's to stop thread clashes.
    /// </summary>
    public static Dictionary<int, Mutex> mutexs = new Dictionary<int, Mutex>();
    /// <summary>
    /// List of bools to control imediate stopping of thread loops.
    /// </summary>
    public static Dictionary<int, bool> stopThreads = new Dictionary<int, bool>();
    /// <summary>
    /// List of intervals threads will wait befoer next cycle.
    /// </summary>
    public static Dictionary<int, int> threadIntervals = new Dictionary<int, int>();
    /// <summary>
    /// Managers GameTime to be passed onto the threads.
    /// </summary>
    static GameTime gameTime;

    /// <summary>
    /// ctor
    /// </summary>
    /// <param name="game">Calling game class</param>
    public ThreadManager(Game game) : base(game)
    { }

    /// <summary>
    /// Overiden Update call, loads manager gameTime varaible.
    /// </summary>
    /// <param name="gameTime"></param>
    public override void Update(GameTime gameTime)
    {
        ThreadManager.gameTime = gameTime;

        base.Update(gameTime);
    }

    /// <summary>
    /// Method to add a thread to the maanger.
    /// </summary>
    /// <param name="threadCode">Code to be executed in the thread.</param>
    /// <param name="threadInterval">Time period between each call in miliseconds</param>
    /// <returns>Index of thread, first one added will be 0 next 1 etc..</returns>
    public int AddThread(ThreadCode threadCode, int threadInterval)
    {
        int retVal = threads.Count;

        threadStarters.Add(threadStarters.Count, new ParameterizedThreadStart(ThreadWorker));
        threads.Add(threads.Count, new Thread(threadStarters[threads.Count]));
        threadStopEvent.Add(threadStopEvent.Count, new ManualResetEvent(false));
        mutexs.Add(mutexs.Count, new Mutex());
        threadIntervals.Add(threadIntervals.Count, threadInterval);
        stopThreads.Add(stopThreads.Count, false);

        threads[threads.Count-1].Start(new ThreadCodeObj(threadCode,threads.Count-1));

        return retVal;
    }

    /// <summary>
    /// Method to kill a single thread.
    /// </summary>
    /// <param name="index"></param>
    public void KillThread(int index)
    {
        mutexs[index].WaitOne();
        stopThreads[index] = true;
        threads[index].Join(0);
        mutexs[index].ReleaseMutex();
    }
    
    /// <summary>
    /// Method to start a thread
    /// </summary>
    /// <param name="threadCode"></param>
    /// <param name="threadInterval"></param>
    /// <param name="index"></param>
    public void StartThread(ThreadCode threadCode,int threadInterval,int index)
    {
        if (threads[index].ThreadState == ThreadState.Stopped)
        {
            threads[index] = new Thread(threadStarters[index]);
            threadIntervals[index] =  threadInterval;
            stopThreads[index] = false;
            threads[index].Start(new ThreadCodeObj(threadCode, index));
        }
    }

    /// <summary>
    /// This is the method that is called per thread.
    /// </summary>
    /// <param name="ThreadCodeObject">Instance of ThreadCodeObj to execute.</param>
    private static void ThreadWorker(object ThreadCodeObject)
    {
        int index = ((ThreadCodeObj)ThreadCodeObject).threadIndex;

        do
        {
            try
            {
                mutexs[index].WaitOne();
                if (gameTime != null)
                    ((ThreadCodeObj)ThreadCodeObject).CodeToCall(gameTime);

            }
            finally
            {
                mutexs[index].ReleaseMutex();
            }
        }
        while (!threadStopEvent[index].WaitOne(threadIntervals[index], false) && !stopThreads[index]);
    }

    /// <summary>
    /// Method to tidy up unfinished threads.
    /// </summary>
    /// <param name="disposing"></param>
    protected override void Dispose(bool disposing)
    {
        for (int t = 0; t < threads.Count; t++)
            KillThread(t);

        base.Dispose(disposing);
    }
}

As you can see in the code snippet above, there are 4 methods that are not native to the GameComponent, AddThread, KillThread, StartThread, ThreadWorker.

AddThread

Well, guess what this method does...yep, adds a thread to the manager. So each thread needs one of the base thread elements to, I also set the interval and if the thread is stopped. I set the flag to say this thread has been stopped, then call the threads Join method, this stops (blocks) this thread from running until the thread terminates, this won't happen until the threads loop in ThreadWorker exits and is why I set the stop flag for the thread so that it will terminate. You will see in this call I use another class ThreadCodeObj.

ThreadCodeObj

/// <summary>
/// This is the delegate to be used for passing the code to be called in the tread.
/// </summary>
/// <param name="gameTime">GameTime</param>
public delegate void ThreadCode(GameTime gameTime);

/// <summary>
/// This class holds the required data for the code to be called in the thread.
/// </summary>
internal class ThreadCodeObj
{
    public ThreadCode CodeToCall = null;
    public int threadIndex = -1;

    public ThreadCodeObj(ThreadCode code, int index)
    {
        CodeToCall = code;
        threadIndex = index;
    }
}

This class stores the code to be called in the thread and the index of the thread it is to be used in.

KIllThread

Yep, you got it, kills a running thread. First off the treads mutex calls it's WaitOne method, this method holds this thread up until it's free to do it's work.

StartThread

Restarts a killed thread. First check if this thread has been stopped, if it has then re initialise the threads elements.

ThreadWorker

Well this I guess is where it all happens, first we get the index of the thread we are in, then we kick off the threads loop, get the mutex for this thread to tell us when it is safe to call the delegate, then we make sure the gameTime instance is not null and call the delegate. We then get the mutex for this thread to signal that we are done and then check if we need to leave the loop and if not wait for the given interval for this thread index.

Implementation

So as with most of my samples (I like to think) it's simple to add a method to a thread. First of all set up the ThreadManager and add it to the Game.Components list, now simply call the ThreadManager.AddThread method, passing it the method you want to put in the thread via the ThreadCode delegate along with the interval you want for the thread. I guess most of the threads you will create will have a time span of 0 so they are executed immediately.

You will also notice I have not bothered with affinity (the ability to request the processor the thread will run on) in this sample, this is because on a PC, you wont know how many CPU's your application will be running on so it's probably best left up to the OS to sort it out.

My next post on threading will be for the XBox, it will be almost identical with this source but will have affinity included, we know where we stand with the 360, we know what processors, how many cores and which ones we can put threads on.

The sample code shows this working in a very simplistic manor, I simply add three methods to the thread manager that populate a variable that holds the game time each time it is called. You can kill the thread and then re start them with an interval of 0.

Source solution can be found here.

Generic XNA - Movies in your Windows games

Nemo Krad — Wed, 28 May 2008 14:38:00 GMT

Well, I started looking into this after a friend of mine asked if it could be done. I remembered the other week on Ziggyware that someone got a web cam to stream in an XNA app and so thought that the principle should be the same, taking the output, rendering it as a texture then applying it as you required. So started to try and do it myself, well I came a cropper as the examples I came across were for the old MDX and not XNA (I am not bright enough to do a full port), having to use unsafe code to get handles to the Game.Graphics device etc... but then I came across this post on codeplex as well as a few others which gives a class in XNA to do just this using DirectShow. Now all the examples I found seem to have originated from this post on CodeProject, as does the class I am using here.

Now you may be wondering, where is the movie clip for this....well fraps does not seem to play well with the method I am using to do this and so does not generate a nice clip for me to put up, wish it did because I think it's pretty cool.

Anyway, all I have done is got this lovely class's output image on a 3D surface. This means you can have movies playing in your games in a virtual cinema, have adverts playing on an advertising billboard as you race past in your racer game, have a television like in GTA IV (I love the cartoons!)

Clip of the Web Cam in XNA done by MirageProject on YouTube, this gives you an idea of what my implementation looks like, but instead of giving it a device to read from you give it a *.wmv, *.mpg or any other supported format. Also, notice in my image above that the clip on the left is in black and white, this is down to the shader effect applied, not the clip.

[Go to the site to view embedded media]

You can get the solution zip here. (You have to supply your own clips or the zip would have been huge!!)

RandomChaos Physics

Nemo Krad — Tue, 20 May 2008 13:21:00 GMT

[Go to the site to view embedded media]

So I have started work on a simple physics engine. I intend to have it serve both 2D and 3D development. I guess it wont have all the lovely bits and bobs that engines like BulletX have, but what the hell, it's going to help me understand how a Physics Engine works. Not sure about all the others, but this will naturally be exclusively for XNA and so written in C#. As ever I will put the full source up here once I have finished it so you can improve or add to it.

So needless to say, other things may well be held up; Nova Wars and the Volumetric Cloud system being just two of them. As I think I have mentioned before; my goal now with the blog is to take all the samples I have put up and get them into an engine. This will also help me debug the samples as I will know what plays well with others and what does not. So I kind of think a Physics Engine, no matter how basic, will be a great addition.

The clip in this post just shows where I currently am with the Physics Engine which is basic Force Generators. There is so much to do, not to mention adding 2D Physics too...I really have become an XNA junkie....help.....I don't seem to be able to stop..

Generic XNA - Fire 2D & 3D Shaders

Nemo Krad — Mon, 19 May 2008 20:50:00 GMT

[Go to the site to view embedded media]

Well, this should be the final post on these flame shaders. As you have seen in the previous posts I have created 2D and 3D flame shaders based on the flame shader that comes with the NVIDIA SDK. When I initially created the 2D shader I found there was an issue with it when drawn with the 3D effect, turns out the issue was in the FireEmitterBase class, it was fixed by me setting the effect save state in the Begin call. Once that was done it all rendered fine.

The only issue with the 2D flame shader is that you have to make a draw call per flame as an index.offset has to be passed per flame or the flame animations will all look the same.

I have put them all in the same project, just added a new class for the 2D flame, as well as the shader it's self and a floor class.

Solution can be found here.

Generic XNA - Fire 2D

Nemo Krad — Sun, 18 May 2008 21:42:00 GMT

[Go to the site to view embedded media]

Well, just posting my first attempt at getting the flame shader into 2D. It's not perfect, but as it stands at the moment, will give you 2D flames. When played with the 3D flames it does not seem to render well, but on it's own, as you can see it seems to be working. I am going to give it a bit of testing before I put the source out, but think it should be fine for pure 2D implementation, also still need to move the code into it's own solution....

As ever C&C welcome.

Generic XNA - 3D Fire Sample

Nemo Krad — Fri, 09 May 2008 19:42:00 GMT

Hope the music is acceptable this time...

[Go to the site to view embedded media]

Sorry about the quality of the clip, it was a 20MB clip, but I think youtube has crunched it up adn so it has lost some quality....

OK, here is the code sample for the flame shader I have adapted from NVIDIA's Volumetric Flame shader. The emitter class is pretty much the same as the billboard particle samples in my earlier posts, the real work is in the shader. I took the original NVIDIA flame shader and merged it with my billboard shader resulting in the sample you see here.

Now the emitter given in this sample is very basic, but I am sure you will be able either derive from it or use it as a template for your own flame emitter.

I have had a few requests regarding a 2D version of the shader so I am going to look at applying it to a 2D context.

Solution can be located here.

SkyBox Shader Fix

Nemo Krad — Fri, 09 May 2008 19:18:01 GMT

I have found my skybox shader has a bug in it, the shader displays the cubemap as a reflection, the following shader code will give a better result.

So, if you have used my skybox sample then replace the shader with this code:

Texture surfaceTexture;
samplerCUBE TextureSampler = sampler_state 
{ 
    texture = <surfaceTexture> ; 
    magfilter = LINEAR; 
    minfilter = LINEAR; 
    mipfilter = LINEAR; 
    AddressU = Mirror;
    AddressV = Mirror;
};

float4x4 World : World;
float4x4 View : View;
float4x4 Projection : Projection;

float3 EyePosition : CameraPosition;

struct VS_INPUT 
{
    float4 Position    : POSITION0;
    float3 Normal : NORMAL0;    
};

struct VS_OUTPUT 
{
    float4 Position    : POSITION0;
    float3 ViewDirection : TEXCOORD2;
        
};

float4 CubeMapLookup(float3 CubeTexcoord)
{    
    return texCUBE(TextureSampler, CubeTexcoord);
}

VS_OUTPUT Transform(VS_INPUT Input)
{
    float4x4 WorldViewProjection = mul(mul(World, View), Projection);
    float3 ObjectPosition = mul(Input.Position, World);
    
    VS_OUTPUT Output;
    Output.Position    = mul(Input.Position, WorldViewProjection);
    
    
    Output.ViewDirection = ObjectPosition - EyePosition;    
    
    return Output;
}

struct PS_INPUT 
{    
    float3 ViewDirection : TEXCOORD2;
};

float4 BasicShader(PS_INPUT Input) : COLOR0
{    
    float3 ViewDirection = normalize(Input.ViewDirection);    
    ViewDirection.x *= -1;
    return CubeMapLookup(ViewDirection);
}

technique BasicShader 
{
    pass P0
    {
        VertexShader = compile vs_2_0 Transform();
        PixelShader  = compile ps_2_0 BasicShader();
    }
}

Sorry for giving you a crappy shader in the first place :P

Generic XNA - Fire

Nemo Krad — Tue, 06 May 2008 23:10:00 GMT

Yes, I have been playing with fire! I have had this flame shader by NVIDIA (from the SDK) for ages now. I tried to implement in my olf RC3D Engine but it was a poor attempt and was of no real use to anyone, but I think I may have the beginnings of a decent implementation now. I have mixed the NVIDIA shader based on Yury Uralsky's "Volumetric Fire" with my billboard shader and billboard particle system and it seems to be playing quite well.

Take a look at the clip and let me know what you think.

[Go to the site to view embedded media]