Encelo’s Blog

Lately I’ve been really disappointed by the poor performances of my first depth of field implementation, thus I decided to do something about it…

The most natural step to do was to give a look to the second Direct3D example from the same paper I used for the first one, as I was sure it would have led to more satisfactory results.
I spent the two last nights converting, correcting and fine tuning it, but I was rewarded by the fact that I was right: even if it is a five passes algorithm which is using four different Frame Buffer Objects, it is about 2.5 times faster than my previous implementation!

I think the speed boost depends on the two following:

1. image blurring is achieved by a gaussian filter which is calculated separating the X from the Y axis, it is an approximation of a standard 2D kernel but it also means that the convolution matrix calculation complexity decreases from a quadratic to a linear factor.
2. this filter operates only on a downsampled (1/4th of the screen resolution actually) FBO

Another nice note about this new implementation is that there are only two focal parameters, focus depth and focus range, which really help to setup a correct scene.

Now let’s review the five passes in detail:

1. Render the scene normally while calculating a blur amount per-vertex, then store the interpolated value per-pixel inside the alpha component of the fragment.
   The calculation at the vertex shader is just:

   
   Blur = clamp(abs(-PosWV.z - focalDistance) / focalRange, 0.0, 1.0);
   

2. Downsample the scene rendered at the previous pass storing it in a smaller FBO
3. Apply the gaussian filter along the X axis on the downsampled scene and store it in a new FBO
4. Apply the gaussian filter along the Y axis on the already X blurred scene and store it in a new FBO
5. Calculate a linear interpolation between the first full resolution FBO and the XY downsampled blurred one
   This is performed in the fragment shader as:

   
   gl_FragColor = Fullres + Fullres.a * (Blurred - Fullres);
   

Again, you can view it in action on my YouTube Channel, or in a high definition 720p version hosted on my Vimeo page.

I’m back to work after many months, university exams take really a lot of time…
For I am a bit rusty on GLSL programming, but willing to learn new things anyway, I have decided to begin with a simple yet interesting topic, image processing.

The whole thing, actually, needs two rendering passes and relies heavily on Frame Buffer Objects because:

1. You render the scene to an off-screen texture.
2. You render a quad covering the entire screen and binded to the previously written texture.
3. You make a shader process the fragments resulted from rendering this textured quad, i.e. post-processing the original scene.

In this program post-processing is demanded to convolution matrices calculated with these kernels:

GLfloat kernels[7][9] = {
    { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f}, /* Identity */
    { 0.0f,-1.0f, 0.0f,-1.0f, 5.0f,-1.0f, 0.0f,-1.0f, 0.0f}, /* Sharpen */
    { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}, /* Blur */
    { 1.0f, 2.0f, 1.0f, 2.0f, 4.0f, 2.0f, 1.0f, 2.0f, 1.0f}, /* Gaussian blur */
    { 0.0f, 0.0f, 0.0f,-1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f}, /* Edge enhance */
    { 1.0f, 1.0f, 1.0f, 1.0f, 8.0f, 1.0f, 1.0f, 1.0f, 1.0f}, /* Edge detect */
    { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f}  /* Emboss */
};

The final fragment color is calculated by a simple shader which, at the core, just performs the following:

for(i = -1; i <= 1; i++)
    for(j = -1; j <= 1; j++) {
        coord = gl_TexCoord[0].st + vec2(float(i) * (1.0/float(Width)) * float(Dist), float(j) * (1.0/float(Height)) * float(Dist));
        sum += Kernel[i+1][j+1] * texture2D(Tex0, coord.xy);
        contrib += Kernel[i+1][j+1];
    }

    gl_FragColor = sum/contrib;

When the user chooses a filter, the application updates the kernel currently in use with a call to:

loc = glGetUniformLocation(sh.p2, "Dist");
glUniform1i(loc, dist);
loc = glGetUniformLocation(sh.p2, "Kernel");
glUniformMatrix3fv(loc, 1, GL_FALSE, &kernels[curker]);

Dist is a user defined parameter (you can change it using arrows) that defines the distance in pixels from the center to the contributing sample.

Since a month I have created a YouTube Channel, now you can have an idea of how this demo works without downloading and compiling the source code: have a look at this link!