I was thinking about a really simple and limited depth of field effect - it doesn’t even need to be that good - think of windwaker on the gamecube. They must have had some method or other to achieve it in a very fast manner on such limited hardware.
Do you know how they did it? The way I see it is there’s a couple of ideas to follow:
doing multiple camera renders sliced by distance - probably looks a bit fugly where the joins are and of course there is the transformation costs to deal with.
a simple shader which is the entire scene rendered quarter of the size, blurry (post fx) - but then drawn back over the main scene with more transparency for anything closer up… this in theory would sort of give a decent DOF?
Accuracy isn’t important but speed is. I was wondering what ideas you guys had before embarking further on this concept. The game I am working on would really benefit visually by this as it would make the foreground pop, and reduce visual confusion.
I don’t know a whole lot about shaders but this is an interesting problem. I think I would go with option 2, but rather than rendering at a quarter size I would make the blurred version by apply a blur filter to the original render. If you use a small texture and up scale it, that would be the opposite of AA, so it would adding aliasing.
So i guess the steps are, render main camera normally, make a copy of that which is blurred, then generate a depth map and then use that as a alpha channel for the crisp version rendered on top of the blurred version.
I got no idea how to make that happen but the theory sounds solid
I’m guessing image effect blur would be incredibly performance hungry on mobile though. Another option would be some sort of vertex shader that pushes verts outwards more towards the distance… This would be your fast COC. But it’s only theory.
The downscaling works by replacing groups of 2x2 pixels by one pixel in the lower resolution with the averaged color of the 4 finer pixels in the higher resolution. (If you take the average of 4x4 pixels instead of 2x2 pixels the quality can be improved a lot.)
Averaging 2x2 pixels is a single(!) texture read at the position in between the 2x2 pixels; thus, this is very efficient. Moreover, the resulting downscaled image is only a quarter of the size, thus, the image filter has to process only 1/4 of the number of pixels of the original image.
You can continue downscaling to even coarser levels. (In the end you would create all the levels of a mipmap and in fact this is an operation that is integrated very efficiently in many OpenGL drivers as automatic mipmap generation.)
The simplest interpolation of pixels from any of the coarse image levels is just a single texture lookup (with bilinear interpolation); thus, this is also extremely efficient.
The full algorithm is described in GPU Gems, Section 23.6 Reverse-Mapped Z-Buffer Depth of Field: http://http.developer.nvidia.com/GPUGems/gpugems_ch23.html ; by the way, NVIDIA also holds a patent on this technique but I haven’t heard that they ask anyone to license the technique.
Hi hippo,
I tried using Trilinear sampling with hardware mipmaps when we did our DOF. It worked on PC with no result on IOS. Its a pity because it looked great on the PC. I think it gave a better look than my final manual sampling. For those that are interested I’m covering how we did it here.
