Kent's Portfolio

(xyz)^0

About

(xyz)^0 is a math-themed first person shooter.

The goal of this project was to learn how to make a game from scratch by using C++ and OpenGL.

Retrospectively, I have learn a lot of new things and have increased my understanding of how game engines work internally.

Overview

Tools

C++, OpenGL, GLSL, visual studio

Role

Co-Owner, Programmer

Team size

Timeline

Aug 2024 - Nov 2024

Links

Notable Tasks

Topics

Behavior Tree System

example of the boss utilizing the behavior tree system

After learning how a behavior tree system works from a previous project, I wanted to utilize that knowledge and recreate it in our engine so that I can use it to make a boss.
So I spent a week to learn the system and made it as modular as possible.
After that, I used it to make the boss and it was super convenient. It was also used for animations like the pillars that the boss creates in all the states (red, green, blue and healing state).

Code Samples

Floor grid & wall grid

showcasing getting a cell position from a wall grid

Both the floor grid and wall grid has functions that can get specific cells based on the arguments passed in.
These functions are useful especially for the boss attacks (blue wave attacks and red pillar attacks).
In the case of floor grid, users can get the cell center position based on its world index.
So if I pass in (5,0) with a cell size of 1, it would return (5.5, 0.5) as the cell center's world position.
To get wall grid cell's coordinates, it's a little more complex as I wanted to grab a cell's position that can be used for spawning healing cubes (for healing the boss).
So what I did was figuring out an algorithm that can get a cell's position based on an angle.
As you can see from the video, wherever the ray (adjusted using angles) touches, it returns the cell's position correctly.

Code Samples

OBB collision with SAT algorithm

OBB collision between two objects. Red means they are overlapping.

Initially, we agreed to have simple AABB collision checks as it was straightforward.
After a bunch of testing, it felt that it was time for an upgrade. So I did some research and found out that OBB (Oriented Bounding Box) with SAT (Separating Axis Theorem) was a good choice as it accounts for rotation.
Since we already had the base structure that OBB and SAT require (a transform class) to make it work, implementing it was fairly quick.
And thanks to Robin's code structure for checking collision, swapping out AABB with OBB was quick and smooth.
Side note: Currently, the collisions doesn't support sweeping detections, which would help preventing "phasing" through objects.

Code Samples

OpenGL & Graphics programming

floor grid with custom shader for displaying lines with the appropriate color

This is my favorite part of the project as I get to learn about the components that are required to render things to the screen like Vertex Arrays, Vertex Buffers, Buffer Layouts and Shaders.
Thanks to TheCherno's videos and Learn OpenGL website, and also my previous experience of making shaders in Unity, it made learning about this topic a lot easier.
For the floor grid, wall grid and heal rays, I utilized OpenGL's line drawing functionality to handle drawing lines. And, they all have separate shaders that handles rendering the lines differently.
For example, I wrote a shader specifically for the floor grid that takes in the world position of the points so I can change the fragment color to X and Z axis colors (red and blue) if their positions lie on the axes.

Code Samples

tinyobjloader

showcasing different types of models imported into the game

So, we got a basic cube rendered on screen that was made from a float array filled with vertices data. Perfect!
But what now? What if we needed more complex mesh? Like perhaps a teapot? Or a bun?
We can technically construct it out of float arrays but unless we're geometry geniuses, we need the help of a mesh loader.
So we did some digging and found two libraries - assimp and tinyobjloader.
Both me and robin decided to go for one each and I chose tinyobjloader.
After reading through the documentation on their Github repo, I attempted to extract a mesh data using it.
It was tough. I had only little conception on what data a mesh contain and the terminologies they used were unfamiliar to me.
After a day of trial and error, I got it working and it became the foundation for mesh loading in our tiny game engine.

Post-processing and Framebuffers

difference between before and after outline post-processing

After having enemies that can move around and chase the player, it grew harder to tell if an enemy was closer than the other.
And one solution I thought would be very fun to implement was outline post-processing which highlights edges of a mesh.
So I decided to learn how to use OpenGL's Framebuffer feature which can be used exactly for this purpose!
Throughout the process, I followed an article by Roystan on how to make the outline shader in Unity and managed to convert it to GLSL.
Because of the extra requirement of depth buffer and screen-space normals, I had to refactor the basic mesh shader to output a depth texture and a screen-space normal texture on top of the default fragment color.
This process has taught me a lot about Framebuffers, depth buffers and screen-space normals. And it was after this, I start to understand why game engines have render pipelines as it can help organize the rendering order of objects.

Code Samples

Reflections

The whole project was a blast to make and it has taught me so many things that I wouldn't have learned elsewhere.
After this project, a lot of dots were connected especially when it comes to graphics programming. Concepts like render pipeline, render textures, passes, post-processing, materials in Unity now made a lot of sense to me.
On top of that, I come to appreciate game engines more as I got a glance of the lower-level programming that makes an engine possible. It gave me a better understanding on why features in game engines are made they way they are.
One thing I would definitely want to improve on is learning how to organize the codebase better for a local game engine, especially in C++. I have a lot more to learn when it comes to the language itself.
Lastly, a big thank you to my teammates for bringing the game to life. They are all talented and I enjoyed working with them a lot.
Thank you for reading about the project development journey :)

Kent Chua