Rodrigo Holztrattner

This is my Vulkan rendering engine, a life project (at least I want it to be) for learning and developing my game-programming knowledge, on this project it is possible to find a resume of my capabilities when working with C++ and a graphic API, this isn't my first attempt to create a game engine but I expect this will be the one that I will use to build my dream game someday.

I started its development from scratch in 03/09/2018, I've put a lot of effort in making it an incremental project where I can treat each feature as a module, allowing me to easily add, replace, modify and remove functionality whenever I found it necessary.

You can find more info on its github page (see below). Some details about my implementation:

• It uses the Vulkan rendering API (Anvil library)

• Render passes generated using the deferred rendering technique

• Focused on multithreading, it uses my custom Peon library to create and manage parallel jobs

• Memory efficient, I try to use custom allocators (per-thread) for high intensive allocation/deallocation objects

• Independent update and render threads

• Hot-reload of resources when changes are detected

• Entity Component System (ECS)

• Custom resource system, it uses my Packet library to load, manage and edit files as resources.

• It uses a Render Graph that allows me to ignore the most boring part of the Vulkan API when creating render passes (creating it, configuring all inputs and outputs, setting the shaders and all remaining stuff can be done in less than 20 lines, all processed at compile time!)

• The font rendering uses the distance fields technique

• A huge map system in conjunction with a custom world coordinates component that resolve all the precision problems that a map like this could create

• Screen Space Shadowing, allowing cheap shadow calculations from the deferred info, without the need to render the entire scene multiple times for each light

• Screen Space Global Illumination Approximation, this includes the ambient occlusion generation and the second diffuse light bounces, both performed using ray marching, they add a more realistic feel to the scene and are cheap to calculate

• Overlay System that allows to easily create overlays on the engine without having to rely on the rendering pipeline, one major example in use is the ImGui library

A hobby project developed by me using C++ and OpenGL.

I challenged myself to create a simple copy of Sunless Sea, a game developed by Failbetter Studios that was originally built using the Unity Engine. Only the original game assets were used on my adaptation and the rest of the code and gameplay itself were developed by me using just C ++ and OpenGL in Visual Studio.

Some features about the project:

• Made using C++ with OpenGL (GLFW and GLEW)

• It has a partial deferred rendering system (for lightning and other future post-processing effects that I planned to add)

• It uses a 2D lightning system with point lights and directional lights (close to what the Sunless Sea game uses)

• Sprite animations (currently only the smoke animation when moving)

• A simple user interface, it is supposed to match the original game interface (currently only the speed control widget)

• Collision detection using bounding boxes with precise pixel fetch (because the game uses 2D sprites and it's easy to detect collision this way)

I worked on this project for 4 months during my graduation course on the university. It was a really nice experience but I had to focus on my final project to get my diploma :)

I made this project in 2015 during the BEPiD course (Brazilian Education Program for iOS Development, now called Apple Academy) and this was one of my attempts to create a game for IOS. It's basead on a Warcraft3 map called Battleships (take a look at this video), it's a "naval-DotA game" where the player must destroy the other team main base in order to achieve victory, the players have access to cannons (items they can buy) that auto-attack enemies in range, they can also change ships and learn skills while playing.

I was learning how to program in Objective-C (and after that in Swift) but I discovered the C++ feature of that language and of course I had to try it, it was a really challenge because I had other projects at the same time and I mainly worked on this 2 or 3 hours a week (at least I had an entire year).

Some features about the project:

• Implemented using Objective-C++ with OpenGL for IOS devices

• The map was made using hexagram models (for simplicity)

• Pathfind using a simple A* just to allow point and click movements (also this helped alot with the (minimal) AI that I added)

• A simple AI for periodic spawned ships from each side (take a look at the video for the battleships map)

• Functional cannon system, where the player uses a resource (gold) to buy more advanced cannons (items) that auto-fire at nearby enemies

• An inventory system for the cannons and for future itens like sails, hulls, etc (different ships had support for different inventory sizes)

• Multiplayer implemented with the lock-step technique (the game had a lobby screen), this was my first attempt to implement multiplayer on my own and I achieved some progress, but eventually I had some desync problems where one player had a different "vision" about the game from the others, I knew this happened because I used floating points everywhere and they aren't good for lock-step approaches (also random number generation here is a issue too)

Unfortunately I didn't upload a working version to git, neither I recorded videos about it (you will have to trust on my word and in the images at the end), also I don't own a macbook anymore so I can't check if the project is still working, the link below is from my google drive where you can find the entire xcode project in case you want to check it.

https://drive.google.com/open?id=1sZzeGfM8CkuFf8ysGUGZk3ceGJGgdp01

I used to name my projects using a dummy name like Wonderland, please ignore this fact (the real Wonderland project is the one at the top of this page).

A mini-game developed by me as a final project for the Computer Graphics Design class at university. It was developed in Unreal Engine and it was a simple spaceship arena game where the player must survive multiple waves of enemies that occasionally drop powerups.

Some key features:

• Developed using the Unreal Engine with some small additions using C++

• A really nice polished movement for the player ship (take a look at the video)

• The AI was simple but I implemented them using blueprints via a state machine

• I made a custom missile system with support for multiple types of missiles (homming, area damage, laser, etc)

The project is a little large and I didn't uploaded it to github, if you wanna take a look at the project please send me an e-mail.

One of my first DirectX project, it was a learning experience to get into the world of computer graphics and it was the door to several other projects. Mostly of its computation is done using a compute shader and the results are worthy of being used as windows 98 screen saver.

Some details (this is an old project and I don't remember too much about its implementation):

• C++ with DirectX

• Compute shader for the particle movements

• Multiple types of interaction