A pulp fiction adventure of turn based tactics and real time stealth. This was the primary studio project being worked on during my time at Harebrained Schemes and, while I was technically on the Core Tech team, I worked directly on it for art pipeline programming, along with helping with design and implementation of studio-wide tooling and libraries.

A collection of studio-wide tools and libraries developed with long term maintainability and flexibility in mind. My primary role at HBS was as a member of the Core Tech team, which was intended to be a project-independent tools and infrastructure development team. The idea was to move the studio towards more modular, reusable code that was held to a higher standard of quality and documentation. My role specifically was on the technical art and graphics sides, though I also became the primary point of contact for anything involving Python in various projects.

Squids From Space is an 8 vs. 8 online competitive top down asymmetric shooter in Unreal Engine 4. It started life as sort of a spiritual successor to Fat Princess, an earlier game Fun Bits had worked on, but quickly grew into its own. I was deeply involved with this project since we started working on it (then a mothballed prototype) and was one of the primary programmers through the bulk of the project. In September 2019, I assumed the lead programmer role.

This was our second contract working with the Oculus team - this time, to port the First Contact Oculus Rift demo to the upcoming Oculus Quest. This was quite a big task, as, in addition to the vast difference in power between a PC capable of running Oculus Rift and the upcoming mobile based Quest platform, the original Rift version (from our understanding) hadn’t even been initially intended as a full product, so there was a lot that needed to be optimized.

This is a sandbox I made in Python to experiment with techniques for generating terrain heightmaps. It’s set up such to allow for rapid iteration of generation logic, caching algorithm steps to avoid having to recalculate parts of the process unless necessary. It uses Perlin noise to perturb Voronoi diagrams with edge detection optimized for processing island beaches.

In early 2018, Fun Bits was contracted to add support for a large list of languages to a few of its demos and tutorial applications. The main one I worked on of these was the Touch Basics (or Touch NUX) application, which was what would run upon first setup of the Oculus Touch controllers. This was a little bit of a challenge, as the project had been built on, at the time, a pretty old version of UE4, which predated many later features for both localization and font support in VR.

Orbital Loop is a music “game” for Google Daydream, as one of two projects (with reGrow) we were working on for the then upcoming VR platform. It’s essentially a relaxing music composition application, intended to take advantage of VR to give a more engrossing experience than would necessarily be possible with a conventional platform.

reGrow was one of the two projects Fun Bits was working on (with Orbital Loop) for the then upcoming Google Daydream mobile VR platform, and the first project I worked on at Fun Bits that was really our own. The premise changed some over its development, but always revolved around the idea of growing and breeding gardens of flowers.

A 3 vs. 1 asymmetrical competitive multiplayer game where three wolves attempt to steal sheep from a shepherd. This was my second year team game project at DigiPen, where I worked with a team of four over the school year, serving as technical director. We started with a custom engine, where I built most of the core engine, the physics system, and most of the editor. We switched to UE4 for the second semester of the project to allow us to focus more on game design and polish.

This was a project over the course of a semester for an advanced real time rendering class. By the end, it supported deferred rendering, mesh instancing, BRDF lighting, soft shadows (using exponential shadow maps), dynamic reflection, image based global illumination with HDR environment maps, and screen-space ambient occlusion.

The second raytracer I built for school, this time a bidirectional path tracer in C++. Over the course of the project, I added support for several forms of optimization as well as features such as depth of field and constructive solid geometry (CSG). Other features such as global illumination, shadows, and reflections came naturally out of the algorithm.

This was built up over a semester for an animation programming class. It implements hierarchical skeletal animation systems for arbitrary meshes with support for both forward and inverse kinematics as well as path following along splines with animation speed-matching.

This application implements Filip Strugar’s Continuous Distance-Dependent Level of Detail (CDLOD) algorithm for rendering heightmaps. This is a real-time, GPU based method for dynamically blending between detail levels of a terrain mesh with adjustable density aiming to keep triangles a consistent size on screen while avoiding artifacts such as gaps in geometry where detail levels change.

A multiplayer platform-based arena game where each platform has its own localized gravity. This was the first full team project I worked on at DigiPen. On a team of five, I was primarily the physics programmer, which posed an interesting challenge given the gravity focus of the core concept of the game. Additionally, the project was built on a custom engine that I had made in a previous course.

A physics simulation with support for large numbers of masses constrained by springs using a Verlet integrator.

A raytracer built over one quarter in Java with support for Beer’s law light attenuation and total internal reflection for dielectric objects. Display was done with OpenGL, but the actual image is calculated on the CPU using conventional inverse raytracing.

A two player arcade game with procedural maps. This was a team project for an object oriented design patterns class in C#. The objective of the assignment was to apply design patterns practically to achieve a complex application that was robust and flexible. For this project, I was the leader of a team of three and architected much of the core engine code.