Programmable RGB-LED Softboxes for studio photography. Much faster and easier to work with compared to colored gels, and it's possible to produce complex lighting effects using just two programmable softboxes which would require four or more standard strobes with gels. Large boxes can make for nice background gradients, as well. They're not a perfect solution for all use cases, though, and in particular are very limited in their brightness compared to many studio strobes.

Brightness can be improved by adding additional LEDs for each 'pixel', but the power requirements make this impractical for very large arrays, and in general it's not likely these boxes will ever compete with sunlight, so for the time being they're strictly intended for use in a studio environment.

A small art project controlled by someone's heartbeat.

For a possible installation/exhibition setup the handy PulseSensor is now used to detect someone's heartbeat. This can produce a reasonably accurate estimate of someone's heartbeat just by lightly pressing their finger against the sensor. Earlier prototypes used an AD8232 with an Arduino to estimate the moment of each heartbeat.

The heartbeat data is fed to a raspberry pi which triggers each outward pulse. These pulses flow outward, eventually rippling back in toward the "heart". When they come back, each of them has a chance to drag in a small particle, which will be pushed and pulled by the currents triggered by the user's heartbeat. If these particles are either pulled in to the center or pushed out past the edge of the lights, they trigger a change in the colors used for the heartbeat waves.

Still a work in progress!
A very rough prototype to test the idea of making a game based on a short film by the same name. The idea was to build a dark horror experience with stealth and tower defense elements.

Still in the very early stages, but the lighting isn't looking too bad, so far, and both allies and enemies follow a reasonably robust prioritized task-based planning scheme which allows them to adapt on the fly to changes in the environment or their situation. The map is generated procedurally.

A RetroPie system built for a friend's birthday. Wired to support the original SNES controllers for maximum nostalgia, and it doubles as a lamp! A small fan was also configured to kick on any time the Pi started to get a little too warm, but it's almost never needed for most games.

I had originally planned on 3D printing the case since there are some cool retro designs out there, but in the last stage of the project got my hands on a laser cutter which led to a much nicer, personalized, case.

After seeing this presentation from Jane Ng about her work on Firewatch, I fell in love with their backgrounds and tried to build a similar sky and fog shader. Their blog entry on the topic helped me get started by defining the parameters they use for their system, but it was a little light on implementation details.

I started by just generating simple gradients for the sky, set from user-defined colors. From there I projected the sun as a circle onto the sky from a position on the unit circle (to allow the user to set the time of day) and added some exponential falloff from the sun's base color to the sky near the sun's position. The fog itself is a simple exponential function, with the density of the fog increasing with distance from the camera and with decreasing height. Scattering effects from sunlight into the fog are handled with a similar exponential decay function to the halo around the sun in the sky.

As a team of four, we attempted to teach Nao to play the Glockenspiel over the course of about six weeks. This included visual detection of the instrument and playing sticks, grasp planning to retrieve the sticks, and a simple method for learning the ideal joint configuration to play each note once Nao was ready to play. The visual estimate of the instrument's pose gave a good guess for which note would be played via an IK solution, and audio processing allowed Nao to determine when the correct note was played.

I helped build a small fluid visualization application in OpenGL over the summer. Our main goal was to produce something specifically for fluids, with the hope of making something more intuitive than ParaView for at least a limited set of scenarios (ParaView is amazing, but very complex).

A short game made with a friend in one week for the Public Domain Jam. You take on the role of Cyrano de Bergerac just after he joins the military, and before he has gained the great amount of respect and panache that he is shown to have in the play.

Simple object tracking prototypes in one and two dimensions using a cheap webcam. The tracking data is used to control the state of an LED array (via USB connection to an Arduino which manages the LED driver).

A little hacky but working. The sky is actually just a hollow textured sphere, which unfortunately required me to bump the iteration count on the march up to avoid getting a seam on one side (should probably have just used a cubemap).

TODO: Caustics for the shadows, and reworking the hacks into something more robust (e.g. in the current implementation transparent objects will occlude other transparent objects).

NOTE: It will render at the size of your browser window! If you have performance issues, try resizing your browser.

Another game jam collaboration.

You are an owl. With an airship. Powered by ferret slave labor. Low on fuel, you must raid a small island for fresh workers before your ship loses all power and falls from the sky. Ferrets are quick and paranoid, though, so you must use stealth and traps to capture...

You only live as long as the last person who remembers you...

A short game made over a few days for a game jam. It features a persistent world, procedural dungeon generation, and multiple playable characters with their own weapons. The game focuses on the experience of ceasing to exist after d...

A simple animated raymarching exercise. Supports procedural and bitmap textures, both of which go through the same lighting process, as well as soft shadows and ambient occlusion.

A small simulation which begins from a "seed" set of triangles, growing new ones from each available vertex while taking care than any newly-added triangles do not overlap any existing triangles.

A Tetris-like game in which some pieces release water into the play area when they are cleared. As the water level rises, wooden blocks will float, separating them from metal and water blocks. This creates a two-tiered play area in which one must plan rows both at the surface and at the bottom of the water. The water level itself is managed by the player by submerging fireballs, which causes the water to evaporate.

More or less "Hello World" for HTML5 and WebGL. On the left-hand side of the page you can see the color gradient used to render the fractal, and by clicking on the labels along the gradient you can configure it to render in any colors you like. (it will also randomly regenerate the gradient if the page is reloaded, but this doesn't usually produce pleasant color combinations)

2D layered sprite engine for a never-finished action RPG. The engine was written in Python with the help of PyGame, and the map editor/animation viewer was written in C#.