Geometry Rift: Apocalypse · published
I’ve been obsessed with one thing since the beginning of Geometry Rift: I wanted the screen to fill with colored light.
Not just a glow around each enemy. I wanted groups of enemies to create areas of color. If ten orange enemies are together, that area should feel orange. If a group of blue enemies is nearby, both colors should mix naturally. Bright near the vector lines, softer as it spreads out.
It sounds simple, but getting there has been one of those small technical battles that ends up eating far more time than expected. Which is also, to be honest, one of the reasons I enjoy making games.
- The first prototype of Geometry Rift started as a minigame in Still Breathing -
I come from the demoscene, so this kind of thing matters to me. I like when visuals are not just decoration, but part of the feel of the game. Geometry Rift started as something I wanted to build with my son, but it also connects directly with the games I grew up loving: arcade games, shooters, vector graphics, particles, synth music, too many things happening on screen, and that feeling that the machine is doing something a bit excessive just because it looks good.
At first I used Godot’s built-in glow.
In Godot 4.3 and 4.4 it actually gave a falloff very close to what I wanted. The glow was meant to spread nicely, with a soft gradient that looked great over the dark background. It had that kind of smooth color wash I was looking for.
The problem is after Godot 4.6, the glow changed. The falloff I liked was gone, or at least it no longer behaved the way I needed. So the first solution was basically dead. The default Godot glow is just a shiny border, which is not bad, but it's very far of my goal.
At that point I started looking again at how older games solved this. Geometry Wars was the obvious reference. It is still one of the best examples of how to make simple shapes feel huge with color and bloom.
The idea is very old-school and very clever: since the background is mostly black, you can isolate the bright stuff, process that light separately, and add it back on top.
My first version based on that idea became V1 in Geometry Rift. It was fast and usable. It duplicated the bright shapes around themselves and blurred the result a bit.
From a gameplay distance, it worked reasonably well.
But if you looked closely, you could see what was happening. The glow was made of repeated copies. You could see little ghost versions of the enemies around the original shape. Once I noticed it, I could not stop seeing it.
It was good enough to keep the game moving, but not the look I had in mind.
There was another version that got closer to the color clouds I wanted.
For a while I thought, “Okay, this is it.” The colors were spreading, groups of enemies were creating visible areas of light, and the screen started to look much closer to what I had imagined.
Then the whole thing started burning to white.
When too many lights overlapped, the color disappeared. Orange became yellow. Pink became white. Some areas just turned into a big overexposed mess. It also cost too much in performance, so even if I had accepted the look, it was not practical.
That version was useful because it proved the direction was right, but it was not shippable.
Then I tried using mipmaps as a shortcut for the blur.
On paper it made sense. You sample lower-resolution versions of the image, and that should give you a cheap wide glow.
In practice, it created ugly square artifacts. The falloff did not feel smooth, the blur did not reach the way I wanted, and when I pushed the values harder, it just became more obviously broken.
This was one of those versions where you keep changing parameters because you want it to work. Threshold, intensity, radius, gamma, cap, whatever. You convince yourself that the next tiny adjustment will fix it.
It did not.
Eventually I accepted that the approach was not right for this game. Specially because when it started to work it was terribly CPU consuming, so I had to discard it.
The main thing I learned is that a wide glow does not come from simply spacing samples farther apart.
If you do that, you don’t get a smooth blur. You get visible copies, rings, blocks, or patterns. The eye catches it very quickly. The right approach, I think, is to treat the glow as an image.
First you render all the light sources into a separate layer. Then you blur that whole layer, but not just each enemy or each bullet separately. The complete light layer. Maybe this was a common knowledge thing, but it took a lot of time to realize that on my own.
If you want the glow to spread further, you work with lower-resolution versions of that layer. A small blur on a small image, scaled back up, creates a much wider and smoother result. That is the trick. It is simple, but it took a few failed versions to really get there.
The current version captures the whole light layer into its own render target.
Enemies, bullets, particles, walls, decals and lasers all go into that layer. The background and HUD do not. Only the things that should emit light.
That layer then goes through a downsample pyramid. Each level is blurred and later combined back into the final image.
The higher-resolution levels keep the glow close to the objects, so the lines still feel sharp and bright. The lower-resolution levels create the larger areas of color. That is where the big soft clouds come from.
This is much closer to what I wanted from the start. It does not look like each object has its own glow effect anymore. It feels more like the light belongs to the whole scene.
## Performance
The final problem, as always, is making it run well.
The full V3 glow is heavier than the old version, so it has to scale with detail settings.
ULTRA can use the full version. HIGH and MEDIUM can use cheaper render targets. LOW can fall back to V1, which is still fast and works well enough on weaker machines.
That balance matters because this is not just a visual test. It has to work in the real game, with enemies, weapons, particles, explosions and all the chaos that happens during a run.
This might sound like a lot of work for “just glow”, but for me it is a big part of the identity of the game.
Geometry Rift is built from simple shapes, but I want it to feel alive through motion, color, music, sounds and feedback. That is the kind of thing I have always loved in games and demos. Simple elements pushed hard until they become something more.
I’m making this game partly because I love videogames, and partly because I wanted to build something with my son. That makes these details matter even more. I want the game to have that feeling I remember from the arcade and demoscene stuff I grew up with: technical, colorful, a bit excessive, and made by someone who clearly cared too much about how a pixel fades into another pixel.
The glow has been one of the hardest parts to get right.
But now it finally feels like Geometry Rift is getting the light it was supposed to have.