Julia Daxenbichler.

I worked on Bus Bound from the very beginning of the project. For the spiritual successor of Bus Simulator 21, we wanted to really make the city shine, and of course, the roads are an important part. I spent lot of my time working on this project on creating the "RoadTool 2.0", an overhauled version of our existing tooling. Besides adding tons of new features and UX improvements, I completely remade the procedural road generation logic in Houdini, and added road-specific Houdini tooling in UE.

I also implemented a bus customization system where the player can pick different colors and patterns from color palettes, which can also be unlocked during gameplay.

At one point, it became evident that the traffic lights were often not visible enough, given that they are placed on the far side of a junction in the US. Hence, during some slack time, I implemented traffic light and car indicator "glints" to enhance visibility. These glints were based on billboards, with some visual effects to make them look more appealing.

Originally, the dynamic navigation route for the player was displayed as a continuous line on the ground. However, this line drew too much attention away from the rest of the game, and flickered between lanes a lot if multiple lanes lead to the target. I replaced the continuous line with procedurally generated navigation arrows on the ground, with the spacing depending on the road speed limit and upcoming points of interest (e.g. junctions), and displayed all available lane options to make driving more relaxed and intuitive. I also colored the arrows red if a lane was currently affected by a red traffic light or a traffic incident (e.g. accident), which further improved the issue of traffic light visibility.

The mirrors of the buses have always been a performance challenge, having to render the scene multiple times using Unreal's not-very-optimized scene capture system. With the introduction of Lumen, GI reflections became an option, but the accuracy required for bus mirrors would come at an unfeasible performance cost. However, for this type of game, the most important objects in the reflections are cars; the rest of the environment does not need to be as detailed. So I experimented with a hybrid mirrors system, where objects of interest are rendered in high resolution using a scene capture, and the rest of the environment is displayed at a lower resolution using Lumen reflections. The system was ultimately not used due to some visual artifacts, but with some more love I think it could become a real alternative!

Bus Simulator 21 was the first project that I worked on when I joined stillalive studios in 2021. Back then, the game was close to its release date, and had some bugs and performance issues that needed to be ironed out.

One of my first contributions was several fixes to the foliage visuals. For example, I fixed a bug with the foliage wind sway material when the wind parameters changed abruptly, and added the wind sway to the foliage impostors as well.

I also created a tool for automatically generating road signs. Roads could be tagged with names using bounding boxes, and road signs were automatically generated and oriented at junctions. This tool also taught me an important lesson: Make the prototype visuals as ugly as possible, otherwise they will not get replaced! ;)

Nearing the end of the project, I was also involved in GPU performance profiling using UE tools (e.g. GPU profiler, Unreal Insights) and RenderDoc. Foliage was a big issue, as well as lighting and decals. I experimented with some settings and compared tiled vs. clustered shading for different reference locations in the world. I also fine-tuned LOD settings on the foliage, batched lights where appropriate, and adjusted the settings on the bus mirror scene captures. Lastly, I did some debugging on devkit consoles.

Tram Simulator started out as a DLC for Bus Simulator 21, and was eventually developed into its own game. This project made use of a "faux hole" shader that I originally developed for the construction sites in Bus Bound. This shader can render holes in the level geometry without having to modify the underlying geometry. This makes it useful for "holes" that appear dynamically during gameplay. All you need is a mesh that defines the shape of the hole, and a definition of a surface plane. In Tram Simulator, this shader was used for the tram rails. The surface planes were calculated in Houdini, where the rails are generated, and stored in the mesh's vertex colors.

Neophyte (or mossfight, as I like to call it) was an attempt to revive a cancelled project. The original vision for the game was a fast-paced co-op first-person shooter where the players have to fight a dangerous material that spreads across the level when uncontrolled. After the project's cancellation, I was tasked with finding a way to make the spreading mechanic into a fun game, which proved to be a challenge!

Before the game was cancelled, I created the game's modular equipment system. Each equipment item is defined not by a Blueprint or a C++ class, but a definition data asset. This allows designers to compose different modules to achieve the desired behaviour, with the modules themselves being created by coders. Examples for those modules include "spawn a projectile burst", "trigger cooldown", or "play an animation". The definition assets are also validated upon saving to catch any logic errors as early as possible.

To decorate the gameplay with some "richer" interactions, I also implemented a minigame interaction system. A minigame in this system could be something like a quicktime event, or a game of Snake. Using Unreal's Enhanced Input system, the minigame system is built to ensure that no inputs can ever "leak" into the main gameplay, something that happens all too often in a lot of games. Furthermore, I added a dodge mechanic to the game as an opportunity for player skill expression.

I also tried my hands on an efficient volume texture generator. This generator was used to voxelize "cells" in the spreading simulation, and pass the data to a Niagara particle system in the form of a 3D texture. This texture was generated in the space of the player's view frustum, efficiently filling the entire texture space and, due to the even spacing in view space, providing LODs as a neat side effect. This allowed the system to batch together all visible emitters of the simulation, since individual particle systems generate a lot of overhead. Unfortunately, the substantial overhead from Unreal's scene capture system resulted in the generator not being used.

I could list all of my other contributions in detail, but I will spare you the wall of text, and instead just list them here. I implemented a 3D map view, a status effect system, a movement parameter override stack, and a score calculation system. I contributed substantially to the difficulty system, incapacitation state machine, visuals of a stream-based weapon (think garden hose), and refactoring of the interaction system.

As a huge cat fan, of course I had to volunteer for this project. What came out on the other end was a cute little demo for a cozy game where the player takes care of their customers, prepares orders, customizes their café, and most importantly, rehabilitates stray cats.

When starting on the project, I envisioned a game where the interaction with the cats feels rewarding and believable. So when I had some slack time, I created an animation blueprint to make the cats react to the player, based on each cat's individual preferences. Sammy might lean into your hand when you scratch his cheek, but Nelly might dodge and hiss! I then brought these mechanics into the game by programming a minigame system. This system was then also used for feeding cats, playing with them, and preparing orders.

I also created a node-based relocation system, where customers and cats can move between nodes while the player is not looking, based on customizable criteria. (If a cat wants to be rehomed, it sits on a customer's lap!)

Remnants was my team's graduation project for our Bachelor's degree, and my first experience with the Unreal Engine. The game combines classic shooter mechanics with a twist: Elemental gems, which can be collected throughout the game, influence the behaviour of the projectiles. The four base gems - fire, earth, water and air - can also be combined to explore a total of 10 completely different projectile types.

The game was created in UE4, using both C++ code and Blueprints. My contributions include a savegame manager, scene management system, inventory system, gameplay programming and UI design. The game is available on Steam.

Incendarius was my team's graduation project for our Master's degree. Cayn, the main character of the game, must solve a range of fire-based puzzles in his sleep to cope with his dark past. His fire magic has the power burn down obstacles, but it can get out of hand...

Incendarius was created in UE4, using both C++ code and Blueprints. My main contribution was the underlying C++ temperature system, which is similar to a spring system in nature. This also included linking the temperature system to the puzzle system, creating state machines and behaviours for flammable and explosive objects, and visual effects (Niagara particles). Additionally, I was responsible for the savegame system and scene management, as well as some general gameplay programming. I also created much of the UI, including the design and logo, and took on some minor art tasks, like the design, modeling, rigging and animation of the Bomb Snail.

Incendarius is currently available only on itch.io. We consider this release "Episode 1" of the game.

This two-player game was created during a 48-hour game jam using Unity. Each player controls two points of a long, wonky tongue. They can use this tongue to lick their favourite "flavour orbs" that appear randomly on the surface of a sweet treat.

I was in charge of creating the tongues, which are generated using a physics joint system and procedural mesh. I also created the logic for orb spawning and most of the UI. Since orb spawning, level UI generation and color classification are fully procedural, new content can be added very easily. After adding a mesh asset, the only required step is to manually define two target player colours that appear on the mesh.

B⬠keh was the first game that I developed during my time at the FH Salzburg. The user needs to find the pentagon among many hexagons to proceed to the next level. I relied heavily on HTML5 and CSS3 for the effects. The game logic is written in JavaScript. Click the button below to launch the game!

This website was developed by me, using HTML/CSS and JavaScript, along with a bit of Photoshop and Python.

This project was created during an AI course at the FH Salzburg, using Unity and C#. A lost raptor is searching for its mother using goal-oriented action planning, and you can tweak the parameters of the world to manipulate the simulation. The AI must avoid hunger, thirst and injury by scavenging, exploring, hunting and avoiding enemies.

FlyCycle is a VR gamification project that aims to make cycling on a stationary bike more fun. The project makes use of an ergometer and a VR headset. The player can control the speed and altitude of the flying bicycle by pedalling, and steer by leaning to the side. Points are gathered by flying through floating rings while avoiding obstacles. The greatest challenge of this project was parsing and interpreting the ergometer's output sent through the serial port interface.

This mobile game was developed during a mobile development course at the FH Salzburg, using Android Studio and C++ with a bit of Java. Two colored planets can be touched to form a laser beam that destroys all enemies of the same colour that come in contact with it. As a fun exercise, an efficient - albeit quite limited - particle system was implemented for the explosion effects. This allows the game to display millions of particles on mobile systems.

This project was my Master's thesis. I explored a new approach to light field rendering based on a 2019 paper. While this paper uses a neural network to segment input images into "depth layers", I decided to go a different route and generated a synthesized focal stack from a sparse set of input images. From this focal stack, the depth layers can then be extracted. All this is done efficiently in CUDA, consuming less time and memory than the learning-based approach (at the cost of somewhat lower image quality). You can download the paper by pressing the button below.

One day, you - a goldfish trapped in a fish bowl - decide that you've had enough. You jump out of your bowl, only to find that moving on land is is harder than it seems...

This project was created during a game engine development course at the FH Salzburg. The 2D engine, including a physics engine, SFML-based renderer and simple particle systems, was developed in C++ using SFML and TGUI. Besides creating approximately half of the game engine, I was responsible for creating the navigation logic. This included defining the different height levels of the objects and transitions between them. I also designed and implemented the AI of the enemy cat and integrated some (mostly self-made) graphics and sounds.

Aska is based on a game concept my team developed back in school for our final year project. This simple 2D scrolling shooter, which I developed in my first year at the FH Salzburg, was my first C# game ever! I used MonoGame as a basis, and the programming and sprites were all done by me. No sound or animations, unfortunately.

Robot Rodeo was developed during my second year at the FH Salzburg. One player controls a robotic bull, and the other has to hang on for dear life...

This was my first Unity game, counting out tutorials. The game was developed mostly via pair programming, so I did not have many exclusive tasks. I did, however, create the bull and robot 3D assets, some of the UI, and a funky GLSL shader for the battery display on my own.