Jump to content

Advanced Terrain Texture Splatting

Peer Reviewed by riuthamus, Dragonsoulj, slicer4ever

terrain splatting texture
In this article I will explain a texture splatting algorithm which allows you to create more natural terrain. This algorithm may be used in shaders of 3D games as well as in 2D games.

4: Adsense

In this article I will explain a texture splatting algorithm which allows you to create more natural terrain. This algorithm may be used in shaders of 3D games as well as in 2D games.

One of the most common ways of terrain texturing is blending multiple tiled layers. Each layer has an opacity map which defines the extent of texture presence on the terrain. The method works by applying an opacity map to the higher levels, revealing the layers underneath where the opacity map is partially or completely transparent. Opacity map is measured in percentage. Of course on each point of a terrain the sum of opacities of all layers makes one-hundred percent as the terrain can't be transparent. Instead of tile textures, the opacity map stretches entirely on all terrain and therefore has quite a low level of detail.

Now we will pass to the most interesting part — algorithms of blending of textures. For simplicity and obviousness our terrain will consist of sand and large cobble-stones.

Attached Image: 1.jpg

Simplest way of blending is to multiply texture color with opacity and then sum results.

float3 blend(float4 texture1, float a1, float4 texture2, float a2)
    return texture1.rgb * a1 + texture2.rgb * a2;

Such a technique is used in Unity3D in the standard terrain editor. As you can see, the transition is smooth but unnatural. Stones look evenly soiled by sand, but in the real world it doesn't happen like that. Sand doesn't stick to stones, instead it falls down and fills cracks between them, leaving the tops of stones pure.

Let's try to simulate this behavior in Excel plots. As we want sand to be "fallen down" between cobble-stones, for each texture we need the depth map. In this example we consider the depth map is generated from grayscaled image and stored in the alpha channel of a texture. In Unity3D it can be done in the texture inspector by setting the flag "Alpha From Grayscale".

First of all we will consider the simplified model of depth map of sand and stones.

Attached Image: 2.png

The blue line on the plot symbolizes the depth map of sand and red is cobble-stones. Notice that tops of stones lie higher than sand level. Considering this fact, we will try to draw pixels of that texture which is above.

float3 blend(float4 texture1, float a1, float4 texture2, float a2)
    return texture1.a > texture2.a ? texture1.rgb : texture2.rgb;

Attached Image: 3.jpg

Excellent! Tops of cobble-stones remain pure whereas sand lies in cracks between them. But we didn't consider layer opacity yet. To use it we just sum depth map and opacity map.

float3 blend(float4 texture1, float a1, float4 texture2, float a2)
    return texture1.a + a1 > texture2.a + a2 ? texture1.rgb : texture2.rgb;

At the expense of summation less transparent texture will be higher than usual.

Attached Image: 4.png

Attached Image: 5.jpg

So we have a more natural transition from sand to stones. As you can see, grains of sand start filling cracks between cobble-stones, gradually hiding them. But as calculations happens pixel-by-pixel, artifacts begin to appear on the border between textures. To get a smooth result we will take several pixels in depth instead of one and blend them.

float3 blend(float4 texture1, float a1, float4 texture2, float a2)
    float depth = 0.2;
    float ma = max(texture1.a + a1, texture2.a + a2) - depth;

    float b1 = max(texture1.a + a1 - ma, 0);
    float b2 = max(texture2.a + a2 - ma, 0);

    return (texture1.rgb * b1 + texture2.rgb * b2) / (b1 + b2);

In the code above we at first get part of a ground seen at a certain depth.

Attached Image: 6.png

And then we normalize it to get new opacities.

Attached Image: 7.png

Attached Image: 8.jpg

As a result we found the algorithm of textures blending, which allows us to reach close to a natural terrain image.

In summary I want to explain what this algorithm was developed for and how we use it.

The shader was developed for turn-based strategic indie game Steam Squad. As engine and developing platform we use Unity3D. And as the Unity IDE is extremely flexible, we made our own level designer extension. In general the level designer is a simplified Unity3D terrain editor with some features of Titan Quest Editor.

When you paint the texture on a terrain there is a recalculation of the opacity map corresponding to this texture. And as the sum of all opacities has to make 100%, the editor automatically normalizes opacity maps of other layers.

Here is short YouTube video showing how it works.

Shader which uses this algorithm in Unity3D Asset Store


GDOL (Gamedev.net Open License)


Jul 17 2013 12:21 AM

That's a really cool technique!  It adds quite a lot visually for only a little work.


Thanks for sharing!

Jul 17 2013 12:32 PM

This is one of those techniques that when seen, causes you to ask yourself: "Why hasn't anyone thought of this before?"


The bottom picture looks natural. This is very impressive!

Jul 17 2013 02:53 PM

I think many people have, the issue is the draw call and the load times; which leads me to my question.


Doesnt the pixel shader run slower and cause considerable lag on a procedurally generated terrain setup?


This setup would work on solid, never changing terrain, but I think it would cause serious issues with terrain that was to change on a constant or semi constant basis. Each modification of the land would require another draw call, would it not?


Also, with our system we have been looking at doing this but we have 3 textures maps ( normal, specular, color ). Each one of these would need a new sample, this means 3 * 3 = 9 samples. We would have to blend this with another texture ( for the edges of the blocks/regions ) making a total of 18 samples.... is this correct?

Jul 17 2013 07:18 PM

I have no clue why my post generated two down votes... as there was nothing negative about it. Oh well.... whatever!

Jul 17 2013 07:59 PM

Seemed to me like you raised some valid points. O.o

Jul 17 2013 08:00 PM
I really like this technique, I'm defiantly going to keep it in mind for the future.
Jul 17 2013 08:02 PM

I like it as well... i just want to understand how it could be used in a modular world rather than a static one.

Jul 18 2013 12:45 AM

Riuthamus, good questions!


Shader behaves exactly like default one. Of course, it has more math operations, but delay is absolutely insignificant. In the my implementation of shader I can blend 9 textures: 4 color maps + 4 normal maps + noise map. And with some math magic I still fit in SM2.0 limitations.


Also with some storage magic the changing of texture transparency isn't more difficult than moving point of a mesh. I can change it in realtime, but changing of set of textures is still expensive operation.


Sorry but I can't show you all sources because the shader is part of commercial project.

Jul 18 2013 01:07 PM

It would be helpful to people attempting to duplicate your results if the textures depicted above could be provided (or a modified version of them, such as with a text watermark).

Jul 18 2013 02:35 PM
Nice. Especially the clarification with the Excel graphs. Congrats and thanks.
Jul 20 2013 07:18 AM

You could get the same result by prefiltering the alpha map, avoiding all but one sample in the pixel shader. And if you employ some kind of relief shader, I suggest using the height map instead. 


I employed this method to much success, but I didn't use a hard comparision but instead used a simple smoothstep() to blend between to two. Also works nice, but had the downside that the order of sequence is now important. It's always "one on top of the other". Which was fine for me as my terrain blending put one material per pass. 

Jul 21 2013 07:23 PM

Great effect, thanks for sharing!

Jul 22 2013 02:04 AM
Jul 30 2013 01:01 AM

This'd look nice with some sort of emboss-mapping like effect.

Sep 03 2013 03:03 AM



Keep up the good work!

Sep 13 2013 04:59 AM

I implemented this technique in Unity3D. You can find shaders in Unity Asset Store and here is a demo.

Jun 23 2014 03:12 PM

Thanks Andrey, this technique is beyond fantastic!

Note: GameDev.net moderates article comments.