Three Months In: What I've Learned So Far

It has been around three months since I properly started working on Evolve, so I thought it would be a good time to write down what I've learned so far.

The biggest lesson is probably that smaller voxels are not always better.

When I first started thinking about the game, I seriously considered using 0.25 metre voxels.

On paper, that sounds great.

You get loads of detail, buildings can be much more precise and the world should theoretically look less blocky.

The problem is the amount of data.

A normal one metre voxel contains 64 individual 0.25 metre voxels. You have four voxels along each axis, so 4 × 4 × 4 gives you 64 blocks occupying the same volume.

That is an enormous amount of data once you start talking about an entire world.

Even with ECS and DOTS, I very quickly came to the conclusion that trying to build the whole game around 0.25 metre voxels just isn't realistic.

So I've settled on 0.5 metres.

And actually, I'm really happy with that decision.

For building, 0.5 metres feels really nice. It gives enough precision that you can create much more interesting structures than you could with one metre blocks, without creating a completely ridiculous amount of voxel data.

So that part worked exactly as I'd hoped.

The terrain did not.

Apparently voxel games know what they're doing

One of the things I assumed at the start was that smaller voxels would automatically make terrain look better.

Turns out that isn't true at all.

If you generate a mountain entirely out of 0.5 metre blocks, there is just too much detail.

Every slope contains twice as many steps. Every ridge has more edges. Every little change in elevation becomes visible.

When you look out across a large landscape, instead of getting this nice coherent mountain shape, you get visual noise.

It looks awful.

It actually made me start thinking that perhaps all of these other voxel games know what they're talking about and I don't have a clue.

There is something psychologically quite pleasant about larger voxels when you're looking across terrain. Your brain seems to understand the shapes much more easily.

The other issue is movement.

With 0.5 metre terrain you end up with steps everywhere.

You can obviously make the player automatically climb over them, but you still feel all of those tiny changes in elevation as you move around the world.

It just doesn't feel particularly nice.

And considering one of my main goals is to have huge mountain ranges and large natural features, that was becoming a fairly big problem.

The compromise

I've ended up with what I think is a good compromise.

Internally, the world still uses 0.5 metre voxels.

But the natural terrain generates at one metre resolution.

So when you're standing looking across the world, the terrain essentially looks like it is made from one metre voxels.

If you then start hacking into the terrain, you're actually interacting with the underlying 0.5 metre voxels.

That means I still get the precision I wanted for digging, building and manipulating the world, without having the entire landscape covered in tiny blocks.

At the moment, this feels much better.

It has definitely been one of those things where actually building it taught me far more than thinking about it ever could.

The world is getting big

Performance so far has actually been really encouraging.

At the moment I'm drawing full voxel terrain out to around 512 metres from the player.

Beyond that I switch over to a much cheaper clipmap representation.

That allows me to show terrain several kilometres into the distance. At the moment I'm around four kilometres, which is already more than I really need because by that point atmospheric fog will obscure most of it anyway.

So I'm fairly happy with where the terrain system is.

World generation is working.

Terrain streaming is working.

The texturing system is working.

I can run around the world with the player character and, importantly, it is starting to actually feel like somewhere rather than just a collection of technical systems.

There is obviously still a lot to do, but the underlying direction now feels much clearer.

Trees and foliage

Once the terrain was in a reasonable state, the next big thing I started looking at was vegetation.

Trees are slightly interesting because they're split between two systems.

The trunks themselves are true voxels.

They use the same underlying voxel system as the terrain and are currently built using the same 0.5 metre resolution.

Leaves and grass are handled separately through the foliage system.

That system has turned out to be very performant.

At the moment I'm able to draw quite large quantities of foliage out to around 96 metres from the player without performance becoming a major problem.

That includes both grass across the terrain and the leaves on trees.

My current development machine uses an RTX 3080, so it's certainly not a low-end GPU, but I'm deliberately trying not to design everything around extremely high-end hardware.

One of my slightly ambitious goals is still Steam Deck support.

I haven't actually tried the game on a Steam Deck yet, so I may regret writing this later, but looking at the profiler I'm still reasonably confident that I can get it running.

A lot will come down to how aggressively I reduce things like draw distance, foliage distance and simulation range.

But so far, I haven't seen anything that makes me think it's impossible.

Making the atmosphere

I've also started working more on the atmosphere of the world.

That means clouds, fog, weather and generally all of the volumetric effects that hopefully make the world feel a little less like a collection of cubes.

I'm using Unity's Universal Render Pipeline rather than HDRP.

The main reason for that is scalability. URP gives me a much better chance of targeting lower-end hardware and hopefully eventually handheld devices.

The downside is that you don't really get all of the volumetric systems I want out of the box.

So I've ended up building most of them myself.

That has been somewhat time-consuming.

I'm definitely a developer rather than a graphics artist, so almost everything I'm doing has to be approached from the code side first.

Things like clouds and atmospheric scattering are therefore another fairly large learning curve for me.

But they're starting to work.

And combining those more realistic skies, fog and lighting with the voxel terrain is beginning to produce something quite close to what I originally had in my head.

Three months in

Overall, I think things are going pretty well.

The basic world exists.

I can generate it, stream it, texture it, walk around it and see several kilometres into the distance.

Trees and foliage are working.

The first versions of the weather and volumetric systems are working.

And, perhaps more importantly, I've already found a few assumptions I made at the beginning that turned out to be completely wrong.

I think that's probably going to happen quite a lot.

Progress is maybe slightly slower than I imagined when I originally wrote down the plan, but not dramatically so.

Three months in, I'm still roughly where I hoped I would be.

And for the first time, it's starting to look less like an engine and a little bit more like the beginnings of a game.