Each time when not taking attention, the 3D-rendering world has been drastically changed, so I wondered what the current / common way of shadowmapping is.

VSM, ESM, EVSM (all derivatives of SM) are being used in current titles I believe.

Some engines like Unity™ (saw in one forum one day) still prefer constantly varying from methods such VSM to PCF with a bunch of blur filters or HW accelerated filters (but I don't know why).

The future of rendering looks like it is path tracing (see here), and until there it will be a lot of possibilities regarding to shadow casting.

It's semi-on topic, so I'm gonna ask the question here: A couple months ago the I saw one or two fresh blog posts about someone who experimented with ray traced shadows on a fairly complex scene (couple million polys). I can't find the blog post anymore. The scene in question was some kind of small village/city surrounded by castle walls. Does anyone know what I'm talking about and could link me to it?

No one likes VSM anymore, shadow leaking sucks and evsm is very expensive to fix it. PCF has gotten better with more taps, as well as doing a smart sampling pattern ala Advance Warfare. http://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare

Regardless, there are a lot of optimizations for depth targets. Here is a good resource: http://www.cse.chalmers.se/~uffe/publications.htm

"Efficient Virtual Shadow Maps for Many Lights." is a great paper if you think you can afford the overhead, and apparently there will be a new, improved version of such later on this year. Caching shadow maps is also a common idea http://diaryofagraphicsprogrammer.blogspot.com/2008/12/cached-shadow-maps.html You just store the shadow maps from previous frames and re-use them unless something is actually moving within the light's radius.

If you've got a static directional light then scrolling cascaded shadow maps is really good idea: https://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2012/08/CSM-Scrolling.pdf it's very similar to caching shadow maps, you just use it for a directional light instead.

This is also useful: https://mediatech.aalto.fi/~ari/Publications/Shadow_Caster_Culling_for_Efficient_Shadow_Mapping.pdf a way to cull things from a directional shadow map if it won't cast shadows to anything on screen.

Sample distribution shadow maps can be used for much higher quality (ideally no aliasing) directional shadow maps: http://visual-computing.intel-research.net/art/publications/sdsm/sdsmLauritzen_I3D2011.pdf the excellent MJP has a sample out with a simplified (lower overhead) implementation that, I believe, is pretty much what is used in the stunning looking The Order 1886, so you can in fact run it in realtime on an actual game.

This: http://www.crytek.com/download/Playing%20with%20Real-Time%20Shadows.pdf offers a good overview of what Crytek did for Crysis 3...

And I guess that's more than enough information to get you going. Epic is experimenting with raytraced shadows accelerated by all their static (non skinned) meshes having generated signed distance fields, but it quickly gets slower than shadow mapping if your scene gets too complex.

Here are my two cents:

I'm using Camera Space Shadow Mapping (CSSM) algorithm, but now with DEPTH HISTOGRAMS to get optimal plane placements (every few frames).

Before I had to specify focus range (like 15-25m) but now that is handled by depth histograms.

In past (as Hodgman mentioned) there was annoying edge flickering (because it was perspective warping approach), but now, with new optimizations this problem is gone.

There were also problems with scenes like "airplane and the ground" where a lot of shadow map space was wasted on empty space between airplane and the ground (if you are in the airplane looking down and there is some shadow on the wing but most of it is on the ground far away). Not anymore.

IN SHORT:

· It is fastest (considering the quality);

· It is most precise;

· It uses smallest shadow map of all the other algorithm and achieves the greatest quality;

· Works for every imaginable case (big or small lights - including omni);

· It's a "one line of code" implementation (not really, but one line of code actually calculates everything, the rest is just passing parameters to the shaders and rendering scene);

· No one knows about it (I suck in PR and every few years I write shameless advertizing post like this one ).

I should probably write a follow-up paper explaining depth histograms and how they are used to squeeze every little bit of performance and quality from shadow mapping but who has the time these days (plus, convincing reviewer that you've actually created something new is extremely tiresome - they are not game developers - they don't get it - well, some of them do).

OK.

Basically, difference between regular CSSM and CSSM with Depth Histograms is that every few frames, a depth histogram of the scene is obtained (after few frames of delay).

Now, If you look at the depth histogram, where ever you see a bump that means that there is some geometry on that distance that could have shadow. This helps you with the problem of "space between airplane and the ground" - we could simply ignore that empty space.

Then you integrate depth histogram by view angle which gives you a curved line starting from the bottom of view fostrum to the top of the view frostum (first read the CSSM paper to understand this).

Then you simplify that line to 4-8 segmments that will represent new projection planes of the standard CSSM. This time you don't have to specify focus distance. Now it works even with infinitely large scenes that don't have far clipping plane and quality is always maxed because shadow map texels are only used where they are needed (and distributed optimaly).

You can't get more quality than that - it's an ideal solution for any kind of scene and it works great even with tiny shadow maps.

So, not only that shadow mapping is focused only on visible space (no 50% wastage like with other algorithms - old CSSM introduced that) but now it is focused only on parts of the scene that can have shadow.

Original CSSM paper: https://bib.irb.hr/datoteka/570987.12_CSSM.pdf

Web page with old CSSM demo application: http://free-zg.t-com.hr/cssm/

Let me know if you want me to sketch this out in Paint

Edit: I've changed "plane" to "airplane" in the "airplane vs ground" example so the people don't get too confused since the term (projection) planes is used a lot.