April Sample Online!

Go ahead and use it Nick. If you find any performance improvement tricks (shouldn’t be too hard, since I focused on getting it done first; didn’t care much about perf)

Cdxrd: Glad you liked it. There aren’t really too many complex things in there. Reading the original article on Gamedev is a must, because it explains the theory behind these shadows very well (even though it has some OpenGl/C++ code in it). The calls to spritebatch are just overrides of the normal ones, with some added parameters.

Some points of confusion might come from the several ways in which I use alpha blending. CornflowerBlue has a series of 3 articles that explain the alpha blending stuff. http://blogs.msdn.com/etayrien/archive/2006/12/19/alpha-blending-part-3.aspx

A full blown tutorial is not likely right now, since the exam session is approaching But if I get enough requests, I’ll try to fit it in my schedule.

It’s not drawing them that’s slow, it generating them
A few ways to improve performance would be:

* precompute shadows for static lights and objects

* only compute/render shadows from lights that might be visible on the screen (for big scrolling levels) Note that some ofscreen objects/light will need to be included in the algorithm to make it work well

* for each light, only cast shadows from objects which are in the light’s range

* any optimization that you would do in a physics engine, to avoid testing for collision between two objects, you can do in the shadows sample, to avoid computing shadows for some light/object pairs

There are probably a few other ways to increase performance, but the purpose of the article was to describe the technique

Soul, you are the second person asking for a tutorial

If I had more time, I would be glad to do it. Maybe after my exams are all done and passed, I’ll try to put together a tutorial explaining everything, but I can’t promise anything.

I looked over the flatredball engine for a while, but not too much. So I’m afraid I can’t help you with integration.

I’ll look into it later today and tomorrow, and I’ll let you know.

Yes, I’m aware of Manders’ technique. I though hard about doing all those computations on the GPU myself, but there is a big difference between our samples.
He only has lines for which to draw shadows, while I have polygons with arbitrary number of edges. For a line, no matter of the light’s position relative to it, the shadow always has the same shape. This is not so for a polygon, and depends both on the shape of the polygon and on the position of the light.

One way to do this would be to draw the shadow volumes for each edge of the polygon, in the same way as Manders draws shadows for his lines, but depending on the level of detail of that polygon, this could result in a great number of Draw calls (order of tens), as opposed to a single Draw call for the whole object’s shadow, as it happens now. These add up, and may actually hurt performance more than benefit it.

This is one area where DirectX10 geometry shaders would come in handy, as they could be used to generate the shadow’s geometry on the GPU, for any convex shape imaginable. But since XNA is DX9 only, for now I’ll have to stick to doing all this on the CPU.

One other idea would be to move these computations on another thread, and use multi-threading, but this is dangerous territory as well.

Yes. That’s the best idea I could also come up with I just forgot about it until you reminded me.

I decided not to use it in the sample, because I though the extra tinkering needed to remove the artifacts might confuse some people.

But mainly, that’s the way I would go about it, if I were to modify the sample.

To be honest, I’m not really sure. Drawing the object on top of the shadow is not such a good idea, because it may cause shadowed objects to actually be drawn (like object lying in the shadow of other objects, and so on)

What would probably be best on the long run is the idea to also assign a “height” when first processing the shadows, and when drawing the objects, only apply shadows on objects lower than this height. And an object is set to be a little higher than its own shadow. This would probably lead to the best result, where small objects don’t case shadows on objects larger than them. But it would also mean rewriting the way shadows are combined with the scene, adding a bit more shader complexity.