I was responsible for the build pipeline for our Unity projects, which included a Jenkins server and GitHub Actions. I set up the pipeline to automatically build and test our projects, ensuring that we could catch issues early in the development process. This included setting up automated tests and code quality checks to ensure that our code was always in a releasable state. At the start, developers were expected to make their own builds, which quickly led to a lot of confusion between configuration state and wasted time chasing all the platforms we supported. First, I put important configuration for each platform behind editor tooling to help standardize our working copies. Then, I added batchmode functionality to inject all the relevant credentials and parameters for each platform at build time, allowing us to run the builds straight from the command line from fresh checkouts. We stood up a Jenkins VM with a Unity license where I configured all the supported platforms and various hacks to older Unity versions to get them working on a nightly basis. From there I improved turnaround time with cache servers, build license servers for parallelization, and repository Jenkinsfiles for PR commit builds. Then, we moved the bulk of the Unity build to GitHub Runners so I needed to replicate much of the environment and state in our new customized build images. To date Jenkins remained the coordinating source of scheduled builds, but called out to GitHub Runners to make the artifacts. That also poised us to use Runners for our automated testing such as ensuring that each PR commit builds for every platform without requiring developers to switch and reimport the entire project several times per PR.

As an early developer on the team, I helped take our applications from proof of concept to production quality by helping to extract and standardize the platform on which they were built and with which we could build further applications more quickly. This involved us creating systems and editor tooling to author and synchronize the state of scene objects across all clients, and to back up that state to our cloud service. We used an off the shelf networking solution, Photon, as a basic message bus between clients, and built our own protocols on top of that. Our web interfaces facilitated enrollment, scheduling, content management of the assets in a session, reporting, etc things you’d expect. For ease and speed of implementation, the messaging and state management was lots of JSON, but we had begun to push towards a more structured approach with protobufs and shared schemas to reduce transfer and storage.

These apps made full use of our platform, allowing users to author and schedule training sessions for their students. It was built to be a modular system, allowing us to add new content and features as needed. The apps were designed to be used in a classroom setting, usually with an instructor or multiple students in HMD like HoloLens but also with an arbitrary number of participants on mobile devices as ‘magic windows’ into the scene either in-person or remotely. It let instructors create and manage training sessions, and students could join those sessions and interact with the content in real-time. The apps utilized our web interface for instructors to manage their classes and schedule training sessions, or control the scenario directly in a WebGL control panel for some of the apps. I was directly involved in developing many aspects of our products, from the platform and networking, datastore communications, state synchronization, authoring tools, custom rendering pipelines required for performance targets and the level of dynamic response required from our patient, and various content authoring like setting up individual medical scenarios.

A cooperative project with a tabletop company to create a digital version of their enterprise-geared cashflow edutainment game. This game required a very disciplined approach to its state and business logic due to its size and complexity and planned needs for cloud game saves. I made extensive use of ScriptableObjects to decouple the default game state and logic from the scene. I also implemented significant coverage with unit tests around the game’s core logic, in order to ensure we were staying accurate to the provided rule booklets, using Unity’s integration of NUnit.

Unit Tests

Unit tests everywhere

GameState Defaults

With ScriptableObjects containing logic and defaults, anyone was able to edit and test various starting conditions in the editor

ActionQueue command for Tax Phase

The command queue let me break the complex game phases into bitesized pieces

ActionQueue command for AssignTalent

Even the complicated steps that could fail were scheduled this way

CHL came to us partly complete but needed a team whose expertise spanned not only mobile development but could also handle the hurdles of physical device interfacing. Mobile exercise game for kids paired with a cheap BLE Fitbit clone wristband. I had to spend significant time in this project testing communication reliability and implemented lots of overhead above the serial connection to queue, throttle, and retry necessary actions while keeping the game feeling as responsive as possible.

Sample of the provided hardware spec

I'm okay with poring through a roughly-translated spec sheet...

Sample of the resultant system call

...and crafting systems and code to fit

Sample of the resultant system call

...and crafting systems and code to fit

Freight client sought to pilot VR forklift simulations in its training. Our environment would accompany classroom training sessions, track performance and understanding of the processes involved, and report metrics to instructors. We gathered video, scans, and lots of resources from job sites, including a few days of training in-person on the target heavy machinery. With the Oculus Rift/Touch, we recreated the machinery with its control systems in VR–even so far as using a Logitech wheel and pedals setup for steering and acceleration, which presented its own challenges.

Tutorial

Introducing the student to the controllers

Tutorial

Driving Tutorial

Operating Controls

Teaching students how to manipulate forklift levers

Inventory UI

Selecting appropriate materials for different load situations

Everyone Loves Nodes

Lesson objectives relied heavily on state machines in Playmaker to speed production which let me iterate and tweak quickly according to playtesting

This client wanted to gamify exercise for schoolkids. It was even featured in a writeup, check out the article here! It ended up with two lofty goals from a programming standpoint, utilizing the Kinect sensor in a user-friendly (KID-friendly) way, and tracking several of them finely enough to identify and count exercise motions. I created a method of tracking each skeleton, even if moving around the frame or in- and out-of-frame. I also made a simplistic gesture recognition framework, and a library of pose sequences with which my target “exercises” were assembled. I was able to track how close a person’s body was to the desired position and provide feedback on how to match the target, all illustrated through a fun rigged robot character doing the same exercises. To login, students held up to the Kinect camera a personal QR badge which was printed by the instructor from the Web LMS.

Individual Exercise Instruction

Left - Fun animated coach. Right - Realtime feedback from Kinect

Running Trail Obstacle

This required a high punch when you go close to clear the obstacle

Running Trail Obstacle

This required a low kick when you are near to clear the obstacle

Activity Description

Instructors built sets of exercises on the Web LMS and students performed them in-game

Activity Description

Custom exercise sets could also be set up in-game for immediate play

Assessments

Students had a number of metrics tracked and saved to the Web LMS and could compete against their own best runs

Select Activity

Once in-game there were a number of options for play including assignments built by teachers on the web

Web Metrics

On the web LMS teachers could see reporting from their students including a fine-grained detailed view of events sent via the web API

Web LMS

Instructors could pick any class they managed and assign a number of exercise sets to show up on a given class date

Exercise Sample

Exercises were comprised of sequential position tests--GestureComponents--that let me combine and reuse a common library of actions

Exercise Sample

Exercises were comprised of sequential position tests--GestureComponents--that let me combine and reuse a common library of actions

Gesture Component Sample

Gesture Components took snapshot observations from the Kinect body frame and would perform basic tests to determine what sort of pose certain joints were in like 'both hands are raised'

I am frequently tasked with mobile apps to assist sales personnel, with one such example seen here . I used phonegap/cordova here to leverage my experience with web development. The app connects to a custom backend that syncs up file content (products, videos, brochures, etc) for offline access, and lets me make changes and additions without having to push a new binary through Apple’s approval cointoss.

This app expanded upon the model I’d built with WMed Mobile for continuous product delivery without app updates. Its AWS-based backend communicates with an existing enterprise product and media asset system and delivers content securely to mobile endpoints, behind the client’s own Okta-based directory authentication.

These small-scale sites were built for pilot presentation material ordering, and for new pilot hire initiation training. The stack chosen utilized a static generated site with VueJS providing state, routing, etc but otherwise cheaply hosted via CloudFront/S3. Form submissions, email confirmations, etc were handled via API Gateway and Lambdas in NodeJS.

A chemicals company wanted a slick interactive showcase to be used by their sales team. We created an artistic powerplant environment with dynamic lighting, UI, animations, particles, and even liquid flow.

Unfortunately the Kickstarter for this project didn’t complete, but I made a lot of headway in our playtesting and prototyping. This included working with the then-still-new Oculus developer kit, and ramping up on many concepts like water caustics, mixing rigged and point-cache animation methodologies, laying out bezier pathing controllers for sea creatures, and more

This was a beast of a project and a well earned lesson in many aspects of rendering and optimization for lighting, baking, and VR performance. Our first attempt to slap an entire modeled 3D home in a scene and run was a massive slog, so from that starting point I learned to whittle and tune and profile like a champ. I introduced the usual suspects like occlusion and frustrum culling, instanced materials and geometry, tuning the lighting and advising on mesh construction, LOD levels, and texture atlassing. We learned a ton and eventually delivered an immersive floorplan visualizer when VR was just taking root.

This was an internal demo project we revisited several times over the years to show off different aspects of our work. The main concerns were to make it as visually impressive as possible, and show off cool interactive features. Choosing which parts to emphasize quality-wise was key for performance, and we’d always have to balance that with what was actually discernible in the headset. Our interaction sequences would often have the participant assembling some medical device from one of our clients onto a poor patient’s open knee or foot.

This project was geared towards soft skills training that put students through several managerial scenarios and prompted decision making. I was tasked with profiling and optimizations, and other technical art wizardry, to finish delivery.

This archviz project was to help visualize the client’s proposed revamping of their product showroom. We recreated the planned space to scale, modified the construction based on the proposals, and allowed executives to preview the functionality before committing to costly renovations.

LoadCaptain was one of my first Unity projects, coming from years of web development. I was its sole developer, so I really had to hit the ground running. It featured a 3D tarmac and airplane environment, complete with cargo interior, loading scaffold equipment, and tarmac carrier trams for the various freight. We had dozens of lessons and plane configurations to build, each with very specific cargo securement orders and techniques. Participants across the country got graded, recorded, and reported to a central metrics database (VPS with a REST API, backed to MySQL) and transmitted to the enterprise LMS in a nightly cronjob. This program was used for years after WebPlayer was deprecated and instructors were forced to give up the last version of IE that supported it.