#terrain generation

Stochastic Geomophical Transport for Terrain Erosion Simulation

One major way to model terrain has been through simulating erosion: how the rock weathers away is a big component of the vibe of the landscape on a geological scale. But there's a couple of components to that: both the erosion itself and also where that material goes afterwards. In short, this new simulation from Nicholas McDonald and Guillaume Cordonnier handles both mountains and rivers.

(Another major way, of course, is Perlin Noise and related approaches, which eschew teleological realism but gain other benefits.)

The idea here is momentum conversation: using a new particle-based algorithm (which can be combined with other geological processes, like tectonics and wind direction) it simulates geomorphological transport, which operates over geological time, taking advantage of the difference in timescales: over the course of geologic time, a river is basically instantaneous.

This makes it very flexible for mixing "a wide variety of phenomena" as they say: in the paper they describe the potential for things like dunes, coastal erosion, floods, rockfalls, varying erosion weights. I particularly like how effective it is at effects like braided rivers and river deltas, which are very common in nature but often overlooked on procedurally-generated maps.

On the other hand, if the erosion is fast (individual rockslides) or transport is slow (glaciers) that breaks the assumption and it won't be as accurate at modeling it.

I think the reason that I'm personally drawn toward this algorithm is because it has a history that is naturally embedded in it.

You don't necessarily need to replicate the exact phenomena that was involved in creating something to get a good result. Much of games and simulation is about picking the right abstraction to get the right feel, regardless of how you get there. It's often the better call, to get the right poetry instead of the exhaustively correct metric. But one benefit that you do get replicate the physical causative process to try to simulate the physical effects of water, wind, and time is that it comes with a built-in sense of history.

The Terrifying Cave Generation of Minecraft Snapshot 21w06a

After a very long wait, we’ve finally gotten to the ‘caves’ part of the Caves and Cliffs snapshots. This is very exciting for Minecraft, since a cave update has been both teased and desired for years. While Minecraft’s original cave system is pretty cool, especially with canyons, Snapshot 21w06a threatens to completely demolish it. While only being the tip of the iceberg. 21w06a introduces the…

Perlin noise is an algorithm very common in computer science- it is an algorithm designed to create maps of graduated floats that range between 0.0 and 1.0, maps that can be referenced by coordinate and thus used to add variety to textures, height maps, et cetera.

The primary advantage of algorithms like Perlin noise, simplex noise, et cetera, is that these variations can be achieved mathematically, rather than by a determinism based on a pre-existing state of input data besides the coordinates. However, the true beauty of these maps is in the ability to use them as a basis for more sophisticated algorithms. Data ranges of these 0.0-1.0 floats can be used to place objects, modulate other values, and so on. However, when they are used as height map data, typically they are either taken “as-is” and used to generate hills/islands or add subtle variety to manually-drawn maps.

Personally, I never liked to see it used to generate islands and hills. The problem I have with it is that, viewed from a macro level, Perlin noise is slightly too consistent. 

Oh by the way: If you plan on continuing your old save file, expect to see some sillyness like this, when uncovering new terrain!

Generating Maps With Photoshop Actions

You can, of course, generate things with recorded Photoshop actions. One artist who uses the handle Yo-L did just that. They posted the actions and patterns used, though they require Photoshop CC so this exact set of recorded actions won’t work on earlier versions.

The principle is sound, though, and you can use the concepts for all kinds of image generation. Remember, Photoshop is just acting on a 2D array of numbers. A generator that used a node-based interface or is coded directly by writing functions can do the exact same math.

It’s sometimes worth hauling out an image editor and seeing what an operation will look like as you’re trying to reason through the inner workings of your generator.

Some useful operations:

Curves and ramps:

By applying a gradient (or more complicated ramp or curve) to an image we can create a wide variety of effects.

Clouds, curves, threshold:

This is just a curve layer and a threshold over the cloud filer (which is itself a form of value noise) but it creates very organic transitions:

Adding detail with a blend mode

Need to add detail to a coastline? Here I’m screening a noise layer over a smooth threshold-based coastline to add detail. “Screen” in Photoshop is just inverting the layers, multiplying them together, and then un-inverting the result. Just like the filters, all Photoshop blend modes are just math. 

What about removing detail?

Here I’m using a Gaussian blur as a low-pass filter to remove the details from the underlying value noise, which results in a smoother look. If you’ve got a generator that’s too noisy, try filtering out the frequencies that you don’t want.

Distortion!

Alternately, maybe you just want to distort your image a bit and break up its regularity. Remember this post about Íñigo Quílez’s use of warping? Photoshop’s Distort filter does the same thing:

There’s a zillion more things you can do with this (look up image kernels in particular). If you’ve got a generator that is putting out results that are close to what you want but not quite there yet, consider doing some post-processing on it.

I’d love to see other people’s examples of simple post-processing techniques, whether implemented in code or in Photoshop.