Leveling Terrain below GameObjects

Hey! We will at some point but I don't know if that will also be included in the Terrain Tools package.

As for pointers, when I was thinking about doing this for Terrain Tools, I was going to take the projection code for the Mesh Stamp tool to get the area that should be flattened for the whatever mesh I had intersecting the Terrain. You could probably just have a MonoBehavior attached to those GameObjects that modifies the heightmap whenever it's transform changes.

To make it a little more non-destructive, you will want to store state for the mesh stamp or Terrain so that you can "undo" the effects of the stamp when the stamp is moved elsewhere. You could do this by caching a texture for that area of the Terrain ( this might lead to a lot of memory usage though ).

If the transform for the mesh changes, either apply the inverse of the mesh stamp or apply a cached portion of the heightmap that existed before the stamp was placed there then apply the stamp in the new location for the transform. This breaks when the mesh is being stamped at an elevation that causes the Terrain height to be 0 or the Terrain's max height; that's when you start to lose your height information.

Actually, caching a subset of the heightmap is probably the better way to go. You might lose height information depending on how you flatten the Terrain under the stamp.

You might also want to apply a blur on the mask

Once you have the mask, then you'd want to modify the Terrain height by lerping the existing height towards the intersection height ( which could just be the bottom of the mesh bounds in Terrain space ) based on the texel value in the mask texture. You can use the Terrain Tools API to do all this. It's the same calls: BeginPaintHeightmap, EndPaintHeightmap, etc.

 

this is the function call in the Mesh Stamp Tool

Code (CSharp):

1. // generate a mask for the mesh to be used in the compositing shader
2. TerrainTools.MeshUtility.RenderTopdownProjection(
3.     activeMesh, //  the mesh to be rendered
4.     model, // model transformation matrix to be used
5.     renderTextureDestination, // render texture to blit to
6.     TerrainTools.MeshUtility.defaultProjectionMaterial, // you can replace this with your own if you want. just needs to render the height or depth
7.     TerrainTools.MeshUtility.ShaderPass.Height ); // this could just be zero if using the builtin material. the second pass always returns 1. can't remember why i did that
8.  

here is the code for the projection / height shader:

Code (CSharp):

1. Shader "Hidden/TerrainTools/MeshUtility"
2. {
3.     Properties
4.     {
5.         _MainTex ( "Texture", any ) = "" {}
6.     }
7.  
8.     SubShader
9.     {
10.         ZTest LEQUAL Cull OFF ZWrite ON
11.  
12.         HLSLINCLUDE
13.  
14.         #include "UnityCG.cginc"
15.  
16.         sampler2D _MainTex;
17.  
18.         struct appdata_t
19.         {
20.             float4 vertex : POSITION;
21.             float2 texcoord : TEXCOORD0;
22.         };
23.  
24.         float4x4 _Matrix_M;
25.         float4x4 _Matrix_MV;
26.         float4x4 _Matrix_MVP;
27.  
28.         ENDHLSL
29.  
30.         Pass // render mesh depth to rendertexture
31.         {
32.             HLSLPROGRAM
33.  
34.             #pragma vertex vert
35.             #pragma fragment frag
36.  
37.             struct v2f
38.             {
39.                 float4 vertex : SV_POSITION;
40.                 float4 worldPos : TEXCOORD1;
41.                 // float4 viewPos : TEXCOORD2;
42.             };
43.  
44.             v2f vert( appdata_t v )
45.             {
46.                 v2f o;
47.  
48.                 float2 b = float2( 0, 1 );
49.            
50.                 o.worldPos = mul( _Matrix_M, float4( v.vertex.xyz, 1 ) );        // world space position
51.                 o.vertex = mul( _Matrix_MVP, float4( v.vertex.xyz, 1 ) );   // clip space position
52.  
53.                 return o;
54.             }
55.  
56.             float4 frag( v2f i ) : SV_Target
57.             {
58.                 return i.worldPos.y;
59.             }
60.  
61.             ENDHLSL
62.         }
63.  
64.         Pass // render mask
65.         {
66.             HLSLPROGRAM
67.  
68.             #pragma vertex vert
69.             #pragma fragment frag
70.  
71.             struct v2f
72.             {
73.                 float4 vertex : SV_POSITION;
74.             };
75.  
76.             v2f vert( appdata_t v )
77.             {
78.                 v2f o;
79.  
80.                 o.vertex = mul( _Matrix_MVP, float4( v.vertex.xyz, 1 ) );   // clip space position
81.  
82.                 return o;
83.             }
84.  
85.             float4 frag( v2f i ) : SV_Target
86.             {
87.                 return 1;
88.             }
89.  
90.             ENDHLSL
91.         }
92.     }
93. }

 

and this is how i build the model matrix in the Mesh Stamp tool:

Code (CSharp):

1.  
2.             Matrix4x4 toolMatrix = Matrix4x4.TRS( Vector3.zero, toolSettings.rotation, toolSettings.scale );
3.  
4.             Bounds modelBounds = activeMesh.bounds;
5.             float maxModelScale = Mathf.Max( Mathf.Max( modelBounds.size.x, modelBounds.size.y ), modelBounds.size.z );
6.             float x = .5f;
7.             float y = .5f;
8.             float xy = Mathf.Sqrt( x * x + y * y );
9.             float z = .5f;
10.             float xyz = Mathf.Sqrt( xy * xy + z * z );
11.             maxModelScale *= xyz; // this gets the max length of any bounds axis for the mesh given any rotation and scales
12.                                                   // it so it always fits within the texture bounds (until you apply more scaling to it ofc.
13.                                                   // but this will start as fitting in the rendertexture )
14.  
15.             // build the model matrix to transform the mesh with. we want to scale it to fit in the brush bounds and also center it in the brush bounds
16.             Matrix4x4 model = toolMatrix * Matrix4x4.Scale( Vector3.one / maxModelScale ) * Matrix4x4.Translate( -modelBounds.center );
17.  
18.             Vector3 translate = Vector3.up * ( toolSettings.stampHeight ) / commonUI.terrainUnderCursor.terrainData.size.y;
19.             model = Matrix4x4.Translate( translate ) * model;
20.  

 

I believe lines 18 and 19 should involve the mesh.transform.y position instead of the toolSettings.stampHeight

 

Anytime! Let me know if you have further questions

 

One thing to note is that this is not an intersection test and will give you odd results for shapes like bridge meshes and chairs. You'd think that the only part where the blending would occur is where the chair legs are but if you just use a plain topdown projection then it will also include the chair seat in the mask

 

Cool. If you end up making something for this, let me know!

 

Mesh bounding box would also work. You could make it a MonoBehaviour instead of a Terrain Tool which is probably what you would want anyway. Or have a system running in-editor that you can add these Meshes and transforms to that will modify the Terrain. If there's an overarching system that is running, that might be better because you could then batch overlapping or closely clustered Mesh stamps together in a single render for better blending results instead of doing one Stamp after the other with will favor the blended state of the next Stamp instead of giving all the local Stamps equal blending weight

 

I like that a lot!

 

Better. Much better

 

You might see some things from Terrain Tools in our work for 2020 but the end goal is a whole lot more than what we did with Terrain Tools.

The main thing that we've announced is non-destructive layers and the workflows around that

 

Environment is a different solution. You might see some similarities but it's not based on Terrain.