Portfolio
Work Experience

NDA
Engineer Intern
2021

Hired as an Engineering Intern at Sledgehammer Games.

Programmer responsibilities:
- Prototyped wild life AI, stealth gameplay and user interface.
- Refactored old AI behaviors and flocking agents to work with upgraded game systems.
- Collaborated with designers and artists for feature requests and asset integrations.
- Supported project milestone success by adding missing features and fixing bugs in gameplay and core systems.
​- Participated in weekly meetings to showcase progress and gather input from teammates and management.​

Language: ​C++
Contract time: 4 months

Academic Games

D.A.A.
Gameplay Programmer
2021

Programmer responsibilities:
- Improved visual fidelity by working on shaders and visual effects for the game (Corruption Zones, Damage Overlay, and more).
- Developed camera shake system to improve game polish.
- Developed and integrated intro and end game cinematics.
- Collaborated with team to improve player experience and the game loop.

Platform: Windows
Engine: Unity
Language: ​C#
Team Size: 12 members
Development time: 8 months (Joined mid-way)

Arc Apellago
Engine & Gameplay Programmer
2019 - 2020

Traverse the sky in this open-air platformer featuring elegant, fluid movement and swift combat. Play as a mysterious assassin-like wielder of spirit energy to strike down enemies, restore the great guardian statue and return the land to the earth.

Arc Apellago was my sophomore year game project at DigiPen. It was a great learning experience and I enjoyed my time working on it!

Programmer responsibilities:

- Collaborated with game designers to implement player movement, player attacks, and enemy AI.
- Implemented game asset hot loading improving development pipeline efficiency by 100%. (Sprites, Animations, Textures and Shaders).
- Developed in-game resource management system using data serialization.
- Empowered artists with custom sprites and frame-independent animations systems.
- Developed shaders and visual effects improving game polish (Trees, bushes, damage filter, and parallax scrolling).

Other responsibilities:
​
- Oversaw production through self-hosted GitLab repository, performed hiring processes and managed team using agile methodologies.

Platform: Windows/Linux
Engine: Custom
Language: ​C++
Team Size: 12 members
Development time: 8 months

DeltaBlade 2700
Gameplay Programmer & Producer
2019

Fight as a Rogue Cyberpunk Ninja-Robot in DeltaBlade 2700: an Action-Packed, High-Energy, Competitive Local Multiplayer Brawler with Explosive, Fast-Paced Sword Combat... and Jetpacks.

Deltablade 2700 was developed during my second semester at DigiPen. It was an amazing experience to work with such a passionate team and see our game published on Steam!
​
Programmer Responsabilities:

​- Implemented player movement, collision, hurt/hitboxes, and state machine.
- Developed 2D lighting and dynamic shadow mapping using GLSL and batched shadow data improving performance by 50%.
- Improved graphics quality of the project by implementing visual effects and shaders.
- Assisted in the completion of Steam’s technical requirements to publish the game.

Producer Responsabilities:

​- Oversaw game production with monthly sprint meetings throughout development.
- Coordinated production for programming, audio and art.
- Managed and shipped the project successfully through various milestones and deadlines (PAX, and Steam).

Platform: Windows
Engine: Custom 
Language: ​C
Team Size: 10 members
Development time: 8 months

DeltaBlade 2700 at the 2019 DigiPen Arcade PAX West booth.

Gunslinger
Gameplay Programmer
​2018

Gunslinger is a reaction gun duel game that was developed during my freshman year at DigiPen Institute of Technology.

Responsibilities:
​
- Developed frame-independent camera, and animation systems.
​- Implemented slow-motion game mechanics.
- Guided gameplay design, and directed game polish.
- Led sound effect implementation.
 
Platform: Windows
Engine: School's Framework
Language: ​C
Team Size: 4 members
Development time: 3 months

Open Source Projects

CSYS
Cross Platform C++ Console Library

CSYS is a console library that aims to provide all the underlying systems/features a console would need (i.e. auto-complete, commands, etc). This was a summer project developed in collaboration with Tristan Bouchard. 

Responsibilities:
​
- ​Implemented full and partial auto-complete using ternary search trees achieving high performance.
- Implemented command history, script support and command logging functionality.
- Led test driven development writing 110 unit-tests with 80% code coverage.
- Managed continuous integration, build system and unit testing to ensure library correctness and stability.

What I learned:
- CMake - Build system
- Travis/AppVeyor - Continuous Integration
- Doctest - Unit testing
- Ternary Search Trees - Used for auto-complete

​Platforms: Windows/Linux
Language: ​C++
Team Size: 2 members
Development time: 3 months

ImGui Console Widget

A Dear ImGui Console Widget built with CSYS. ImGui-Console started as a example/test project for CSYS and something I wish our team had when developing Arc Apellago. I developed all of the features below:

- Smart scrolling, command timestamps, command log filtering and colored console output.
- Console settings and visuals are preserved through sessions.

If you wish to see ImGui-Console in action there is an example executable in GitHub!

What I learned:
- ImGui - User Interface
​
Platforms: Windows/Linux
Language: ​C++
Team Size:  Solo
Development time: 3 months

Academic Projects

3D Graphics Engine

A 3D OpenGL Graphics Engine built through out DigiPen's 3D graphics courses (CS250 and CS300).

Features:
- Phong and Blinn-Phong Illumination Models.
- Point, Spot, and Directional lights.
- Spherical, Cylindrical, and Planar projections.
- Light attenuation and distance fog
- Dynamic Environment Mapping..
- Reflection, Refraction and Fresnel.
- Affine Math Library.
- Perspective 3D Camera.
​- OBJ Loader.
- Normal Visualizer

APIs: OpenGL, GLFW, Glad, and ImGui
Platforms: Windows/Linux
Language: ​C++, GLSL
Team Size:  Solo
Development time: 8 months

Hybrid Graphics Engine with Spatial Data Structures

A 3D OpenGL Hybrid Rendering Engine built for DigiPen's  Advanced Computer Graphics class. 

Features:
- Deferred Rendering and Forward Rendering Support.
- Phong and Blinn-Phong Illumination Models.
- Dynamic Octree and BSP.
- Serialization support for Spatial Data Structures.
- Implemented GJK Algorithm for Collision Detection.
- Robust Geometry Toolbox for primitive intersections (Ray, Plane, Point, Sphere, AABB).
​- Multi-threaded asynchronous model loader.
- Perspective 3D Camera.

APIs: OpenGL, GLFW, Glad, and ImGui
Platforms: Windows/Linux
Language: ​C++, GLSL
Team Size:  Solo
Development time: 4 months

Hierarchical Modeling and Skeletal Animation

A group of projects for DigiPen's Advanced Animation and Modeling. Built/expanded from my Hybrid Graphics Engine with Spatial Data Structures project.

Features:
- Animation interpolation using multiple methods (SLerp, NLerp, Lerp, etc) with custom quaternion implementation.
- Support for incremental Lerp and SLerp for performance improvements.
- Hierarchical structure representation of bones (Skeleton).
- Hierarchical transformation and concatenation using quaternions and VQS for memory efficiency.
- Custom Key Frames, Clips, and Animator structures.
- Model and Animation loader supporting multiple file formats.
- Animator skeleton visualization.

APIs: OpenGL, GLFW, Glad, Assimp, and ImGui
Platforms: Windows/Linux
Language: ​C++, GLSL
Team Size:  Solo
Development time: 4 months

Animator and Skeleton

Curves and Surfaces

A project showcasing parameterized polynomial curves and surfaces with a view toward applications in computer graphics. ​Built for DigiPen's MAT300 class.

Sub-projects:
- De Casteljau Algorithm for Polynomial Functions.
- De Casteljau Algorithm for Bezier Curves.
- Interpolating Polynomials.
- Interpolating Splines.
- De Boor Algorithm for Spline Functions.
- De Boor Algorithm for B-Spline Curves.

APIs: OpenGL, GLFW, Glad, and ImGui
Platforms: Windows/Linux
Language: ​C++
Team Size:  Solo
Development time: 4 months

A* Pathfinding

A project showcasing optimal A* pathfinding built for DigiPen's CS380 class taught by Steve Rabin. Built using a AI framework provided by the class.

Features:
- Optimal A* Pathfinding supporting path smoothing and rubber-banding.
-  Heuristic distance calculation using Euclidean, Octile, Chebyshev, and Manhattan.

Platforms: Windows
Language: ​C++
Team Size:  Solo

A* Pathfinding - Single Step View Mode