1

Description

"This snippet can be seen as a stem from which one can develop more advanced terrain features (and some of them will be the subject of other contributions, snippets or articles).\r\nIt consists in a script that builds the terrain surface data, initializes the geometry and sets the shader inputs, and thus, a shader to help rendering the terrain.\r\n\r\nThe idea behind this contribution is to build \"small\" (up to 256x256 or more) terrain using a noise function and to use an interpolation function to smooth the surface in real-time using a shader.\r\n\r\n??? guide TL;DR\r\n- Create a `MultiMeshInstance3D` node\r\n- Attach the script below to it and set the following parameters:\r\n\t- **noise** : A `FastNoiseLite` resource with _Simplex_ noise type and _Rigged_ fractal type\r\n\t- **terrain** : Select the node itself\r\n\t- **size** : Let's be adventurous and set 128x128\r\n\t- **height** : Good result with 8. For higher mountains, aim for 16.\r\n- In the `multimesh` parameter of the `MultiMeshInstance3D` section, use a `PlaneMesh` as mesh, set the size to 1m x 1m, and subdivision to 3. Don't forget to set the `Transform Format` parameter to `3D` and check the `Use Custom Data`.\r\n- In the `material_override` parameter of the `GeometryInstance3D` section, create a `ShaderMaterial` and add the shader that can be found in the [rendering section](#rendering)\r\n???\r\n\r\n# Parameters\r\n\r\nThe script exposes the following parameters:\r\n- **noise** : A `Noise` resource that will be used to generate the shape\/surface of the terrain. Godot already provides a very satisfying `FastNoiseLite` wrapper which offers a great variety of choice. One simple solution is to set the _noise type_ to _Simplex_, the _frequency_ to `0.01` and a _fractal type_ to _Rigged_.\r\n- **height** : A multiplier for the noise output. The noise output will always be comprised between -1 and 1.\r\n- **sea_level** : The stepping value that cap the lowest value outputted by the noise function. \r\n- **terrain** : A `MultiMeshInstance3D` node that will be used to draw the terrain. Details about its configuration will be given in the [terrain section](#terrain) below.\r\n\r\n# Terrain{#terrain}\r\n\r\nThere's a lot of documentation about how to achieve good result using continuous noise functions to build semi-realistic terrain surface. We won't develop this part here. But as an example, we've added the **sea_level** parameter that allows simulating water surface.\r\n\r\nTo draw the terrain, we're using the `MultiMeshInstance3D` node. For better result, the _multimesh_ parameter should be set with a geometry which (X, Z) coordinates range from (-0.5, -0.5) to (0.5, 0.5) as shown below:\r\n\r\n> [!IMPORTANT]\r\n> Don't forget to set the _Transform Format_ parameter to 3D and check the _Use Custom Data_ parameter.\r\n\r\nHere, we have used a `PlaneMesh` resized to 1x1, facing Y (which is default setting) and subdivided at least 2 times.\r\nThere is as many instances as _cells_ in the terrain, spanned on the Y plane.\r\nEach instance is centered on a height sample of the heightmap.\r\n\r\n# Rendering{#rendering}\r\n\r\nA small amount of points for a terrain, if used _as is_ to draw triangles (as it is usually done), provides poor visual results. Here is a 32x32 terrain with classic geometry rendering:\r\n\r\n\r\nHowever, when detailing the terrain by subdividing it and applying an interpolation between heights, we obtain more acceptable results:\r\n\r\n\r\nTo achieve this result, we are using a bicubic B\u00e9zier interpolation. For that, we need three values for each point of the terrain : The elevation, the slope on the X axis and the slope on the Z axis. Those data are computed by the script, packed into an image at `FORMAT_RGBF` format and passed to the shader using an `ImageTexture` as uniform.\r\nThe instance custom data contains the position of the patch in the terrain (X, Z).\r\n\r\n??? guide The Shader\r\nThe uniforms `data_tex` and `terrain_size` are already set by the script.\r\nHowever, the following convenience parameters can be used:\r\n- **color_tile_scaling** : Number of subdivision in the color grid paving a tile\r\n- **color_tile_on** : First\/\"On\" color of the tile\r\n- **color_tile_off** : Second\/\"Off\" color of the tile\r\n- **border_thickness** : Border thickness from in \\[0, 1\\] range (best result with 0.01)\r\n- **color_border** : Border color\r\n\r\n```glsl\r\nshader_type spatial;\r\n\r\nconst float ONE_THIRD = 1.\/3.;\r\n\r\nconst vec2 PATCH_OFFSET[4] = {\r\n\tvec2( 1., 1.),\r\n\tvec2( 0., 1.),\r\n\tvec2( 1., 0.),\r\n\tvec2( 0., 0.)\r\n};\r\n\r\nconst vec2 T_IDX[9] = {\r\n\tvec2(-1., -1.),\r\n\tvec2( 0., -1.),\r\n\tvec2( 1., -1.),\r\n\tvec2(-1., 0.),\r\n\tvec2( 0., 0.),\r\n\tvec2( 1., 0.),\r\n\tvec2(-1., 1.),\r\n\tvec2( 0., 1.),\r\n\tvec2( 1., 1.)\r\n};\r\n\r\nconst ivec4 PATCH_POINTS[4] = {\r\n\tivec4(0, 1, 3, 4),\r\n\tivec4(1, 2, 4, 5),\r\n\tivec4(3, 4, 6, 7),\r\n\tivec4(4, 5, 7, 8)\r\n};\r\n\r\nvoid compute_points(\r\n\tvec3 p0, vec3 p1, vec3 p2, vec3 p3,\r\n\tvec2 sl0, vec2 sl1, vec2 sl2, vec2 sl3,\r\n\tvec4 ktu, vec4 ktv, vec3 dtu, vec3 dtv,\r\n\tout vec3 position, out vec3 normal, out vec3 tangent, out vec3 bitangent) {\r\n\tvec3 b0, b1, b2, b3, u0, u1, u2, u3, v0, v1, v2, v3, shift_0, shift_1;\r\n\tfloat x0_slope, z0_slope, x1_slope, z1_slope;\r\n\r\n\t\/\/ First and second curves slopes\r\n\tx0_slope = sl0.x;\r\n\tz0_slope = sl0.y;\r\n\tx1_slope = sl2.x;\r\n\tz1_slope = sl2.y;\r\n\tshift_0 = vec3(ONE_THIRD, x0_slope, 0.);\r\n\tshift_1 = vec3(ONE_THIRD, x1_slope, 0.);\r\n\t\/\/ First curve interpolation\r\n\tb0 = p0;\r\n\tb1 = p0 + vec3(0., z0_slope, ONE_THIRD);\r\n\tb2 = p2 - vec3(0., z1_slope, ONE_THIRD);\r\n\tb3 = p2;\r\n\tu0 = (ktv.r * b0) + (ktv.g * b1) + (ktv.b * b2) + (ktv.a * b3);\r\n\t\/\/ Second curve interpolation\r\n\tb0 += shift_0;\r\n\tb1 += shift_0;\r\n\tb2 += shift_1;\r\n\tb3 += shift_1;\r\n\tu1 = (ktv.r * b0) + (ktv.g * b1) + (ktv.b * b2) + (ktv.a * b3);\r\n\t\/\/ Third and fourth curves slopes\r\n\tx0_slope = sl1.x;\r\n\tz0_slope = sl1.y;\r\n\tx1_slope = sl3.x;\r\n\tz1_slope = sl3.y;\r\n\tshift_0 = vec3(ONE_THIRD, x0_slope, 0.);\r\n\tshift_1 = vec3(ONE_THIRD, x1_slope, 0.);\r\n\t\/\/ Fourth curve interpolation\r\n\tb0 = p1;\r\n\tb1 = p1 + vec3(0., z0_slope, ONE_THIRD);\r\n\tb2 = p3 - vec3(0., z1_slope, ONE_THIRD);\r\n\tb3 = p3;\r\n\tu3 = (ktv.r * b0) + (ktv.g * b1) + (ktv.b * b2) + (ktv.a * b3);\r\n\t\/\/ Third curve interpolation\r\n\tb0 -= shift_0;\r\n\tb1 -= shift_0;\r\n\tb2 -= shift_1;\r\n\tb3 -= shift_1;\r\n\tu2 = (ktv.r * b0) + (ktv.g * b1) + (ktv.b * b2) + (ktv.a * b3);\r\n\r\n\t\/\/ Final point\r\n\tvec3 v = (ktu.r * u0) + (ktu.g * u1) + (ktu.b * u2) + (ktu.a * u3);\r\n\r\n\t\/\/ dU\r\n\tvec3 du = (dtu.x * (u1 - u0)) + (dtu.y * (u2 - u1)) + (dtu.z * (u3 - u2));\r\n\r\n\t\/\/ First and second curves slopes\r\n\tx0_slope = sl0.x;\r\n\tz0_slope = sl0.y;\r\n\tx1_slope = sl1.x;\r\n\tz1_slope = sl1.y;\r\n\tshift_0 = vec3(0., z0_slope, ONE_THIRD);\r\n\tshift_1 = vec3(0., z1_slope, ONE_THIRD);\r\n\t\/\/ First curve interpolation\r\n\tb0 = p0;\r\n\tb1 = p0 + vec3(ONE_THIRD, x0_slope, 0.);\r\n\tb2 = p1 - vec3(ONE_THIRD, x1_slope, 0.);\r\n\tb3 = p1;\r\n\tv0 = (ktu.r * b0) + (ktu.g * b1) + (ktu.b * b2) + (ktu.a * b3);\r\n\t\/\/ Second curve interpolation\r\n\tb0 += shift_0;\r\n\tb1 += shift_0;\r\n\tb2 += shift_1;\r\n\tb3 += shift_1;\r\n\tv1 = (ktu.r * b0) + (ktu.g * b1) + (ktu.b * b2) + (ktu.a * b3);\r\n\t\/\/ Third and fourth curves slopes\r\n\tx0_slope = sl2.x;\r\n\tz0_slope = sl2.y;\r\n\tx1_slope = sl3.x;\r\n\tz1_slope = sl3.y;\r\n\tshift_0 = vec3(0., z0_slope, ONE_THIRD);\r\n\tshift_1 = vec3(0., z1_slope, ONE_THIRD);\r\n\t\/\/ Fourth curve interpolation\r\n\tb0 = p2;\r\n\tb1 = p2 + vec3(ONE_THIRD, x0_slope, 0.);\r\n\tb2 = p3 - vec3(ONE_THIRD, x1_slope, 0.);\r\n\tb3 = p3;\r\n\tv3 = (ktu.r * b0) + (ktu.g * b1) + (ktu.b * b2) + (ktu.a * b3);\r\n\t\/\/ Third curve interpolation\r\n\tb0 -= shift_0;\r\n\tb1 -= shift_0;\r\n\tb2 -= shift_1;\r\n\tb3 -= shift_1;\r\n\tv2 = (ktu.r * b0) + (ktu.g * b1) + (ktu.b * b2) + (ktu.a * b3);\r\n\r\n\t\/\/ dV\r\n\tvec3 dv = (dtv.x * (v1 - v0)) + (dtv.y * (v2 - v1)) + (dtv.z * (v3 - v2));\r\n\r\n\tposition = v;\r\n\ttangent = normalize(du);\r\n\tbitangent = normalize(dv);\r\n\tnormal = cross(bitangent, tangent);\r\n}\r\n\r\nvoid compute_from_uv(\r\n\tvec2 p_uv, vec2 global_uv,\r\n\tsampler2D data, vec2 map_size,\r\n\tout vec3 position, out vec3 normal, out vec3 tangent, out vec3 bitangent) {\r\n\t\r\n\tvec2 unit_size = vec2(1.) \/ vec2(map_size);\r\n\tivec2 coord = max(ivec2(0),ivec2(sign(p_uv.xy)));\r\n\tint patch_id = coord.y * 2 + coord.x;\r\n\tvec2 l_uv = p_uv + PATCH_OFFSET[patch_id]; \/\/ Local UV\r\n\tivec4 control_points = PATCH_POINTS[patch_id];\r\n\r\n\tfloat t = l_uv.x, t2 = t * t;\r\n\tfloat m_t = 1. - t, m_t2 = m_t * m_t;\r\n\tvec4 ktu = vec4(m_t2 * m_t, 3. * t * m_t2, 3. * t2 * m_t, t2 * t);\r\n\tvec3 dtu = vec3(3. * m_t2, 6. * t * m_t, 3. * t2);\r\n\r\n\tt = l_uv.y;\tt2 = t * t;\r\n\tm_t = 1. - t;\tm_t2 = m_t * m_t;\r\n\tvec4 ktv = vec4(m_t2 * m_t, 3. * t * m_t2, 3. * t2 * m_t, t2 * t);\r\n\tvec3 dtv = vec3(3. * m_t2, 6. * t * m_t, 3. * t2);\r\n\r\n\tvec2 uv = (global_uv + .5) \/ map_size;\r\n\r\n\tvec2 mp0 = uv + unit_size * T_IDX[control_points.r];\r\n\tvec2 mp1 = uv + unit_size * T_IDX[control_points.g];\r\n\tvec2 mp2 = uv + unit_size * T_IDX[control_points.b];\r\n\tvec2 mp3 = uv + unit_size * T_IDX[control_points.a];\r\n\r\n\tvec3 d0 = texture(data, mp0).rgb;\r\n\tvec3 d1 = texture(data, mp1).rgb;\r\n\tvec3 d2 = texture(data, mp2).rgb;\r\n\tvec3 d3 = texture(data, mp3).rgb;\r\n\r\n\tcompute_points(\r\n\t\tvec3(T_IDX[control_points.r].x, d0.r, T_IDX[control_points.r].y),\r\n\t\tvec3(T_IDX[control_points.g].x, d1.r, T_IDX[control_points.g].y),\r\n\t\tvec3(T_IDX[control_points.b].x, d2.r, T_IDX[control_points.b].y),\r\n\t\tvec3(T_IDX[control_points.a].x, d3.r, T_IDX[control_points.a].y),\r\n\t\td0.gb, d1.gb, d2.gb, d3.gb,\r\n\t\tktu, ktv, dtu, dtv,\r\n\t\tposition, normal, tangent, bitangent);\r\n}\r\n\r\ngroup_uniforms scaling;\r\n\r\nuniform vec2 terrain_size;\r\n\r\ngroup_uniforms ground;\r\n\r\nuniform sampler2D data_tex : repeat_disable;\r\n\r\ngroup_uniforms colors;\r\n\r\nuniform int color_tile_scaling : hint_range(1, 8) = 1;\r\nuniform vec3 color_tile_on : source_color = vec3(0.8);\r\nuniform vec3 color_tile_off : source_color = vec3(0.5);\r\nuniform float border_thichness : hint_range(0., 1.) = 0.01;\r\nuniform vec3 color_border : source_color = vec3(1., 0., 1.);\r\n\r\nvarying vec2 p_uv;\r\n\r\nvoid vertex() {\r\n\tp_uv = vec2(VERTEX.x, VERTEX.z);\r\n\tvec3 v, n, t, bt;\r\n\tcompute_from_uv(p_uv, INSTANCE_CUSTOM.xy, data_tex, terrain_size, v, n, t, bt);\r\n\r\n\tvec3 vn = NORMAL;\r\n\tvec3 t_n = normalize(n * vn.y + t * vn.x + bt * vn.z);\r\n\tNORMAL = t_n;\r\n\tfloat extrude = VERTEX.y;\r\n\tVERTEX = v + n * extrude;\r\n}\r\n\r\nvoid fragment() {\r\n\tvec2 nuv = fract((p_uv + .5) * float(color_tile_scaling));\r\n\tint idx = int(step(0.5, nuv.x)) * 2 + int(step(0.5, nuv.y));\r\n\tbool border = (p_uv.x + .5 < border_thickness) || (p_uv.y + .5 < border_thickness);\r\n\tALBEDO = border ? color_border : ((idx == 0 || idx == 3) ? color_tile_on : color_tile_off);\r\n}\r\n```\r\n???\r\n\r\n> [!NOTE]\r\n> The `fragment` part of the shader is an example. It should be the starting point of customization to add some neat effects of ground texturing.\r\n\r\n> [!NOTE]\r\n> The vertex shader is not limited to \"flat\" geometries like planes or patches. It can handle more complex geometries as follow:\r\n> \r\n> \r\n> It could also be a good idea to use a secondary noise function to jitter inner points of a patch to give more detail PER instance.\r\n\r\n# Example\r\n\r\nA sample scene could be the following:\r\n\r\n\r\nThe main script is attached to the root node with the `terrain` parameter set to the `Terrain` node.\r\nThe `Node` is attached to the simple [camera orbit script detailed here](https:\/\/thegodotbarn.com\/contributions\/snippet\/153\/orbit-cam)."

Main code

extends Node3D

# Noise that will generate the terrain
@export var noise : Noise

# Maximum height of our terrain
@export var height : float = 16.

# Sea level (in [-1, 1])
@export var sea_level : float = -0.26

# Terrain size (in cells)
@export var size : Vector2i = Vector2i(32, 32)

# Terrain mesh
@export var terrain : MultiMeshInstance3D

func _ready() -> void:
	assert(noise)

	# Generate the terrain.
	var count : int = size.x * size.y
	var heights : PackedFloat32Array = PackedFloat32Array()
	var data : PackedVector3Array = PackedVector3Array()
	heights.resize(count)
	data.resize(count)

	# Compute Heights --------------------------------------------------------
	var start_timer : int = Time.get_ticks_usec()
	var idx : int = 0
	for y : int in range(size.y):
		for x : int in range(size.x):
			heights[idx] = max(sea_level, noise.get_noise_2d(x, y)) * height
			idx += 1
	var end_timer : int = Time.get_ticks_usec()
	print("Height %s generated in %d µs" % [ size, end_timer - start_timer ])

	# Compute Texture Data ---------------------------------------------------
	start_timer = Time.get_ticks_usec()
	idx = 0
	for y : int in range(size.y):
		for x : int in range(size.x):
			var h : float = heights[idx]
			var hmx : float = heights[idx - 1] if x > 0 else h
			var hpx : float = heights[idx + 1] if x < size.x - 1 else h
			var hmz : float = heights[idx - size.x] if y > 0 else h
			var hpz : float = heights[idx + size.x] if y < size.y - 1 else h
			var dX : float = hmx - hpx
			var dZ : float = hmz - hpz
			var n : Vector3 = Vector3(dX, 2., dZ).normalized()
			n.y *= -3.
			data[idx] = Vector3(h, n.x / n.y, n.z / n.y)
			idx += 1
	var image : Image = Image.create_from_data(size.x, size.y, false, Image.FORMAT_RGBF, data.to_byte_array())
	var texture : ImageTexture = ImageTexture.create_from_image(image)
	end_timer  = Time.get_ticks_usec()
	print("Texture generated in %d µs" % (end_timer - start_timer ))

	# Bind the uniforms ------------------------------------------------------
	assert(terrain.material_override)
	var shader : ShaderMaterial = (terrain.material_override as ShaderMaterial)
	shader.set_shader_parameter("terrain_size", Vector2(size))
	shader.set_shader_parameter("data_tex", texture)

	# Instanciate geometry ---------------------------------------------------
	var multimesh : MultiMesh = terrain.multimesh
	assert(multimesh)
	multimesh.set_instance_count(count)
	idx = 0
	for y : int in range(size.y):
		for x : int in range(size.x):
			multimesh.set_instance_custom_data(idx, Color(float(x), float(y), 0., 0.))
			var t : Transform3D = Transform3D.IDENTITY.translated(Vector3(x, 0., y))
			multimesh.set_instance_transform(idx, t)
			idx += 1

Comments