The Libero Engine [3D]

My most recent project. Coded in C++ - Visual Studio 2020. This is a 3D-rendition of my previously made 2D-Engine.
It provides me with the perfect sandbox to learn about various elements of Game-Engine Development. The main challenge would be that it's programmed in the ECS(Entity-Component-System) system-flow, in which all data is Components and Entities in the world are merely ID's.

The Engine uses:
- DirectX11 for rendering
- ImGui for Editor & User-Interface.

The Libero Engine [2D]

This project is my first attempt at a self-made Game-Engine. It is coded in C++ - Visual Studio 2020, and only supports 2D rendering.

In this engine, I remade a beloved arcade-classic 'BubbleBobble' to test out the functionality of the engine. The engine is built using a lot of Game-programming Design patterns such as 'ServiceLocators', Without a doubt the engine has a lot to improve upon. But while working this project I learned valuable skills & techniques that made me understand and appreciate how a Game-Engine works and is built even more.

Stikboldt!

A game I created in 'The Overlord Engine', a small Game-Engine that at first, implemented a basic DX11 framework, but had close to no rendering capabilities. So I added various missing elements such as:

- Basic Diffuse materials
- GPU Skinning (using the Vertex Shader)
- 2D-UI-rendering & Text-Rendering
- Post Processing [Vignette, Grayscale]
- Particle Effects

All of which would call onto the Graphics API of DirectX via Visual Studio C++ code, to render them on screen;

Git

CPU Rasterizer

This software-based-rasterizer became one of the first demo-projects to help me get familiar with the DirectX-rendering-pipeline.

However, the project is not a hardware-renderer calling onto the DirectX API, but a software-based renderer that makes the CPU shade every pixel after another. With a system that tries to mirror the DX-renderpipeline.

The program allows for viewing a mesh in multiple viewtypes:
- Materialmode
- Depth-buffer visualisation
- Surface-Normal visualisation
- ...
On top of that, I applied what I learned about shading during my work on my custom-raytracer, to implement PBR-materials, as well as the basic Phong-specular BRDF added to a simple Lambert-diffuse BRDF.
After I was somewhat satisfied with the work I did, I also added some camera-functionality, some background-rendering & interactive-UI-rendering.

Git

My Custom Raytracer

This is a small demo-project for rendering basic mathematical 3D-shapes (such as spheres, cubes, triangles), and also delivers on rendering a triangle-mesh, parsed from a .obj file. Making the CPU render every pixel in succesion, made the basic concept of how raytracing works more clear.

It served a good lesson on not alone programming, but also basic-math about how light shades 'pixels' in the real world (PBR materials), and just as important, how the pixels that would not be touched by the lights would have to be shaded.

Finally, after getting a somewhat pleasant result, I tried my hand at some optimization-features on rendering meshes, such as boundingspheres that enabled the 'pre-culling' a healthy amount of rays that were 'obviously' not going to hit the mesh.

Git

PolyBusted!

This was my first experience of working in a semi-professional work-ethic, where I, together with 2 talented artists had to create a game concept, prototype it, and later on, once the development phase came to pass, we had to create our 6-week stretching sprint planning to make every hour of our 'work-day' count.

The game is a 4-player robot-wars inspired arena game in which try to collect scrappy parts that spawn in the arena, and use them a couple of times before they innevitably fall off again. This then makes for opportunity for other players to try and steal it, in order to get the upper hand.

Due to circumstances I ended up being the only programmer of our team pretty early on in development. This meant we had to shrink our production-scale down a bit in order to be able to actually deliver a finished product.

[The game supports only controllers, and was built for Windows with the game requiring of 2 - 4 players joining]

Tower Defense!

This small tower-defense game was one of my first projects made in the Unreal Engine 4. After first getting familiar with the visual scripting language Blueprints, I later on shifted towards trying out the C++ scripting featured in the engine.

It also proved to be a relatively small test of my AI-programming skills, as enemies were required to attack towers, but once dealt enough damage, had to chase the player untill that was no longer worth their time. As they were very busy of course trying to get to the core castle of the player, rather than the player him/herself.

Itch.io

'Mad Max' Lowpoly Robot

A lowpoly robot on which I learned the complete AAA-Game-Asset production pipeline.
From unwrapping, to rigging, to baking and adding PBR-materials.
This Mad-Max themed mech taught me the power of baking normal maps, making the use of high-poly-looking quality assets possible in games.

Sketchfab

Lerna Level-Design

From designing and blocking out a level, to creating modular assets for optimizing re-usability,
this project did put my 3D-modelling and unwrapping capabilities to the test, as well as increasing my knowledge on
PBR-materials and how they were used in AAA-quality-games.

Trailer