This article represents a CV of my independent work outside of professional development. All of the projects listed are game engines or related tools of varying degrees of completeness, dating back to around 1994. The projects show a progression that roughly coincides with evolving technology and industry practices over the years. Also shown is a buildup of sophistication and evolving programming styles. I've tried to approach each successive project with a new mindset, and use them as testbeds for learning and research. I've listed the notable features of each project and provided links to github for reference. Projects are listed chronologically, newest to oldest. Many of the older projects are missing binaries and no longer compile on modern tools, but screenshots are provided when possible.
Quagmire is a re-implementation and continuation of the complete feature set of Griffin from the ground up, with additional features and guidelines that improve iteration times and quality of life while working on the project. This engine is still a work in progress.
The code style is in stark contrast to Griffin, showing a paradigm shift away from "modern" C++11/14, OOP, RAII, and templates, and toward procedural programming. Code is written from the mindset of data transformation; closer to the metal, and regarded as a thinner layer over the machine instructions generated by the compiler. Memory is treated like memory and not some abstract thing. This shift was inspired, in large part, by prominent developers Casey Muratori, Stefan Reinalter, Jonathan Blow, Bret Victor, Mike Acton and Chandler Carruth, among others. Inspiration also came from the fact that continued development of Griffin was akin to dragging an anchor through mud.
Quagmire is a continuation of my practice of data-oriented design and improvement to my entity-component-system architecture ideas. One key improvement is better APIs and a simplified code structure throughout the project. I have been able to introduce SIMD intrinsics in many places due to the use of SoA and AoSoA patterns.
Quagmire is also the launchpad for my current game project, with the goal of an eventual commercial release.
- Rewrite of Griffin in C-style C++, no templates, unity build, procedural style
- 4 second clean build vs. ~5 minutes for Griffin
- Windows and Linux (MSVC, GCC, clang)
- Runtime hotloading of game code (game.dll/.so)
- Custom memory management (arenas, linear allocator, heap allocator)
- Fixed-grid spatial hashing with high-speed bitwise scene culling algorithm
- Multi-threaded, data driven input system supporting contexts, control/key mappings, actions, states, toggles, and motion axes
- Data oriented design
- Use of SIMD intrinsics
- Generic container library without C++ templates
Griffin brought forward the development from many of the older projects into a more cohesive engine. This was also my first foray into data-oriented design principles and ECS architecture. Development of Griffin halted in 2015 with the start of Quagmire.
- DoD containers
- Fixed timestep game updates, decoupled rendering, interpolated
- ECS based scene graph
- ECS based movement integration and interpolation
- Custom mesh format, binary baking, high speed load
- ECS based skeletal mesh animation
- Asynchronous asset loading
- Scratch built, flexible task-based concurrency system similar to MS PPL (tasks, futures/promises, then / when_all / when_any continuations, "thread affinity", thread pool)
- Deferred rendering pipeline
- OpenGL 4.1 core profile, GLSL, AZDO methods
- NanoVG UI overlay
- ADS lighting, FXAA, SSAO, sRGB and gamma correction, atmospheric scattering, linear depth buffer
- Stenciled skybox
- Planetary scale, handles floating point precision issues
- Embedded Lua FFI scripting
- Embedded HTTP server for browser-based tools integration (based on Lua Orbit)
- Spherical terrain, GPU tesselation for bi-cubic terrain patches
- ECS based FPS camera, "flyable" dev camera
- ECS based smooth character motion, head bobbing, crouching, running, walking
- ECS based screen shake system
- C++ reflection utility
- Multi-thread code profiling
https://github.com/y2kiah/icarus Icarus was a continuation of the Nebulous project in order to explore rigid body physics and realistic flight modeling.
- Realistic flight model including determination of derivatives.
- RK4 and Euler integrators.
Nebulous was a departure from OpenGL over to Direct3D 9 in order to further explore shader-based rendering pipelines the Effects Framework. This project was also an experiment in a heavily event-driven architecture. Finally, this was a testbed for research into fractal noise algorithms in order to drive procedural terrain generation.
- Direct3D 9 with Effects framework (.fx) rendering
- Process/job system for threaded tasks
- .zip based asset bundles, asynchronous loading
- Event system (observer pattern)
- Asyncronous asset streaming system
- Terrain clip-mapping implementation
- Fractal noise system including integer noise, coherent noise (linear, cosine, cubic, quintic, Perlin, simplex), fBm, and layered multi-fractals.
- Bicubic spline patches for terrain surface, CPU tessellation with caching
- Terrain patch occlusion culling and dynamic LOD
- Texture splatting
- Horizon-culling based terrain shadows
- Sky/cloud layer rendering system
- Blended transparent surface sorting
- Mesh instancing
- Command lexing and parsing with friendly error messages
- Integrated command console (similar to Quake)
Quickport was a portal rendering engine experiment to test the idea of a fast "2.5D" world authoring format in the same vein as Doom, but using full 3D rendering rather than raycast rendering. The dynamic lighting scheme used fixed-function blending of a circular texture projected onto each wall in the direction of the plane normal, scaled based on proximity, and modulated by color. At the time, pre-baked lightmaps were the norm and this was an attempt at fully dynamic lighting (before programmable shaders made that easy to achieve). Quickport also served as a testbed for a particle system, collision detection/response, and sound integration.
- Fixed function pipeline, OpenGL 2
- Dynamic blended lighting system
- Portal rendering algorithm
- Collision detection, wall sliding
- Particle system
- Simple, human-readable 2d level authoring format, extended into 3d similar to Doom level format
- FMOD sound for music
Ray was a project in 1994-1995 to learn the technique of Wolfenstein3D-esq ray casting. My engine was able to handle transparency and sliding doors. One feature Ray had that Wolfenstein did not was dynamic cell lighting with up to 7 shades of 32 colors on a 256 color VGA palette. Ray was written in DJGPP for DOS using the Allegro library.
Other Demos & Tools
Splines & Surfaces
- Research tools exploring Bezier curves, Catmull-Rom, cubic and higher order splines
- Bicubic surface tessellation using precomputed basis matrices
- Surface normal, concavity using 1st and 2nd derivative of curve equation
- Browser based frogger clone, just for fun
A-10C Cockpit Project
- Complete 3D CAD model built in Sketchup
- Embedded C++ and Python development on microcontrollers; Arduino (ATMega 168/368), Raspberry Pi 2,3, Beaglebone.
- NodeRED + MQTT protocol over ethernet for sensor network
Vertical Plane Simulator
- Tool for analyzing 2D (vertical plane) flight model of B767
- Inspired by software used in Flight Technique Analysis course
- Custom web application server for Windows built on Boost Asio
- Implements HTTP 1.1 protocol, limited 2.0 features, simulates CGI
- Lua integration for authoring application logic
- Lua pages (.luap) implementation