Rendering Bel's Fanfare

January 31st, 2026
Bel's Fanfare

Motivation

In Bel's Fanfare, our biggest inspirations are the Zelda games from the N64: TLOZ: Ocarina Of Time and TLOZ: Majora's Mask. The art direction of this project was very clear and specific from the very beginning. It was not about recreating the look of those N64 games as they actually were, but about how people remember them, which is why we looked at the Zelda remasters from the 3DS instead. In this article, I will explain the lighting techniques used in those games and our approach to replicate them in the Unity Engine.

A look at the past

In the past, most games relied heavily on baked lighting because it was necessary to depict complex scenes in realtime. When we think of precalculated lighting nowadays, we think of lightmaps. However, many games had their lighting baked into vertices instead. It required less memory, shorter baking iterations, and offered better performance.

Take a look at a scene from TLOZ: Skyward Sword for example. Lighting is very smooth, without hard shadows. You could almost believe that it is just good texture work.

However, thanks to the website noclip, we can disable textures and uncover the truth:

Indeed, it's all just good old vertex colors. It is hard to put into words just how much baked vertex lighting contributes to the final look of older Zelda games. For instance, take a look at TLOZ: The Wind waker. It's a cel shaded game, surely it is just hard lights and cartoony textures, right?

As you can see, vertex color is used to add shadows and ambient occlusion to the scenes. It is completely essential to the game's art style as it would otherwise look much flatter, especially in interiors. However, it is so subtle and smooth, that it can easily go unnoticed.

While vertex colors had already been used in older Zelda games, I think they reached new heights in the 3DS Zelda remasters. Take a look at these images from TLOZ: Majora's Mask:

As you can see, vertex colors are not just used to add a bit of depth to the scene. Direct and indirect lighting are masterfully baked into vertex colors in these games, which greatly contributes to their characteristic look.

Implementation

Since the game is being developed in Unity using the Universal Render Pipeline, the entire lighting system had to be implemented from the ground up taking into account how its results would be injected in the pipeline.

There were two different lighting phenomena that were required:

• Ambient Occlusion: An estimation of how occluded a vertex is taking into account only its surrounding geometry.
• Lighting: A combined result of all the colors that reach a vertex from all lights, weighted by distance.

While I initially implemented a baking algorithm that ran in the CPU, it was soon clear that it didn't scale well when using large meshes and many lights. We are a small team, so we couldn't afford to waste hours looking at a progress bar. We needed a way to see how assets would look in-engine fast. To achieve that, I reimplemented the entire algorithm to make use of hardware ray tracing. This change allows us to bake all lighting and ambient occlusion in an instant by pressing a single button. While hardware ray tracing is usually associated with high-end graphics, it can actually be used for anything, including an editor tool to bake per-vertex lighting.

Once lighting and occlusion are calculated and stored as vertex colors, a custom shader is employed to abuse the emissive property of materials by adding baked lighting to it.

If you're interested in reading an in-depth explanation of these systems, last year I wrote a couple of articles in which I detailed how I implemented both Vertex Ambient Occlusion and Vertex Lighting.

Integration of dynamic objects

While baked lighting looks great, it can only be applied to static meshes. How dynamic objects are lit is just as important though. In our case, we have a system that generates realtime lights that match their baked counterparts. These lights use a culling mask to affect only dynamics objects such as characters. Additionally, we have configured the render pipeline to use vertex lighting to better match the 3DS Zelda games.

Results

Conclusion

To be honest, I didn't find the idea of reproducing 3DS graphics on modern hardware attractive at first. However, I ended up enjoying the process a lot and also learnt a few things about lighting and geometry along the way. I feel like I understand better why these old lighting techniques still appeal to a lot of people, myself included.

Low-poly games are not just about nostalgia or self-imposed technical limitations, it's an art style just like pixel-art is. However, doing low-poly assets is just a part of it. Back in the day, developers were not trying to do low-poly assets intentionally. In fact, it was the opposite, they tried to squeeze as much performance and fidelity as possible from their hardware. This mindset included shading of course, which is why baked lighting was so predominant.

While per-vertex lighting is accurate for each vertex individually, it becomes less accurate when interpolated across triangles’ surfaces. However, there is a certain beauty in the linearity of the interpolation and the patterns that originate from it even on flat surfaces. If you look at intersections between objects, lighting varies slightly due to interpolation. It is still coherent, but the subtle difference reveals the polygonal nature of the scene. What might have been a technical limitation back in the day, has become essential to accomplish the art direction of Bel's Fanfare.

Just as we saw a resurgence of pixel-art games in the last decade, something tells me that the same is about to happen with low-poly games. While we have focused particularly on the 3DS Zelda remasters, there are many other frontiers to explore. What about a shooter that emulates DS graphics? Or an RPG that uses PS1 graphics? I guess we'll see.