Assembling Terrains without seams

Using the API to set the neighbors won't handle the blending for you. That just allows to to register neighbors for Painting operations.

This would affect gameplay, considering that you have gameplay elements on top of your tiles that depend on height information, but something you could do is define a blending distance for each tile and in a shader bind neighboring heightmaps and the target heightmap and blend between height values there. Then sync the texture data to CPU and update physics.

Another option would be to create terrains between your instantiated terrain prefabs specifically for blending so you don't have to sacrifice any gameplay stuff you've set up in your terrain prefabs. For this you could probably just copy the shader code for the Create Neighbors tool

 

I believe you are absolutely correct and thank you for pointing this out. I will provide a more detailed description of what I meant and make another post.

I was suggesting this but not the part about changing physics in the shader. The third mesh ( or terrain ) would just be there to blend between the adjacent Terrain Prefabs. Assuming you do the blending with a shader to modify the heightmap of that third Terrain, the way that you would get physics to work properly is you'd have to sync the heightmap data and rebuild the physics collider on the CPU.


P.S. I feel like I am years behind a lot of our users!

 

Ok, so:

The Theory

You have 2 tiles that you want to blend



To do this, you could blend the two tiles themselves which might be a little more complicated and would modify your Terrain instances

OR

you could create a third terrain tile, in between the two Terrain Prefabs, that is only there to hide the seam. This is the tile you would perform the blending on so that your Terrain Prefabs remain untouched ( thus not affecting any gameplay related items in the Terrain Prefabs that depend on the hieghtmap like placements of buildings etc. otherwise, they might be floating or under the terrain ). And these Terrain Tiles can be any width of your choosing ( width = the distance in which you allow the blending between any two Terrains to occur )

So you create a new Tile in between the Terrain Prefabs



Then you have to perform blending. In this scenario you do this via shader ( the alternatively would be on the CPU ). I provide some thoughts on how to do this in a bit but this is one result of performing the blending:



There's another case that needs to be handled however and that is this case:



The issue here is that you have generated Terrain Tiles to blend all the adjacent Terrains but now you need to generate a Terrain Tile to blend between the 4 generated Terrain Tiles.

Once you have your Terrain Tiles generated, if you need Physics to work for them, you will have to sync the heightmap from GPU to CPU and rebuild the Physics Collider. The way you do this depends on whichever Unity version you are on. In newer versions of Unity, iirc you should be able to use terrain.SyncHeightmap.

Blending

You will need your shader to reference at most 4 neighboring Terrain Heightmap RenderTextures. You can use the UV of the Terrain heightmap you are using to blend in order to determine how much weight the neighboring Terrains have on the height value at that particular UV.

The idea is that as U or V approaches either 0 or 1, you want the heights of your blend tile to match the heights of the neighboring Terrain along the seam.

You could do something similar to the built-in Create Neighbors Tool. That's at least a good starting point. The shader code is at the end of the post.

Using that shader might not give you the intended results, however, since it is basically either:

1. mirroring the heights of the neighboring Terrains
2. Linearly interpolating the heights of the neighboring Terrains​

so other options would be to also apply some noise along with the blend or, if you want to get really complicated, you also might be able to do an fast-fourier ( FFT ) analysis on the Terrain and extrapolate the "next" height values for each neighboring Terrain. You would then blend between those values for the actual heights of the blended Terrain Tile

NOTE: You might also want to blend the Terrain textures for the tile

Here is the C# reference for the Create Neighbor Terrain Tool

Shader code for Create Neighbors Tool:

Code (CSharp):

1. Shader "Hidden/TerrainEngine/CrossBlendNeighbors"
2. {
3.     Properties
4.     {
5.         _TopTex ("Top Texture", any) = "black" {}
6.         _BottomTex ("Bottom Texture", any) = "black" {}
7.         _LeftTex ("Left Texture", any) = "black" {}
8.         _RightTex ("Right Texture", any) = "black" {}
9.     }
10.     SubShader
11.     {
12.         Pass
13.         {
14.             ZTest Always Cull Off ZWrite Off
15.  
16.             CGPROGRAM
17.             #pragma vertex vert
18.             #pragma fragment CrossBlendNeighbors
19.             #pragma target 3.0
20.  
21.             #include "UnityCG.cginc"
22.  
23.             uniform float4 _TexCoordOffsetScale;
24.             uniform float4 _Offsets; // bottom, top, left, right
25.             uniform float4 _SlopeEnableFlags; // bottom, top, left, right; 0.0f - neighbor exists, 1.0f - no neighbor
26.             uniform float  _AddressMode; // 0.0f - clamp, 1.0f - mirror
27.  
28.             sampler2D _TopTex;
29.             sampler2D _BottomTex;
30.             sampler2D _LeftTex;
31.             sampler2D _RightTex;
32.  
33.             struct appdata_t
34.             {
35.                 float4 vertex : POSITION;
36.                 float2 texcoord : TEXCOORD0;
37.             };
38.  
39.             struct v2f
40.             {
41.                 float4 vertex : SV_POSITION;
42.                 float4 texcoord : TEXCOORD0;
43.             };
44.  
45.             v2f vert (appdata_t v)
46.             {
47.                 v2f o;
48.  
49.                 o.vertex = UnityObjectToClipPos(v.vertex);
50.                 o.texcoord.xy = v.texcoord;
51.                 o.texcoord.zw = (v.texcoord + _TexCoordOffsetScale.xy) * _TexCoordOffsetScale.zw;
52.                 return o;
53.             }
54.  
55.             float4 CrossBlendNeighbors(v2f i) : SV_Target
56.             {
57.                 // All slope offset data is static, but we calculate it on GPU because we don't want to access height data on CPU
58.                 float2 topSlope    = float2(UnpackHeightmap(tex2Dlod(_LeftTex,   float4(1.0f, 1.0f, 0.0f, 0.0f))), UnpackHeightmap(tex2Dlod(_RightTex, float4(0.0f, 1.0f, 0.0f, 0.0f)))) + _Offsets.zw;
59.                 float2 bottomSlope = float2(UnpackHeightmap(tex2Dlod(_LeftTex,   float4(1.0f, 0.0f, 0.0f, 0.0f))), UnpackHeightmap(tex2Dlod(_RightTex, float4(0.0f, 0.0f, 0.0f, 0.0f)))) + _Offsets.zw;
60.                 float2 leftSlope   = float2(UnpackHeightmap(tex2Dlod(_BottomTex, float4(0.0f, 1.0f, 0.0f, 0.0f))), UnpackHeightmap(tex2Dlod(_TopTex,   float4(0.0f, 0.0f, 0.0f, 0.0f)))) + _Offsets.xy;
61.                 float2 rightSlope  = float2(UnpackHeightmap(tex2Dlod(_BottomTex, float4(1.0f, 1.0f, 0.0f, 0.0f))), UnpackHeightmap(tex2Dlod(_TopTex,   float4(1.0f, 0.0f, 0.0f, 0.0f)))) + _Offsets.xy;
62.                 float2 topSlopeOffset    = _Offsets.y + _SlopeEnableFlags.y * topSlope;
63.                 float2 bottomSlopeOffset = _Offsets.x + _SlopeEnableFlags.x * bottomSlope;
64.                 float2 leftSlopeOffset   = _Offsets.z + _SlopeEnableFlags.z * leftSlope;
65.                 float2 rightSlopeOffset  = _Offsets.w + _SlopeEnableFlags.w * rightSlope;
66.  
67.                 float2 blendPos = saturate(i.texcoord.zw);
68.  
69.                 float4 weights = 1.0f / max(float4(1.0f - blendPos.y, blendPos.y, blendPos.x, 1.0f - blendPos.x), 0.0000001f);
70.                 weights /= dot(weights, 1.0f);
71.  
72.                 float4 heights = float4(
73.                     UnpackHeightmap(tex2D(_TopTex,    float2(i.texcoord.x, (1.0f - i.texcoord.y) * _AddressMode.x))),
74.                     UnpackHeightmap(tex2D(_BottomTex, float2(i.texcoord.x,  1.0f - i.texcoord.y  * _AddressMode.x))),
75.                     UnpackHeightmap(tex2D(_LeftTex,   float2( 1.0f - i.texcoord.x  * _AddressMode.x, i.texcoord.y))),
76.                     UnpackHeightmap(tex2D(_RightTex,  float2((1.0f - i.texcoord.x) * _AddressMode.x, i.texcoord.y)))
77.                 );
78.  
79.                 heights += float4(
80.                     lerp(topSlopeOffset.x,    topSlopeOffset.y, blendPos.x),
81.                     lerp(bottomSlopeOffset.x, bottomSlopeOffset.y, blendPos.x),
82.                     lerp(leftSlopeOffset.x,   leftSlopeOffset.y, blendPos.y),
83.                     lerp(rightSlopeOffset.x,  rightSlopeOffset.y, blendPos.y)
84.                 );
85.  
86.                 return PackHeightmap(dot(heights, weights));
87.             }
88.             ENDCG
89.         }
90.     }
91.     Fallback Off
92. }
93.  

Let me know if I need to explain any bit in more detail and thank you again @awesomedata

@AlexandreBourgoin sorry for providing a really vague and unclear reply

 

Agreed. It depends on your use case and the type of content you are trying to create.

To clarify, I suggested adding new tiles in case there were gameplay elements placed on the Terrain tile prefabs and if those elements would break if the Terrain Tiles themselves were modified. If that's not the case, you could definitely simplify it with something like what @muzboz detailed