Game Libraries (Q4)
Lab 2: Shaders
The first successful implementation of drawing colored triangles to the screen with OpenGL and GLSL
Lab 3: Bouncing Quads
Taking the triangles a bit further, and adding some logic to them, I managed to get several quads bouncing around in screen-space in this early version of my game engine.
Lab 4: A New Dimmension
Passing data around the engine in new ways and toying with the OpenGL state allowed me to draw 3D shapes in my engine!
Lab 5: FPS
At this point, framerate-dependent movement was starting to become a noticable issue with window resizing, so it was time to get the system time and calculate the delta times to pass around for framerate-independent object motion. It was also useful for calculating FPS.
Lab 6: 3D Space
Adjusting shaders to allow for objects to be placed in 3D space in a better way and moving the objects around a bit.
Lab 7: Camera
Adding a camera to view the moved objects from other angles, and thus exist inside our world.
Lab 8: Collision
Simple bounding box/bounding sphere collisions with the camera and object allow me to finally make a simple game in my engine! It is very simple. Find the house in the giant box of shapes to win. [Cannot be run in-browser, contact me if interested in seeing]
Lab 9: Obj Loading
Oh finally, not having to type vertices by hand to render shapes on the screen! I manually parse data from .obj files to get any shape in my engine and demo it with several models!
Lab 10: Textures
With model loading then comes the desire to load textured models. Passing around some UV data, loading textures into OpenGL and writing more GLSL shaders allows for much better-looking models!
Lab 11: A New Scene
Upgrades to model loading, configuration files, the demo world, shaders, etc, allow for a new experience to be had.
Lab 12: Lighting
Writing a Phong shader in GLSL, passing around normal data, and creating a demo scene allow for things to start looking even better.
Lab 13: Entity Component System
Refactoring much of the game and engine to support entities and components make coding a flying dragon easier and cleaner while giving us more future potential and freedom for expansion upon the game.
Lab 14: Raycasting
The ability to check if a ray touches a triangle is a very handy thing to have into a game. It can be seen in this assignment by firing red blocks that stick to the walls.
Lab 15: Spatial Partitioning V1
Even a simple spatial partitioning scheme is better than none. One is implemented here, allowing far more rays to be cast, and, through this, our dragon to breathe fire and destroy blocks.
Project Tech/Algorithms
- C++
- OpenGL
- .obj File Format
- GLSL (OpenGL Shading Language
Extended Details
This was the course for which game development students were first required to make their own game 3D game engines. It was a difficult course that covered a lot of ground. My engine literally went from drawing two triangles to implementing raycasting and spatial partitioning in a 3D world with lighting.
My game engine was written in C++, using OpenGL. We were encouraged to do as much as we could from the ground up. That means our own memory management, writing our own GLSL shaders to do phong lighting instead of using what was built in, and much, much more.
Project Credits
Justin Furtado (Me) - More Projects By Me