Recently I’ve published two websites LANified! & Missing the Point using this framework and so far it’s not only aided in increasing the development speed, but has taught me a few things about web-development in the process.

The most significant feature CodeIgniter (CI) offers over traditional php development is a robust MVC architecture. CI Splits the development of your site into Models (Data Access Objects), Views (Templates), and Controllers (Core Logic) which allows you to be very modular. You can easily access the code to display components of your site and change them without affecting how the data is gathered & organized.

With this convention you can easily program logic & data-access witha skeleton display and update it as your web-designer pushes new revisions of the site-design. Or if you’re doing it yourself, you can get a completely functional website before working on the design.

CI gives developers the tools to do what they need with tested standards and a flexible environment. You can write custom libraries & plugins for the framework which expand it’s functionality greatly. This allows you to focus on the development of the site and not get stuck around that pesky SQL bug.

Check the project page out at:

Project Page on Reanmachine.com Wiki

The wiki itself is still under development (and being used to write some of my class notes, heh) but most of the Software: Namespace is ready to roll.

Anyway, unfortunately for me, the problem wasn’t in my memory, but this wonderfull excursion in computer diagnostic process has led me to a wonderfull tool which I’d love to share with the world.

It’s called Memtest86+

http://www.memtest.org/

Wonderfull little tool, you download a bootable image, comes in many formats including EXE for bootable USB Keys, and runs a full band of memory tests on your system memory, as well as dumping out some usefull metrics on your L1 and L2 cache.

Anyway, I suppose this post is more of a shout-out & reccomendation for the software than anything else, so I will leave you all with this:

Memory problems? Getting errors? Get Memtest86+ !!

To simulate depth of field we will need to employ two advanced rendering techniques, the first is Vertex/Pixel Shaders, and the second is Multi-Pass Rendering. Vertex/Pixel (or Fragment) Shaders are small programs that run directly on the gpu over a specific set of data. A vertex shader is a program that’s run for every vertex it’s applied to. A Pixel (Fragment) shader is a program that runs for every ‘fragment’ which is a visual body of pixels drawn to the buffer, this is usually interpolated accross every pixel. Multi-Pass Rendering is a technique in which we render the same scene multiple times per frame, with different effects and/or purposes and we merge the outputs in some fassion to provide the desired result.

First Pass

Firstly we need to render our scene, but this will be in pin-hole format, or completely in focus. We apply a Vertex/Fragment shader to all the objects in the scene, the purpose of this shader is to calculate the distance from the camera of each pixel and store the blurriness coefficient in the alpha channel of the scene.

The shader will need various inputs from the program, such as the camera location, the visual depth of the focus plane, the visual depth of the near focal plane, and the far focal plane. This will allow us to set up a gradient of blurriness between the focal plane and the far focal plane, likewise for the near focus plane.


let fp = focal plane
let ffp = far focal plane
let nfp = near focal plane
let d = distance from camera
let b = blurriness

if (d > ffp OR d < nfp) { b = 1.0; }
elseif (d > fp AND d < ffp)
{
b = (d - fp) / (ffp - fp);
}
elseif (d < fp AND d > nfp)
{
b = 1 - ( (d - nfp) / (fp - nfp) );
}
else
{
b = 0;
}


Render Pass 1	Render Pass 1 Alpha

After the pass is rendered, the framebuffer is copied into a texture while maintaining the alpha channel for use in pass 2.

Second Pass

The second pass we will render a single quad to the screen and apply the texture generated by the first pass with a second Vertex/Fragment Shader. We will only need to pass the texture and the max blurriness to this shader, the rest of the information is stored inside the texture.

For each pixel we construct a unit circle (1.0 pixels big) with a possion distrobution of a number of points. If you’re lazy you can use a fast-blur technique instead of gaussian by setting your unit points to:

(1, 0), (-1, 0), (0, 1), (0, -1), (0.4, 0.4), (-0.4, 0.4), (-0.4, -0.4), and (0.4, -0.4), this will give a good average 8-point sample.

We then take the texture coordinates of the pixel we’re looking at and for each sample in our list (possion or lazy) add sample-point * (blurriness * max_blurriness) to the texture coordinates and sample the texture @ the resulting pixel. The samples are all averaged and a resulting color pixel is generated and output at the original location.

This is a simple blurring technique. Where blurriness is 0, the sample unit circle is effectively multiplied by 0 and will yield the source pixel. Where blurriness is 1.0, the unit circle is multiplied by max_blurriness, and will expand the sample points to sample nearby pixels.

We run into one problem however, at the edge of a sharp foreground object, we will get bleed from the sharp object into the blurred background/foreground. To compete this, we test the blurriness of each sample point, if the blurriness difference between the source point and the sample point is greater than a set threshold, we discard the sample and replace it with a sample from the point we’re inspecting.

2nd Pass:

And there you have it, a 2-Pass Depth of Field technique.