First of all - the priority of shadow filtering is to make the shadows appear smooth and soft.
PCF means percentage closer filtering.
The PCF shown compares the depth to the shadow map at the correct position, plus the four surrounding texels in the shadowmap as well, and blurs the results to get the average. This smoothes out the edges a bit.
In the newer release I also fade the edges out in a subtexel manner, where I weight them based on their position in the texel.
In the engine this would be g_ShadowForceFiltering set to 1.
We can have better PCF filtering if we use more samples, g_ShadowForceFiltering 2 and 3 do that with 5x5 and 9x9 samples respectively.
Most shadowing in games uses PCF today I think.
Poisson sampling is very well explained here: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-16-shadow-mapping/
We randomize our sampling locations, but try to make the random sampling points correspond to each other in a way that they aren't biased too much into one direction. A poisson disk does this more or less, it's basically a distribution of points on a disk where the points still adhere to some rules to guarantee good distribution.
VSM is Virtual Shadow Mapping.
One might naively assume that simply blurring the shadow map might generate soft shadows, but that isn't the case because blurring the depth map will only make the depth values incorrect, therefore we can't reliably compare them anymore.
In VSMs however we store not only the depth, but also the square of the depth (in a second channel) and because of their relationship and the algorithm use we can just do what previously wasn't possible - blur the shadowmap.
If you want to know more about the math behind it you have to google Chebyshev Bound.
So in my case I use a simple blur filter (7x horizontal + 7x vertical) to blur the shadowmap and get softer shadows.
This blurring is pretty expensive, but less blur means less softness.
The biggest problem with VSMs is that they are not reliable, sometimes light will leak through the shadows.
The SS Blur mentioned means Screen Space blur. Instead of calculating the pixel when calculating lighting, I calculate only the shadows extra on a different rendertarget and read this rendertarget as a texture when drawing my lighting.
This allows me to sneak in another blur pass, this time in screen space instead of texture space. Of course, simply blurring the rendertarget would give wrong results, since shadows on a fore/background object could "bleed" into the neighborhood pixels which might not be shadowed.
So we have to use a depth aware blur filter (bilateral).
This is just one more step in making the results appear less choppy.
The highlighting in editor mode is achieved by drawing the objects once again (in transparent) and then drawing them again with frontface culling and their vertices pushed out along their normal vectors and textured with a simple color. This way we enlarge the models, but only draw the outlines, because the other pixels are occluded.
Not super trivial, and not super cheap either. Search for outline / toon shaders and you'll find plenty of good material on that.