Game of Life in a Compute Shader

Implementation of Conway's Game of Life in a Direct X compute shader. Demonstrates how a shader program can be used to solve highly iterative non-graphical problems. Compute shader programming makes you pose the problem in terms of the evaluation of thread groups. This mapped very easily onto the rules of the Game Of Life, which are all about the evaluation of groups of neighbours. Lead to a short and simple program. Video and source can be viewed on the article page. Demo & full article

WebGL Game Engine

The engine features a 3D renderer (forward rendering), an entity component system and a rigidbody physics system. I wanted to embed some sort of WebGL application into this website's landing page. Read about how to follow object oriented patterns in Javascript and used my understanding of OpenGL to write a game engine for the web. I look forward to when then next WebGL standard becomes prevalent so I can add a deferred rendering path without the use of browser specific extensions. Demo & full article

The project files are available here. Alternatively you can view source on this page and make your way through the JavaScript includes, left unminified for this purpose.

C/C++ Game Engine

Game Engine in C/C++. Features an ECS, rigidbody physics (via Bullet library), forward rendering with Ambient, Diffuse, Specular + Shadows lighting model. Currently working on hardware accelerated rig-based animation. Long term project, work in progress.

Cardboard Drive

Virtual reality car driving demo for Android devices. Requires the use of a Google Cardboard headset and a dual analog controller. The player races around a coastal course in an automatic car. Features an interactive car interior and engine sounds. The car has some simulated components, including an automatic transmission, e-brake, wheel slippage at high speeds. Written in C#, using Unity. Environment modelled in Blender. Texture detail and poly count kept to a minimum to keep mobile frame rates as high as possible.

Cross platform 3D Renderer in C

3D renderer written in C, using OpenGL. I used ANSI C and OpenGL ES 2.0 to emphasize portability. I wanted to be able to use this project as the foundation for the renderer of any sort of 3D application I might write for desktop or mobile devices for as long as the OpenGL API remains relevant. When ES 3.0 becomes ubiquitous, I may add a deferred path. I am also looking into replacing my WebGL renderer with this project because of how much faster Emscripten generated JavaScript is compared to handwritten JavaScript. Builds for Windows and Android platforms. Demo & full article

Cross platform 2D Game engine in Java

Game engine written in Java with a focus on 2D and 2.5d games. Features a 3D renderer, 2D physics and an ECS. Runs on Windows/Linux/Mac and Android. Input supports Keyboard, Mouse, Gamepads, Touch events (mobile only). Renderer includes out of the box support for unicode text rendering (Standard Multilingual Plane), Sprite sheets and Tilegrids. The engine's math library exposes Mat4x4, Vector 2 - 4 types and is focused on problems of multiplication, projection, line vs plane intersection, and converting points from one coordinate space to another (eg: Mouse pos in NDC to 3d world space at some depth from the camera).

The project makes extensive use of native libraries for the desktop specific code (in order to access OpenGL, OpenAL and gamepad USB devices) and a pearl-based preprocessor to deal with the implementation differences that arise from the differences between the Desktop and Android Java environment.

More information can be found on the G2Dj project page.

RPG level & script editor

Features a hardware accelerated 2D tile renderer, a level editor and a script editor for NPC behavior. The scripts are interpreted by an embedded Lua interpreter, allowing end users to reprogram NPCs without needing access to the project's source code. Users can use external text editors or use the script editor programmed into the level editor. The script editor includes a debugging feature.

After playing an old Playstation game I'm fond of, I thought it would be an interesting problem to create an equivalent renderer that offloads all forms of animation and drawing onto the GPU. Once the renderer was complete I wrote a simple level editor. I decided to add end user programmable NPCs, so I embedded a Lua interpreter for that purpose.
It should be noted that I do not own the graphics for this project. It started as an homage and ended up some kind of tech demo.

Builds for PC & Android. Demo & full article.

Tower Defense

A 2D tower defense game I wrote in C++, uses Direct X9 for rendering. Features an implementation of the A* path-finding algorithm and a hardware accelerated tile renderer. Level data is stored in XML documents and loaded from file. I never wrote a level editor, so making the game's different stages was a bit tedious. The code is split up into a number separate sub projects, divided according to purpose (Renderer, Pathfinder, etc.) to improve compile times and modularity. Demo & full article

Sushi Joint Rumble

A beat 'em up game with RPG leveling, skill unlocking, item purchasing. This was the result of my 3 semester long final school project during the Algonquin College Game Development program. I worked as the lead programmer on a 7 person team. My responsibilities included technical design, weekly builds, reviewing code commits and of course programming. The amount of subsystems and mechanics lead to a scope that well exceeded the year and a half we had to complete the project. Content ended up being spread thinly across all aspects of the game, whereas we would have been better off focusing on the core elements of the beat 'em up. Definitely learned a lesson on the importance of a focused design. Many over nights at the computer labs, a lot of hard work, a lot of fun.

Terrain map generation on the GPU

Hardware accelerated terrain generation. Terrain data is encoded in a texture. Various channels are used for height displacement, uv, foliage type. A highly tesselated plane supplies the vertex data for the shader. Verts are aligned with texels in the texture, new heights, coloring etc. are calculated via texture lookup. Normals are recalculated after displacement and the terrain is coloured as usual in the fragment shader. Using this method, a huge amount of terrain data can be stored in a texture, as the player moves around, the tesselated plane is used to render a subsection of the data. This also lets you take advantage of texture wrap modes to very easily create finite or infinite worlds. Demo & full article

Voxel renderering on the GPU

Here are a few different voxel renderers I made while reading about procedural terrain generation. One is a minecraft style terrain generator, rendering a noise function as voxel data around the player. It was implemented on the CPU, so I had to spend time hiding chunk loading etc. and this lead me to thinking about how to hardware accelerate the process. To move voxel generation onto the GPU, I encoded the terrain data into a texture and used the texture data to generate voxels in a geometry shader. I used this technique to build a proof of concept demo (the one with the smiling stick figure) then a voxel editor and finally I added a curve function to give it a planetary effect. Demo & full article

Speed King

This was a short game I worked on for the global game jam 2015. Team size was 2 people. I didnt end up submitting the game unfortunately, due to an untimely 10 hour power outage on the final day. Mobile game targeting tablets. Combat was structured on simon says. Threw in a vertex shader that curves the game world for an interesting graphical effect.

Railshooter

A 3D railshooter in the vein of StarFox. The player is constrained to a 2D coordinate within a plane that moves from node to node in a 3D world.

HTML5 3D Rendering

Ongoing investigation of the perspective and 3d transform styles introduced in HTML5. Building 3D geometry out of quads (divs) rather than vertexes presents interesting limitations in terms of possible geometry, calculating lighting etc. The payoff is that since all faces are document nodes, the programmer can inject images, videos, text, iframes etc. into the surfaces of these objects by using regular document calls. You also get cursor ray collision detection for free. Interesting environment to explore.

Oldschool Snake

A snake clone written in ANSI C for a command-line interface. I wanted to see what kind of constraints the command-line would bring up for game programming. I found that clearing the screen after every frame lead to unacceptably low framerates, so instead I had to selectively blank the last {x,y} position of moving objects. For example, blanking where the end of the snake's tail had been a frame ago.

The project files are available here

WebGL 101 seminar

An introductory seminar on WebGL I presented for the student group "Algonquin Startup" at Algonquin College in late November 2015. Talked about some of the more interesting WebGL projects on the web, OpenGL at large and a little bit about working with the API yourself. Along with the talk, I wrote a 5 page writeup and a simple example of a textured quad. Demo & full article

The writeup and example are available for download here.

Dropbox Web Interface

This project generates a small website that allows vistors to browse the contents of your public dropbox, stream content (such as audio and video) and download files.
This is accomplished with two separate subprojects: a Java application and a separate Javascript application.

The Java application creates a JSON representation of your Dropbox's public directory (and sub dirs). This JSON data is then provided to the Javascript application, which uses it to render the directories of your dropbox and resolve download links to your files.

The project is meant to work alongside the Dropbox app Updog which allows Dropbox users to host static webpages from their dropbox app/ directory.