Raygun is a general purpose ray tracer written from scratch in C++. Supporting libraries include libJPEG and libPNG for loading textures and saving rendered images. There is also a work in progress GUI front end, built using the Qt Framework. An added advantage of using Qt is its automated Makefile generator, Qmake. The Qmake system (like CMake), along with the cross-platform Qt Framework libraries, allows Raygun to be compiled on any Qmake compatible environment (e.g. MingW/MSVC on Windows, X11 on Linux, OSX, etc.) with relative ease.

Some of Raygun's features:

• Blinn-Phong shading
• specular reflections
• shadows
• refraction (transparency)
• textures
• normal mapping
• sky boxes
• metaballs

Here's the source code on Github.

This project culminated in my Master's thesis titled Ray Tracing Large Distributed Datasets Using Ray Caches. The primary goal was to develop a method of ray tracing datasets that are distributed among several hundred processors in a cluster. The real "selling point" was to allow visualization to occur during a simulation; a concept known as "in-situ visualization".

The gist of the method was to capture and re-use rays that had traversed the dataset on a given cluster node, rather than casting and computing new rays. Doing this reduces the amount of communication required to send rays back and forth, and also reduces the total number of rays that need to be computed at each node.

Would you like to know more? You can read the abstract and the full paper at UOIT e-scholor.

Voluvis was initially a weekend project to build a real time volume visualization application in OpenGL/C++. The visualization uses a ray casting algorithm computed on the GPU fragment shader (written in GLSL), using a 3D texture sampler.

See the embedded YouTube video for a demonstration. You'll notice the quality and frame rate of the rendering increase/decrease as I modify the number of samples that are taken along each ray. You'll also notice the intensity of the rendered colour increase/decrease as I modify the weighting between accumulated density values and mapped colour values.

MuttEngine is a simple 2D, sprite-based game engine written in C++ using SDL and OpenGL. Currently MuttEngine supports drawing static or animated sprites (using spritesheets). The engine also supports GLSL shaders for customizable hardware acceleration.

MuttEngine has been my initial foray into 2D game engines and I plan to extend it for use in a proper game. Initially this project was simply to learn more about cross-platform graphics application development using SDL.

Matitor is a basic, work-in-progress WebGL GLSL shader editing tool written in Javascript. Currently the editor supports texture mapping, bump/normal mapping, and cube/environment mapping. The inspiration for this comes largely from a talk by Lilli Thompson, who spoke about leveraging HTML5/WebGL for game development and development tools.

Here's the live demo. Disclaimer: you'll need a modern web browser (I recommend Google Chrome or Firefox) and up to date video drivers.

This is a simplistic image gallery and cropping tool written in ActionScript 3. Images can be loaded into the application, cropped, and then downloaded and saved as a jpeg file.

Here's a live demo.

A Sobel filter (or Sobel operator) is a simple image filter which is used to compute the gradient of an image. Applying a Sobel filter to a specific pixel in an image produces a value that represents the "amount of change" in colour intensity at that pixel. For example, applying the Sobel filter to a pixel located near an edge between a very bright and very dark area of an image will produce a very high value. When each pixel is redrawn based on these new values, the end result is an image where the edges in the image appear highlighted.

Sobel filters are commonly applied in computer vision and image recognition algorithms. You've probably seen this in use for facial recognition in point-and-shoot cameras or Google Picasa. This basic implementation of the Sobel filter was written in Java for a undergraduate algorithms project.