Comments for Jason Mitchell

Comment on 3D Particle System for XNA by Erez Robinson

Erez Robinson — Mon, 20 Feb 2012 15:14:29 +0000

Your TextureQuad instantiation is very slow.
So you need to create them before you create your particles.

You can put them in a list:
List quads = new List();

foreach (var texture in textures)
{
var quad = new TextureQuad(graphicsDevice, texture, texture.Width, texture.Height);
quads.Add(quad);
}

and then send them to the particle as an actual parameter, like so:
particles[i] = new Particle(particleLifespan, graphicsDevice, quads[random.Next(quads.Count)]);

Nice example though.

Comment on Observable Properties in XNA by Jason

Jason — Sat, 04 Feb 2012 21:49:25 +0000

That sounds pretty neat. I think there is definitely something to gain from using this approach and I definitely agree that there is a bit of a shift in philosophy required.

I use this kind of approach for handling game input and its worked well for me so.

Comment on Observable Properties in XNA by Josh Elster

Josh Elster — Sat, 04 Feb 2012 19:58:31 +0000

I’ve been able to completely decouple the rendering from the objects in my spike app – objects are rendered via events published to a render object’s subscription. The subscription is defined by a LINQ Rx query, which hooks into a render queue which can be grouped and filtered, allowing rendering to be efficiently batched, with reasonably good results (so far). Culling render requests, as an example, could be implemented with a single .Where() clause on the render query. Since LINQ queries are inherently composable, it’s easy to imagine how complex rendering could be accomplished in a straight-forward fashion. I’m able to render > 100 objects (not all moving, but some) with a nice steady frame rate. More importantly at this time though, I wanted to know what the memory and GC usage was, with all these events being created and passed around. Surprisingly (and I was a bit shocked), it was very constant, with no leaks and minimal GC activity (no objects collected in G0, so GC no-ops). The big no-no I’ve run into so far that could be concerning is that I’ve had to clear each domain object’s local event cache after every call to Update(), otherwise the framerate will plummet over a few seconds as events (messages) pile up and queries get more expensive.

The Rx approach seems to have a crap-ton of promise, but it is a bit difficult to wrap your head around, and requires a shift in design philosophy, as well as creating some problems of its own. For pure XNA development, some wrapping/support logic is needed to synchronize object events and reactive queries with the game loop.

For Silverlight+XNA or pure SL scenarios though, it can be much more simple to use, since games in those frameworks are already asynchronous and event-driven by nature.

Comment on Observable Properties in XNA by Jason

Jason — Fri, 03 Feb 2012 21:55:47 +0000

This sort of model is something I’m really interested in and am currently using in a basic form in a personal game engine project myself. I think it is definitely a feasible approach as long as you take into consideration the frequency which your observables will be notifying their observers.

My implementation isn’t using the Reactive Extensions (something I know very little about) but rather my own lightweight implementation which is a little different to what I described here due to a change in my needs. It seems to have scaled reasonably well in some demo projects I had made which had 2209 pairs of models (4418 updating objects altogether). One model in each pair subscribed to changes in the orientation and position of the other and it ran pretty well. The FPS dropped to around 30 however by looking at the profiler it seemed like this could be improved with a better rendering algorithm which is unrelated to the test I was performing.

Comment on Observable Properties in XNA by Josh Elster

Josh Elster — Fri, 03 Feb 2012 20:12:47 +0000

I’ve been playing around with a proof-of-concept game based around an event-driven, reactive model. Using the Reactive Extensions, it’s looking quite simple (once the learning curve is breached) to create a loosely-coupled engine. I’m planning a post to present the design, and I’d be interested to hear your take on the feasibility of the design.

Comment on Setting Alpha Value for SpriteBatch.Draw in XNA 4 by saboor

saboor — Mon, 23 Jan 2012 05:33:41 +0000

useful description

Comment on Data Access Using a Generic Repository in C# by Jason

Jason — Mon, 02 Jan 2012 12:18:54 +0000

Yeah it’s pretty quiet around here. I really appreciate your feedback!

Particles engines are something I really enjoy working with although I haven’t done much with them recently.

Comment on Data Access Using a Generic Repository in C# by James Hinson

James Hinson — Mon, 02 Jan 2012 12:05:55 +0000

I stumbled accross your blog today looking at different peoples ideas on particle engines. I am a self educated software and programing tech which means I have many limitations. I can see you don’t get many comments. Just wanted to say I enjoyed reading your posts.

Comment on Kinect SDK Extension Methods by Jason

Jason — Mon, 21 Nov 2011 20:34:05 +0000

Totally forgot about that! It’s updated now – I haven’t tested it but it **should** work. You should maybe also take a look at http://jason-mitchell.com/programming/xna-texture2d-creation-byte-vs-color/

Comment on Using the Bing Maps Silverlight Control by Akhila

Akhila — Mon, 21 Nov 2011 13:25:44 +0000

@Kike,

e.Result.Results[0].Address.Locality works perfect for city name..

Thanks Jason.. very nice article.