Current & Recent Projects
-Click any project image for more info-
Compute Shader Raytracing
Using compute shaders in Unity to ray-trace spheres and mesh objects onto a render texture.
Vulkan Renderer
I currently have 2 Vulkan renderers. One using the Vulkan Memory Allocator (Minecraft map), and another with the default allocator (Crysis Nanosuit model).
Direct3D Renderer
A renderer built using DirectX 11 following the tutorial series from ChiliTomatoNoodle on YouTube.
C++ Raytracing
An updated version of the software Raytracer built in "Ray Tracing In One Weekend" by Peter Shirley, including HDRIs for environment maps.
Co-op Stealth Game
The first game built from the UE4 mastery course on Udemy. This game features two players who must extract a valuable item without being seen.
"Space Bounty"
My space game framework being develop under the Half-Way Games name. It currently features a custom installer/launcher and GPU mesh editing and marching cubes.
Basalt Game Engine
Basalt is my early in development renderer/game engine using Vulkan and DirectX12. I plan to use this as a testbed for my learnings over the next few years.
Third Person Shooter
A third-person shooter project with pathfinding AI built in Unreal from the Unreal Engine C++ Udemy course.
Non-Euclidean Spaces
A prototype in Unity for figuring out how to create rooms that don't adhere to traditional geometric spaces.
Past Projects
-Click any project image for more info-
OpenGL renderer
My first step into learning about graphics programming and graphics APIs. Following the LearnOpenGL tutorials.
UATanks
My first completed project at UAT. This tank game featured split-screen co-op, multiple AI personalities, and procedural levels.
Hex Grid Map Editor
A real-time editable map painter that generates a hex grid mesh with biomes, elevation, and rivers. Built for an RTS prototype from the Catlike Coding series.
Ægir
My Student Innovation Project at UAT, Ægir was a tool for generating dynamic large-body water simulations with tons of user defined properties and depth-based trochoidal waves.
Top Down Shooter
Top down shooter project from UAT. It was my first project using source control and taught me about UI and animation. Its really only listed for archival purposes.
Project Techno
My semester long group project at UAT, simulating a "game studio environment". I was tasked with researching and adding networked multiplayer support and creating all of the project documentation/wikis.
2020 Demo Reel
Compute Shader Raytracing
This project uses compute shaders in Unity to completely ray trace a scene of sphere objects and/or triangle meshes. Thanks to the extreme parallelization of the GPU, it is a lot faster than my software raytracer in C++, but still takes a few seconds for an image to complete. In order to keep the program still running in semi-real time, only a single ray is traced for each pixel of the output image. To get a complete image, the results of each compute shader dispatch (from the same camera position) are accumulated into a single output texture which just gets more and more detailed over time as the image converges to cover all ray directions. This project was build following the 3 part series from David Kuri at Three Eyed Games.
Future Goals: Add in acceleration structure to trace against, such as a BVH.
Vulkan Renderers
I currently have 2 Vulkan projects from two different sources to be able to compare different Vulkan practices and better grasp what it takes to really implement it. The repo linked below contains the project I built following a Vulkan course on Udemy, which very closely follows the layout of vulkan-tutorial.com. The second, which contains the Minecraft map, was from vkguide.dev and taught me a lot about how Vulkan is implemented in the context of a game engine. My next big Vulkan related task is to implement it into my own game engine, Basalt, and begin diving into more advanced tasks.
Future Goals: Follow the vkguide for abstracting descriptor sets and separating a game thread from the render thread.
Direct3D Renderer
My Direct3D renderer uses DirectX11 and follows the Hardware3D series from ChiliTomatoNoodle on YouTube. I currently have the ability to load models and scene graphs and manipulate them at runtime using ImGui panels. This series has really taught me a ton, which I plan to utilize in my game engine, Basalt, and is what I refer to as my first steps into more "advanced" graphics APIs, as my previous experience had only been in OpenGL. Outside of graphics, this project also taught me a lot about software architecture and gave me a lot to think about when designing/planning a project.
C++ Raytracer
This project started out as following the raytracer from the book "Computer Graphics from Scratch" by Gabriel Gambetta but then I decided I would revisit "Raytracing in one weekend" by Peter Shirley, which I had followed early into my programming learning, before I was really able to understand any of the code I was writing. This second time through made a lot more sense and I was able to understand both the code and math behind raytracing much better. The project currently features spheres organized by a BVH with Lambertian, Metallic, and Dielectric materials. The scene also has the option to load an HDRI as a background environment map.
Future Goals: Expand the raytracer following the "Raytracing The Next Week" and "Raytracing The Rest Of Your Life" books, and then add in the software rasterizer from "Computer Graphics from scratch" as a second project in the solution.
Multiplayer Stealth Game
This Unreal project is the first game from the UE4 mastery course and features networked multiplayer (which Unreal makes surprisingly easy to implement a basic version of). The goal of the game is to try to steal and extract an artifact from the map without being spotted by the dwarven guards. If a player is spotted, the game ends. To avoid being spotted the players can distract the guards temporarily by shooting at walls or boxes. The AI in this project simply have patrol paths and spot the player by using an AI perception component.
Future Goals: Work on the second co-op project in the course
Space Bounty
Space Bounty is my space game framework for Half-Way Games. I refer to it as a framework because the project itself isn't a game, just all of the tools I would need to make a hypothetical space game. I'm still very early in development, only on milestone 4 of 27, but already have GPU marching cubes, mesh editing , and chunk octrees (for multi-resolution chunks on planets) included in the project. At the time of this writing I am in the middle of the resolution stitching milestone which involved a rewrite on the voxel density arrays for chunks (eliminating the seams between chunks of the same resolution as seen in the video) and implementation of the transvoxel algorithm to create "transition voxels" between changes in chunk resolutions. The chunk resolutions can be thought of as levels of detail for the mesh, the farther a chunk is from the camera the lower voxel density (resolution) it will have.
I have also created a custom launcher/installer for the project (which can be seen in the bottom image). The launcher is built as a WPF app that checks the project's git repo to see if there are any new changes compared to the version installed on the user's computer (or if there is a version of the game installed at all). It then downloads those changes on a background thread and displays the version name, number, and description to the user on the launcher.
Future Goals: To keep this list from being too long, I will just list a few of the upcoming milestones: Planet generation from 3D noise, Chunk saving & loading, and Flight mechanics (in vacuum)
Basalt Game Engine
Basalt is a project that have I wanted to work on for a long time, but never felt "ready" for it, because I foolishly thought that I would need to learn everything before starting. Luckily I came to my senses and realized that the best way to learn is by doing, and began working on the project. Embarrassingly, it was only a few weeks ago that I had my realization, so Basalt is currently very early in development. With that being said, I have already been able to learn a ton about game engine architecture and can't wait to learn more about rendering and graphics programming as a whole. Basalt currently has a logging library, a window abstraction away from the win32 API, an event system, and custom exception types. Like with Space Bounty, I have a bunch of milestones planned out for the engine and have really enjoyed working on it.
Future Goals: A select few of my future tasks are to: Create a graphics abstraction for Vulkan and DirectX, build an early version of an editor viewport, and implement basic scripting support.
Unreal Shooter
This was my first completed project in Unreal, it is a simple 3rd person shooter from the Unreal Engine C++ Udemy course from GameDev.tv (Unfortunately we never covered Unreal in school, so I hadn't had any experience with the engine before taking this course). The game features AI that will attack the player when in line of sight, and investigate the player's last known location when sight is broken before returning back to its guard post. This project taught me a lot about how animations work in the engine and introduced me to Animation blueprints, Skeletal Animations, Animation Blending and in turn, the Animations State Machines. To create the AI I learned about the Behavior Trees, which is a really cool system that works very well in the "Blueprint" node graph style.
Future Goals: I would like to utilize what I learned from creating the multiplayer stealth game to add co-op to this project. I think it would be really fun to increase the enemy count have a two-person team try to clear the facility.
Non-Euclidean Spaces
The Non-Euclidean space project was built as a prototype for a proposed Half-Way Games project before I began working on Space Bounty. The proposed project featured Non-Euclidean environments and "Quantum inspired" mechanics such superposition and entanglement, but unfortunately it has been put on hold until more members of my team have time available. This prototype features two "portals" which are just planes with a render texture and each portal has a camera that moves around its plane relative to the vector to the player. This system was built following the article by Ignis Incendio. As a side project to test my knowledge of Unreal, I have began attempting to duplicate the project there, since I have less experience with it than Unity, which we focused on in school.
Future Goals: Allow for teleporting through portals and finish porting to Unreal for a "knowledge test"
OpenGL Renderer
This was my first step into learning graphics programming my last year at UAT, my OpenGL renderer has model loading, vertex and fragment shaders, ImGui added, and a basic testing framework. All the information that I have learned is from the "The Cherno" youtube channel and the fantastic LearnOpenGL site.
UATanks
My first completed project while at UAT, this features 4 different AI personalities with designer specified attributes, seeded random tile placement & various level generation methods (level of the day, custom seeded, and time-based random), as well as Cinemachine split-screen co-op.
UATanks is a feature-complete project created in Unity, built for PC (but could easily have touch or controller support), utilizing the Cinemachine plugin for smooth camera movements. The AI system features 4 different personality types and a difficulty scaling system, which can be tuned by designers to change how the game plays. Each AI personality is its own class that inherits from a polymorphic base tank class that contains basic tank behaviors and stats.
Hex Grid Map Editor
The Hex Grid Map Editor is a prototype for the basis of an RTS game. This project features a UI that allows the user to change between biome types, elevations, river placement, and a scalable brush for painting multiple tiles. The hex grid utilizes runtime mesh generation to create and update hexes and chunks in realtime when interactively editing. The mesh features elevation transitions for blending between flat, stepped, and sloped (or cliff) neighboring cells. Rivers offset the middle vertices of cells to give them a depth relative to the surface. I created this project with the help of the in-depth tutorials on catlikecoding.com.
Aegir
Aegir was my student innovation project at UAT. Aegir is a scalable, tiled mesh generation, water system that utilizes compute shaders and physical particle simulations to represent reactive large body water simulations in any environment. Through an easy to use window, users can specify parameters for the system which can generate massive, tiled, high-vertex, meshes in just a few milliseconds. The meshes are then simulated using Gerstner(Trochoidal) waves in the surface shaders and physical particles are spawned and simulated on collisions and at wave crests using compute shaders. The system is set to adapt to any terrain a user has through a custom depth texture that can be generated when the mesh is created. I have plans to add mechanics for the"fluid" to flow after the core project is complete, this will most likely be done using vector fields which will generate at the same time as the texture to adapt to various terrains and landscapes.
Top-Down Shooter
Top-down shooter was a project that featured a lot of firsts for me in game development. Throughout the 5 week development period I learned about root motion, blend trees, inverse kinematics, pathfinding, UI, shaders and HLSL, and Audio Systems. All characters are animated using root motion animations from Mixamo and Arm/Hand IK unique to each of the different weapon types. Each weapon has a different shooting/spray pattern and customizable attributes.
This was also my first school project using source control, a link to the repo can be found below.
Project Techno
Project Techno was a group project at UAT. The game is a co-op rhythm racer where one player serves as the DJ having to hit "Guitar Hero style" falling notes in order to increase their partner's (the Driver) view radius. The Driver must avoid obstacles and other racers to complete the course.
When I joined the group much of the base functionality was already implemented and the game already worked for local co-op. I was tasked with expanding on the project by adding networked multiplayer, in order to complete this task I decided to use the Photon plugin for Unity. A few weeks into the project I requested to be able to generate some documentation as the codebase was getting pretty large. I figured this would serve as a good introduction to the project for newcomers and as a quick refresher resource for the other developers working on it.
Since I was the sole developer tasked with implementing networking functionality, I had to research, design, develop, and integrate into the main project, while other members were working on adding more gameplay content into the project. I also added the additional feature of allowing teammates (Drivers and DJs) to connect to each other over the network, meaning we could have a total of 8 remote clients connecting to each other in a 4 team race. Even though I worked on my branch by myself while the other members all had their own assignments, it was still a very collaborative environment. Between the different channels we had, there were at least a few messages sent each day. In our group, I was the only member of the team who wasn't on campus, so I didn't get to take on too much of a leadership role but I was still able to help a few different team members with issues in Unity. Through the creation of the documentation, I was also able to provide some assistance to members of the team, and those in non-programming disciplines could read the script summaries to understand why a game object had a certain script attached to it or what it was being used for.
In the following images, I don't show any of the game just parts that I worked on (excluding the title menu).
