This page lists some of my current and previous projects.


Some games I’ve been working on in my spare time


I started using Unity as a way to quickly get into the actual “gameplay programming” of a game without focusing so much on the engine specifics.

Untitled Shoot-em-up (2010)

Ongoing basic ‘shmup’ game. Collaborating with friends on the ‘gimmicks’ to use (as these define the genre).

Current build playable at:

Uploading new builds as I create them to:

Gravi-Lerpz (2010)

My first Unity project. Started with the 2D Gameplay Tutorial from Unity and added gravity manipulation, including walking up walls and ‘inverting’ gravity on the player. This was quite an undertaking for a first Unity project as I had to completely throw away most of the original code from the tutorial.

Current build playable at:

Playable at:

Tachyon (2010-present)

Personal DirectX 10 game written from the ground up. Still in preliminary development stages. Using as platform to learn, develop and test efficient code for modern hardware. Work done in spare time.

The direction of the game is towards a side-scrolling adventure, similar to “Metroid” or “Castlevania”. While the gameplay is in 2D, the graphics will remain in 3D.

As I’ve been focusing more on the technology behind it all, the gameplay is very simplistic for now:

  • Spawn balls (Right Bumper) and players (Y button) so you can shoot them
  • Balls only take a single hit to destroy
  • Players take more hits to destroy, but you can tell how low on health they are by the color of their smoke

Some implementation details include:

  • Pool of reusable ‘entity’ objects, which only contain references (read: pointers) to possible attributes
    • Influenced by “Data Oriented Design” concepts
    • Attributes allocated from pools
    • Presence of attribute can affect how the entity is used (collision, movement, drawing)
    • Still very basic system; could be expanded to more attributes
  • Concurrent “worker” threads
    • Animations
      • Animations advanced for current frame
      • Final animation matrices calculated for rendering
    • World collision queries (“Traces”, using term from Q3A)
      • “Requests” come in from main thread
      • “Responses” output from worker
  • World organized into Rooms
    • Rooms divided into cells.
    • Collision done on cells.
  • Collisions handled through a request/response approach:
    • Request for movement at beginning of frame, handle at end of frame
    • Request for ‘ground check’ at end of frame, handle at beginning of next frame
  • GPU-driven Particles
    • Very basic “position, direction, color” particle system written in HLSL 4.0
    • Utilizes Geometry Shaders to create/destroy particles.
    • Able to drive a large number of particles, with (seemingly) little overhead.  (Have yet to do proper profiling)
  • Barebones Resource Pipeline
    • Models/World definitions edited/stored in XML format
    • Pipeline converts the XML to Tachyon file formats for in-game loading

Source is available on BitBucket:

I have created an initial release:

Please read the README.txt file for instructions.


I’ve been doing some PS3 work in my own time to prepare for future… endeavors into game programming.


My first Cell/PS3 program. Written in C, using SPUs to run particles and XGL to render particles. Initial code from NeHe Lesson 19‘s Linux/XGL port, since I had no prior X experience.

I did a short writeup on this:

Final version can be found at:

University Work (2004-2007)

In my academic studies, I had an emphasis in 3D theory and implementation, primarily with OpenGL. Some notable experiences during this time were:


Contributed to the Chromium OSS project. Chromium allows you to run a single OpenGL application across multiple servers and monitors (eg: large-scale display).

I contributed rudimentary support for OS X OpenGL (CGL and AGL). This required knowledge and investigation of the OS X OpenGL implementation.

Raytracer (2004)

Semester-long Raytracing project. Written in C++ with an emphasis on performance.

Implementation details:

  • Scene described in .ray file (original defined by instructor, some extensions added)
  • Lighting and shadows
  • Reflections: reflect 100% or reflection map (image)
  • Refractions
  • Multisampling
  • Textures: from files or procedurally generated (checker, noise [‘clouds’])
  • “Interactive” (camera movement) with somewhat complex scenes (see: left image above)

Binary download:

Source available upon request (conditionally, due to being from a University project).

Volume Renderer (2005)

Basic volume rendering written in GLSL. This was my first time using programmable shaders.

Implemented using a two-step, multiple-pass approach:

  • ‘ray’ directions created by rendering backfaces of a unit cube that has color components set to vertex positions
  • multiple passes are used to march the pixel shader functions down through the volume

Binary download:

Source and additional data sets available upon request (conditionally, due to being from a University project).


Some notable courses taken during my university career:

  • Advanced Graphics (semester-long raytracer project)
  • Artificial Intelligence
  • Bioinformatics
  • Information Visualization
  • Real-Time Rendering
  • Scientific Visualization

World of Warcraft Mods

Spyglass (2007-2008)

Developed a modification for saving and viewing the equipment a player was wearing the last time the user inspected them.

Utilized the WoWAce community to host the source and package it for distribution to a large client-base.

Suspended work on this mod near the end of 2008; it has since been picked up by another developer.

Viewable at:

Quake 3 Mods

MD3 Importer for 3D Studio Max 5 (2003)

Limited to only loading a single frame.


Gundam Universe (2001-2003)

Q3A Mod based on the Gundam universe.

Coordinated with a team of developers on the overall look and feel of the mod. Coordinated with artists on changes to the typical Quake3 model hierarchy. Coordinated construction and distribution of builds between team members.

Select functionality that I implemented:

  • True-to-source movement, including boosters and movement in space
  • Worked around limits imposed by engine to develop a server-side method for accurately determining the position of points on models of varying sizes (model data is not available on the server); this was to allow exact calculations of weapon firing positions and location-aware damage.
  • Custom UI, including different UI for first person vs third-person
  • Per-Suit attributes (aka ‘classes’), including: armor values, boost times, and weapon selection
  • Custom weapons: a few were duplicates of Quake3 weapons, but there were a number of additions. eg: head-mounted ‘vulcans’
  • Special effects to convey player damage

I kept a development log, which I’ve moved to here: Work Log

Note: my work stopped in 2003, but the mod wasn’t released until 2008. Because of this, I am not aware of how much of my work stayed in the mod.