0

Description

"The whole demo project is available [here](https:\/\/codeberg.org\/CasualGarageCoder\/godot-wandering-terrain)\r\n\r\n??? guide TL;DR\r\nTo render a heightmap using a single mesh, we will use the following (pretty common) scene structure :\r\n\r\n- A root `Node3D` with the main script attached (see page bottom script) managing mesh and camera placement.\r\n- A `MeshInstance3D` node to display the \"wandering mesh\", using a `ShaderMaterial` backed by a `SpatialShader` which vertex shader will compute the height and the normal for each vertices depending on the uniforms (terrain data, translation and rotation) (more detail [here](#render_terrain).\r\n- A `Camera3D` which position will be managed by some minimal controls for demonstration purpose.\r\n- The usual optional `DirectionalLight3D` to add some flavor to the scene.\r\n\r\nThe mesh will be created using the `PrimitiveMesh` derived script described [here](#build_mesh).\r\n???\r\n\r\nIn the following, we will focus on one kind of terrain rendering, and more precisely height map terrain. An heightmap, as it name implies, is a terrain defined by its height in relation to the 2-dimension coordinate ( `h(x, y) = z` or `h(theta, phi) = rho` in case of spherical coordinate system).\r\n\r\nHeightmaps are usually uniformly discretized by an arbitrary step (for example, 1 meter precision, meaning that the heightmap will provide elevation information on a grid of point separated by one meter). And thus, rendering such a terrain can be sub-optimal when it is big (too big for the graphic card to handle). Enters the LoD, standing for level of detail. The principle is that when the terrain is close to the camera, we can render the terrain as precisely as possible, but when the further the terrain from the camera, the lesser detail we need.\r\n\r\nSeveral techniques have been developed to deal with this LoD approach, usually implying terrain mesh subdivision (as we get closer to the camera) or decimation (as we get away from the camera). For the sake of this article length, we won't make a list or try to evoke them all. The main principle remains to dynamically compute the appropriate mesh for the terrain to be rendered, implying some CPU usage and GPU bandwidth consumption as the mesh is updated.\r\n\r\nThe technique presented here is rather simple. Instead of performing computations to dynamically build a (series of) mesh and update it (them), we just use one mesh once and for all and move it along the terrain. The mesh will be transformed using a vertex shader, directly in the GPU with minimal bandwidth consumption.\r\n\r\nBe advised that this technique is more adapted to scene where the camera is relatively close to the ground, like, for example, third party adventure games in which the view follows the scene subject (the player for instance). However, we will see that it is still possible to manage different kind of view (shoulder cam, eagle view, global map) using several meshes tailored for the different situations.\r\n\r\n### Core Principle\r\n\r\nAs explained earlier, instead of performing on-the-fly mesh computation to resolve LoD, we will use a unique mesh that will be place in front of the camera. With the help of a vertex shader, we will \"slide\" the terrain data over the mesh to adapt each vertices elevation. By doing this, we greatly reduce CPU usage as well as the need to transfer data to the GPU.\r\n\r\nHowever, this comes with some drawbacks. If not tailored correctly, the terrain will appear \"wiggly\" as we move the camera. This is due to the fact that vertices will only update their Y coordinate. Then, as the \"structure\" of the mesh is fixed, it is adapted for relatively fixed camera (should cam, etc.), even if, as we will see later, it can suit many more cases than expected.\r\n\r\n### Creating the Mesh\r\n\r\n#### Using 3D Modeler\r\n\r\nCreating a mesh with different level of detail, and thus, different number of subdivision, is (kinda) easy when done with 3D modeler like Blender. It automatically manages the seams (correct transition between patches of different level of detail to avoid cracks in terrain).\r\n\r\n\r\n\r\nHowever, one has to build the mesh, export it, import it in Godot and finally test if it fits and doesn't produce artifacts in the targeted use-case. And this can be a costly\/lengthy workflow.\r\n\r\n#### Using `PrimitiveMesh`{#build_mesh}\r\n\r\nGodot provides a way to procedurally generate meshes through script. All hail to the `PrimitiveMesh`.\r\nWe can reduce the mesh tailoring workflow drastically by allowing its generation directly in the IDE and even during game execution using the inspector.\r\nLet's start with a square size, an initial number of subdivision and then an array to specify the number of patch layers for each successive lower level of detail.\r\n\r\n\r\n\r\nThe implementation detail here is out of this article scope and is basically some vertices generation and indexing dark wizardry. However, find in the following the script for this mesh generator.\r\n\r\n??? guide Wandering Mesh Generator Script\r\nCreate a new script, copy paste the following code in it. Now, you will be able to select it when choosing a mesh in the `MeshInstance3D` node inspector.\r\n\r\n```\r\n@tool\r\nclass_name WanderingMesh\r\nextends PrimitiveMesh\r\n\r\n# For simplicity sake, the terrain is on X\/Z plane, X being width, Z being depth.\r\n\r\n# LOD 0 square size\r\n@export var start_size : float = 1. :\r\n\tset(value) :\r\n\t\tstart_size = value\r\n\t\trequest_update()\r\n# LOD 0 number of subdivisions\r\n@export var start_subdivision : int = 2 :\r\n\tset(value) :\r\n\t\tstart_subdivision = value\r\n\t\trequest_update()\r\n# LODs number of patches\r\n@export var lods : Array[int] = [] :\r\n\tset(value) :\r\n\t\tlods = value\r\n\t\trequest_update()\r\n\r\n# Relative coordinate of the vertices when computing triangle fans.\r\nconst TRI_FAN : Array[Vector2i] = [\r\n\tVector2i(-1, -1),\r\n\tVector2i( 0, -1),\r\n\tVector2i( 1, -1),\r\n\tVector2i( 1, 0),\r\n\tVector2i( 1, 1),\r\n\tVector2i( 0, 1),\r\n\tVector2i(-1, 1),\r\n\tVector2i(-1, 0),\r\n\tVector2i(-1, -1)\r\n]\r\n\r\nclass Cluster:\r\n\tvar indices : PackedInt32Array # Vertices involved in the cluster\r\n\tvar size : int # Size (root square of vertices number)\r\n\tvar ignore : bool # If true, subdivided cluster. Should not be processed.\r\n\r\n\tfunc _init(sz : int) -> void:\r\n\t\tsize = sz; indices = PackedInt32Array(); indices.resize(sz * sz); ignore = false\r\n\r\nfunc _create_mesh_array() -> Array:\r\n\tassert(start_subdivision >= 1 and start_size > 0.)\r\n\r\n\tvar clusters_count : Vector2i = Vector2i.ONE\r\n\tvar subs : int = start_subdivision\r\n\tvar last_valid_lod : int = -1\r\n\tfor i : int in range(lods.size()):\r\n\t\tsubs -= 1\r\n\t\tif subs < 1:\r\n\t\t\tbreak\r\n\t\tlast_valid_lod = i\r\n\t\tvar lod_patch_number : int = lods[i]\r\n\t\tclusters_count = clusters_count + Vector2i(lod_patch_number * 2, lod_patch_number)\r\n\t# Build inverse subdivision\r\n\tvar reverse_lod : Array[int] = []\r\n\tif last_valid_lod >= 0:\r\n\t\tfor i : int in range(last_valid_lod, -1, -1):\r\n\t\t\treverse_lod.append(lods[i])\r\n\r\n\tvar initial_subdivision : int = (start_subdivision - last_valid_lod - 1) if last_valid_lod >= 0 else start_subdivision\r\n\tvar subdivision : int = 2 ** initial_subdivision\r\n\tvar vertices_distance : float = start_size \/ (float) (subdivision)\r\n\r\n\tvar vertices : PackedVector3Array = PackedVector3Array();\r\n\r\n\t# Build initial un-LODed terrain.\r\n\tvar vertices_layout : Vector2i = (clusters_count * subdivision) + Vector2i.ONE\r\n\tvar clusters : Array[Cluster] = []\r\n\tvar mesh_offset : Vector3 = Vector3(- (clusters_count.x * start_size) \/ 2., 0., 0.)\r\n\tfor y : int in range(vertices_layout.y):\r\n\t\tfor x : int in range(vertices_layout.x):\r\n\t\t\tvertices.append(Vector3(x, 0, y) * vertices_distance + mesh_offset)\r\n\t# And now distribute in clusters.\r\n\tfor y : int in range(clusters_count.y):\r\n\t\tfor x : int in range(clusters_count.x):\r\n\t\t\tvar c : Cluster = Cluster.new(subdivision + 1)\r\n\t\t\tvar start_y : int = y * subdivision\r\n\t\t\tvar in_idx : int = 0\r\n\t\t\tfor j : int in range(subdivision + 1):\r\n\t\t\t\tfor i : int in range(subdivision + 1):\r\n\t\t\t\t\tc.indices[in_idx] = ((start_y + j) * vertices_layout.x) + (x * subdivision) + i\r\n\t\t\t\t\tin_idx += 1\r\n\t\t\tclusters.append(c)\r\n\tvar last_clusters : int = 0\r\n\r\n\t# Fun begins ! Let's subdivide sequencially.\r\n\tvar clusters_to_sub : Vector3i = Vector3i(0, clusters_count.x - 1, clusters_count.y - 1)\r\n\tfor i : int in range(reverse_lod.size()):\r\n\t\tvar stride : int = clusters_to_sub.y + 1\r\n\t\tvar l : int = reverse_lod[i] * (2 ** i)\r\n\t\tclusters_to_sub.x += l\r\n\t\tclusters_to_sub.y -= l\r\n\t\tclusters_to_sub.z -= l\r\n\t\tvertices_distance \/= 2.\r\n\t\tvar cells : Vector2i = Vector2i(clusters_to_sub.y - clusters_to_sub.x + 1, clusters_to_sub.z + 1)\r\n\t\tmesh_offset = Vector3(-(cells.x * subdivision * vertices_distance), 0., 0.)\r\n\t\tvertices_layout = (cells * 2 * subdivision) + Vector2i.ONE\r\n\r\n\t\tvar vertices_start : int = vertices.size()\r\n\t\tfor y : int in range(0, vertices_layout.y - 1):\r\n\t\t\tfor x : int in range(1, vertices_layout.x - 1) if y % 2 == 1 else range(1, vertices_layout.x - 1, 2):\r\n\t\t\t\tvertices.append(Vector3(x, 0, y) * vertices_distance + mesh_offset)\r\n\t\tvar current_cell_count : int = clusters.size()\r\n\t\t# Compute vertices per cells.\r\n\t\tfor cell_y : int in range((clusters_to_sub.z + 1) * 2):\r\n\t\t\tfor cell_x : int in range(clusters_to_sub.x * 2, (clusters_to_sub.y + 1) * 2):\r\n\t\t\t\t@warning_ignore(\"integer_division\")\r\n\t\t\t\tvar to_sub_pos : Vector2i = Vector2i(cell_x \/ 2, cell_y \/ 2)\r\n\t\t\t\tvar sub_id : Vector2i = Vector2i(cell_x, cell_y) - (to_sub_pos * 2)\r\n\t\t\t\tvar to_sub_idx : int = (to_sub_pos.y * stride) + to_sub_pos.x\r\n\t\t\t\tvar to_sub : Cluster = clusters[last_clusters + to_sub_idx]\r\n\t\t\t\tto_sub.ignore = true\r\n\t\t\t\tvar new_cluster : Cluster\r\n\r\n\t\t\t\tvar sub_pos : Vector2i = Vector2i(cell_x - (clusters_to_sub.x * 2), cell_y)\r\n\t\t\t\tvar vertices_start_pos : Vector2i = sub_pos * subdivision\r\n\t\t\t\tvar fixed_start_pos : Vector2i = vertices_start_pos - Vector2i(1, 0)\r\n\t\t\t\t@warning_ignore(\"integer_division\")\r\n\t\t\t\tvar previous_start_pos : Vector2i = sub_id * (subdivision \/ 2)\r\n\t\t\t\tnew_cluster = Cluster.new(to_sub.size)\r\n\t\t\t\tvar idx : int = 0\r\n\t\t\t\tfor y : int in range(to_sub.size):\r\n\t\t\t\t\tfor x : int in range(to_sub.size):\r\n\t\t\t\t\t\tvar from_prev : bool = (y % 2 == 0) and (x % 2 == 0)\r\n\t\t\t\t\t\tvar invalid : bool = ((x + vertices_start_pos.x) == 0) or ((x + vertices_start_pos.x) == vertices_layout.x - 1) or ((y + vertices_start_pos.y) == vertices_layout.y - 1)\r\n\t\t\t\t\t\tvar point_id : int\r\n\t\t\t\t\t\tif invalid and not from_prev:\r\n\t\t\t\t\t\t\tpoint_id = -1\r\n\t\t\t\t\t\telif from_prev:\r\n\t\t\t\t\t\t\t@warning_ignore(\"integer_division\")\r\n\t\t\t\t\t\t\tpoint_id = to_sub.indices[((previous_start_pos.y + (y \/ 2)) * (subdivision + 1)) + (previous_start_pos.x + (x \/ 2))]\r\n\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t# Number of full lines, number of half lines\r\n\t\t\t\t\t\t\tvar line : int = fixed_start_pos.y + y\r\n\t\t\t\t\t\t\t@warning_ignore(\"integer_division\")\r\n\t\t\t\t\t\t\tvar full_lines : int = line \/ 2\r\n\t\t\t\t\t\t\tvar half_lines : int = line - full_lines\r\n\t\t\t\t\t\t\t@warning_ignore(\"integer_division\")\r\n\t\t\t\t\t\t\tvar offset : int = full_lines * (vertices_layout.x - 2) + half_lines * ((vertices_layout.x - 1) \/ 2)\r\n\t\t\t\t\t\t\tif line % 2 == 0:\r\n\t\t\t\t\t\t\t\t@warning_ignore(\"integer_division\")\r\n\t\t\t\t\t\t\t\toffset += (fixed_start_pos.x + x) \/ 2\r\n\t\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t\toffset += fixed_start_pos.x + x\r\n\t\t\t\t\t\t\tpoint_id = offset + vertices_start\r\n\t\t\t\t\t\tnew_cluster.indices[idx] = point_id\r\n\t\t\t\t\t\tidx += 1\r\n\t\t\t\tclusters.append(new_cluster)\r\n\t\t# Post loop\r\n\t\tclusters_count = cells\r\n\t\tclusters_to_sub = Vector3i(0, (cells.x * 2) - 1, (cells.y * 2) - 1)\r\n\t\tlast_clusters = current_cell_count\r\n\r\n\t# Faces building\r\n\tvar indices : PackedInt32Array = PackedInt32Array()\r\n\tfor c : Cluster in clusters:\r\n\t\tif c.ignore:\r\n\t\t\tcontinue\r\n\t\tfor y : int in range(1, c.size - 1, 2):\r\n\t\t\tfor x : int in range(1, c.size - 1, 2):\r\n\t\t\t\tvar v_center : int = y * c.size + x\r\n\t\t\t\tvar cc : int = c.indices[v_center]\r\n\t\t\t\tvar l : int = c.indices[v_center + (TRI_FAN[0].y * c.size + TRI_FAN[0].x)]\r\n\t\t\t\tfor i : int in range(1, TRI_FAN.size()):\r\n\t\t\t\t\tvar v : Vector2i = TRI_FAN[i]\r\n\t\t\t\t\tvar n : int = c.indices[v_center + (v.y * c.size + v.x)]\r\n\t\t\t\t\tif n == -1:\r\n\t\t\t\t\t\tcontinue\r\n\t\t\t\t\tindices.append_array([cc, l , n])\r\n\t\t\t\t\tl = n\r\n\r\n\tvar normals : PackedVector3Array = PackedVector3Array()\r\n\tnormals.resize(vertices.size())\r\n\tnormals.fill(Vector3(0., -1., 0.))\r\n\tvar info : Array = []\r\n\tinfo.resize(Mesh.ARRAY_MAX)\r\n\tinfo[Mesh.ARRAY_VERTEX] = vertices\r\n\tinfo[Mesh.ARRAY_NORMAL] = normals\r\n\tinfo[Mesh.ARRAY_INDEX] = indices\r\n\r\n\treturn info\r\n```\r\n???\r\n\r\n### Placing the Mesh{#placing_mesh}\r\n\r\nThe camera and the terrain mesh will be placed thanks to a script. For practical reason, the terrain should not be a child of the camera (to allow fine camera post-adjustment like line-of-sight obstacle avoidance or terrain-dependent height adjustment).\r\n\r\nIn the following we won't detail input controls. There's already some contributions detailing this like : [Twin Sticks Third Person Controller and Camera](https:\/\/thegodotbarn.com\/contributions\/snippet\/316\/twin-sticks-third-person-controller-and-camera).\r\n\r\nFor simplicity sake, we will only provide a function taking the value of two sticks as parameters (that should have been computed inside `_input` or `_process`) and the `_process` function that will update the position of both camera and mesh.\r\n\r\nLet's consider the following parameters:\r\n```\r\n@export_subgroup(\"Camera\")\r\n# Camera node\r\n@export var camera : Camera3D\r\n# Camera rotation speed around the Y axis.\r\n@export var y_angle_speed : float = PI\r\n# Camera rotation speed around the X axis.\r\n@export var other_value_speed : float = PI\r\n\r\n# Clamping values for camera inclinaison (X axis rotation)\r\n@export var min_other_value : float = 0.1\r\n@export var max_other_value : float = PI\/2 - PI\/5\r\n\r\n# Maximum camera distance\r\n@export var max_camera_distance : float = 16.\r\n\r\n# Function between camera inclinaison and distance (for example, the more it faces the floor, the further the camera goes).\r\n@export var distance_per_other_value : Curve\r\n```\r\n\r\nThe function `manage_stick_entries` takes two `Vector2` for left and right sticks values respectively and a `delta` parameter representing the elapsed time since last call in seconds.\r\nIt relies on exported variables that specifies movement speed and camera movement limitation (in angle and distance). \r\n\r\n```\r\n@onready var current_camera_distance : float = max_camera_distance\r\n@onready var camera_distance : float = max_camera_distance\r\n\r\n@onready var y_angle : float = 0.\r\n@onready var other_value : float = 0.\r\n@onready var other_value_norm : float = 0.\r\n\r\n@onready var move_speed : float = 0\r\n\r\n@onready var move_angle : float = 0\r\n\r\nfunc manage_stick_entries(left_stick : Vector2, right_stick : Vector2, delta : float) -> void:\r\n\t# Left stick => Player movement\r\n\t# Right stick => Camera movement\r\n\ty_angle += right_stick.x * y_angle_speed * delta\r\n\tif y_angle < 0: # Value didn't vary enough to justify the use of a loop.\r\n\t\ty_angle = 2 * PI + y_angle\r\n\telif y_angle > 2 * PI:\r\n\t\ty_angle -= 2 * PI\r\n\tother_value = clampf(other_value - right_stick.y * other_value_speed * delta, min_other_value, max_other_value)\r\n\tother_value_norm = clamp(other_value_norm - right_stick.y * other_value_speed * delta, 0., 1.)\r\n\tcamera_distance = distance_per_other_value.sample_baked(other_value_norm) * max_camera_distance\r\n\tvar transformed_left : Vector2 = left_stick.rotated(y_angle) * 0.1\r\n\tmove_speed = transformed_left.length()\r\n\tif not is_zero_approx(move_speed):\r\n\t\tmove_angle = atan2(transformed_left.x, transformed_left.y)\r\n```\r\n\r\nThis now gives us enough data to proceed with actual camera and terrain placement.\r\nWe will need to designate a `Node3D` as a target for camera.\r\nAs explained earlier, value computation for left and right \"sticks\" are left to the discretion of the reader. They can be computed from inputs or other means. For the rest of this script description they will be referred as `_coming_from_controller_left` and `_coming_from_controller_right`.\r\nIn the following, `terrain` is a reference to the node holding the terrain geometry\/wandering mesh.\r\nIdeally, this node should be attached to a script that provides the height or the terrain for a given position using a function `func get_height(v : Vector2) -> float`.\r\n\r\n```\r\n@export var target : Node3D\r\n\r\n@onready var _coming_from_controller_left : Vector2 = Vector2.ZERO\r\n@onready var _coming_from_controller_right : Vector2 = Vector2.ZERO\r\n\r\nfunc _process(delta : float) -> void:\r\n\t# Left stick, Character move\r\n\t# Right stick, Camera move.\r\n\tmanage_stick_entries(_coming_from_controller_left, _coming_from_controller_right, delta)\r\n\r\n\ttarget.rotation.y = move_angle\r\n\ttarget.translate(Vector3(0, 0, move_speed * delta * p.max_speed))\r\n\r\n\tvar logical_position : Vector2 = Vector2(target.global_position.x, target.global_position.z)\r\n\ttarget.position.y = get_height(logical_position)\r\n\r\n\tvar camera_ray : Vector3 = Vector3.BACK.rotated(Vector3.LEFT, other_value).rotated(Vector3.DOWN, y_angle)\r\n\tvar cam_pos : Vector3 = target.position + camera_ray * camera_distance\r\n\tcamera.look_at_from_position(cam_pos, target.position)\r\n\t\r\n\tvar shader : ShaderMaterial = (terrain.material_override as ShaderMaterial)\r\n\tterrain.position = Vector3(camera.position.x, 0., camera.position.z)\r\n\tshader.set_shader_parameter(\"translation\", Vector2(terrain.position.x - 0.5, terrain.position.z - 0.5))\r\n\tshader.set_shader_parameter(\"rotation\", PI - camera.rotation.y)\r\n```\r\n\r\nUltimately, you can define the following in the _Project Settings_ :\r\n\r\nand add at the beginning of the `_process` function the following lines:\r\n```\r\n\t_coming_from_controller_left.x = Input.get_axis(\"player_left\", \"player_right\")\r\n\t_coming_from_controller_left.y = Input.get_axis(\"player_forward\", \"player_backward\")\r\n\t_coming_from_controller_right.x = Input.get_axis(\"camera_left\", \"camera_right\")\r\n\t_coming_from_controller_right.y = Input.get_axis(\"camera_zoom_in\", \"camera_zoom_out\")\r\n```\r\n\r\n> [!CAUTION]\r\n> I don't recommend this way of fetching controls has its pretty expensive, especially when called repeatedly in the `_process` function.\r\n\r\nThe `get_height` function in the script above allows fetching the height of the terrain for a given position. It is greatly dependent on how you manage you terrain data. In our case, we will store the terrain data in a `PackedVector3Array` called `terrain_data`. It contains the heightmap plus slope information (which are byproduct of normal computation).\r\nThe detail of the `get_height` function is shown below.\r\n\r\n??? guide Retrieve Terrain Height at a Given Position\r\nIn our particular case, we'll rely on a bi-cubic B\u00e9zier interpolation. It is the same as the one used in the shader, but applied to GDScript.\r\n\r\n```\r\nconst PATCH_OFFSET : Array[Vector2] = [\r\n\tVector2(1., 1.), Vector2(0., 1.), Vector2(1., 0.), Vector2(0., 0.)\r\n]\r\n\r\nconst PATCH_POINTS : Array[Vector4i] = [\r\n\tVector4i(0, 1, 3, 4), Vector4i(1, 2, 4, 5), Vector4i(3, 4, 6, 7), Vector4i(4, 5, 7, 8)\r\n]\r\n\r\nconst T_IDX : Array[Vector2] = [\r\n\tVector2(-1., -1.), Vector2(0., -1.), Vector2(1., -1.),\r\n\tVector2(-1., 0.), Vector2(0., 0.), Vector2(1., 0.),\r\n\tVector2(-1., 1.), Vector2(0., 1.), Vector2(1., 1.)\r\n]\r\n\r\nconst ONE_THIRD : float = 1. \/ 3.\r\n\r\nfunc get_height(pos : Vector2) -> float:\r\n\tvar global_uv : Vector2 = floor(pos)\r\n\tvar p_uv : Vector2 = pos - global_uv - Vector2(.5, .5)\r\n\tvar patch_id : int = (2 if p_uv.y > 0. else 0) + (1 if p_uv.x > 0. else 0)\r\n\r\n\tvar l_uv : Vector2 = p_uv + PATCH_OFFSET[patch_id]\r\n\tvar control_points : Vector4i = PATCH_POINTS[patch_id]\r\n\r\n\tvar map_size : Vector2 = Vector2(terrain_size)\r\n\tvar factor : Vector2 = (map_size - Vector2(1., 1.)) \/ map_size\r\n\tvar uv : Vector2 = global_uv + Vector2(.5, .5)\r\n\tvar mp0 : Vector2 = clamp((uv + T_IDX[control_points.x]), Vector2.ZERO, map_size) * factor\r\n\tvar mp1 : Vector2 = clamp((uv + T_IDX[control_points.y]), Vector2.ZERO, map_size) * factor\r\n\tvar mp2 : Vector2 = clamp((uv + T_IDX[control_points.z]), Vector2.ZERO, map_size) * factor\r\n\tvar mp3 : Vector2 = clamp((uv + T_IDX[control_points.w]), Vector2.ZERO, map_size) * factor\r\n\tvar idx0 : int = round(mp0.y) * terrain_size.x + round(mp0.x)\r\n\tvar idx1 : int = round(mp1.y) * terrain_size.x + round(mp1.x)\r\n\tvar idx2 : int = round(mp2.y) * terrain_size.x + round(mp2.x)\r\n\tvar idx3 : int = round(mp3.y) * terrain_size.x + round(mp3.x)\r\n\tvar p0 : Vector3 = Vector3(T_IDX[control_points.x].x, terrain_data[idx0].x, T_IDX[control_points.x].y)\r\n\tvar p1 : Vector3 = Vector3(T_IDX[control_points.y].x, terrain_data[idx1].x, T_IDX[control_points.y].y)\r\n\tvar p2 : Vector3 = Vector3(T_IDX[control_points.z].x, terrain_data[idx2].x, T_IDX[control_points.z].y)\r\n\tvar p3 : Vector3 = Vector3(T_IDX[control_points.w].x, terrain_data[idx3].x, T_IDX[control_points.w].y)\r\n\tvar sl0 : Vector2 = Vector2(terrain_data[idx0].y, terrain_data[idx0].z)\r\n\tvar sl1 : Vector2 = Vector2(terrain_data[idx1].y, terrain_data[idx1].z)\r\n\tvar sl2 : Vector2 = Vector2(terrain_data[idx2].y, terrain_data[idx2].z)\r\n\tvar sl3 : Vector2 = Vector2(terrain_data[idx3].y, terrain_data[idx3].z)\r\n\r\n\t# Time to run bezier interpolation\r\n\tvar t : float = l_uv.x; var m_t : float = 1. - t; var t2 : float = t * t; var m_t2 : float = m_t * m_t\r\n\tvar ktu : Vector4 = Vector4(m_t2 * m_t, 3. * t * m_t2, 3. * t2 * m_t, t2 * t)\r\n\tt = l_uv.y; m_t = 1. - t; t2 = t * t; m_t2 = m_t * m_t\r\n\tvar ktv : Vector4 = Vector4(m_t2 * m_t, 3. * t * m_t2, 3. * t2 * m_t, t2 * t)\r\n\r\n\tvar b0 : Vector3; var b1 : Vector3; var b2 : Vector3; var b3 : Vector3\r\n\tvar u0 : Vector3; var u1 : Vector3; var u2 : Vector3; var u3 : Vector3\r\n\r\n\t# First and second curves slopes\r\n\tvar x0_slope : float = sl0.x; var z0_slope : float = sl0.y; var x1_slope : float = sl2.x; var z1_slope : float = sl2.y;\r\n\tvar shift_0 : Vector3 = Vector3.ZERO; var shift_1 : Vector3 = Vector3.ZERO\r\n\tshift_0.x = ONE_THIRD; shift_0.y = x0_slope; shift_0.z = 0.\r\n\tshift_1.x = ONE_THIRD; shift_1.y = x1_slope; shift_1.z = 0.\r\n\t# First curve interpolation\r\n\tb0 = Vector3(p0); b1 = Vector3(p0.x, p0.y + z0_slope, p0.z + ONE_THIRD)\r\n\tb2 = Vector3(p2.x, p2.y - z1_slope, p2.z - ONE_THIRD)\r\n\tb3 = Vector3(p2)\r\n\tu0 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)\r\n\t# Second curve interpolation\r\n\tb0 += shift_0; b1 += shift_0; b2 += shift_1; b3 += shift_1\r\n\tu1 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)\r\n\t# Third and fourth curves slopes\r\n\tx0_slope = sl1.x; z0_slope = sl1.y; x1_slope = sl3.x; z1_slope = sl3.y\r\n\tshift_0.y = x0_slope; shift_1.y = x1_slope\r\n\t# Fourth curve interpolation\r\n\tb0 = Vector3(p1); b1 = Vector3(p1.x, p1.y + z0_slope, p1.z + ONE_THIRD)\r\n\tb2= Vector3(p3.x, p3.y - z1_slope, p3.z - ONE_THIRD); b3 = Vector3(p3)\r\n\tu3 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)\r\n\t# Third curve interpolation\r\n\tb0 -= shift_0; b1 -= shift_0; b2 -= shift_1; b3 -= shift_1\r\n\tu2 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)\r\n\r\n\t# Final point\r\n\treturn ((ktu.x * u0) + (ktu.y * u1) + (ktu.z * u2) + (ktu.w * u3)).y\r\n```\r\n???\r\n\r\n\r\nIn the scripts above, we hinted the shader parameters that will permit the mesh transformation. This part is fully described [in this section](#render_section).\r\n\r\n### Creating the Terrain\r\nTo create the terrain, we will reuse one of the Godot Barn contribution : [Small Terrain Generator](https:\/\/thegodotbarn.com\/contributions\/snippet\/422\/small-terrain-generator). However, we won't use the whole `MultiMeshInstance3D` part. Given a noise function (using a `Noise` resource), let's compute a heightmap and most importantly, generate the terrain data texture. This can be summed up into a simple function as follow:\r\n\r\n```\r\n# We keep this info for further using (finding the height of the terrain at a particular position).\r\n@onready var terrain_data : PackedVector3Array = PackedVector3Array()\r\n\r\nfunc compute_terrain_data(noise : Noise, height : float, sea_level : float, size : Vector2i) -> ImageTexture:\r\n\t# Generate the terrain.\r\n\tvar count : int = size.x * size.y\r\n\tvar heights : PackedFloat32Array = PackedFloat32Array()\r\n\theights.resize(count)\r\n\tterrain_data.resize(count)\r\n\r\n\t# Compute Heights --------------------------------------------------------\r\n\tvar idx : int = 0\r\n\tfor y : int in range(size.y):\r\n\t\tfor x : int in range(size.x):\r\n\t\t\theights[idx] = max(sea_level, noise.get_noise_2d(x, y)) * height\r\n\t\t\tidx += 1\r\n\r\n\t# Compute Texture Data ---------------------------------------------------\r\n\tidx = 0\r\n\tfor y : int in range(size.y):\r\n\t\tfor x : int in range(size.x):\r\n\t\t\tvar h : float = heights[idx]\r\n\t\t\tvar hmx : float = heights[idx - 1] if x > 0 else h\r\n\t\t\tvar hpx : float = heights[idx + 1] if x < size.x - 1 else h\r\n\t\t\tvar hmz : float = heights[idx - size.x] if y > 0 else h\r\n\t\t\tvar hpz : float = heights[idx + size.x] if y < size.y - 1 else h\r\n\t\t\tvar dX : float = hmx - hpx\r\n\t\t\tvar dZ : float = hmz - hpz\r\n\t\t\tvar n : Vector3 = Vector3(dX, 2., dZ).normalized()\r\n\t\t\tn.y *= -3.\r\n\t\t\tterrain_data[idx] = Vector3(h, n.x \/ n.y, n.z \/ n.y)\r\n\t\t\tidx += 1\r\n\tvar image : Image = Image.create_from_data(size.x, size.y, false, Image.FORMAT_RGBF, terrain_data.to_byte_array())\r\n\treturn ImageTexture.create_from_image(image)\r\n```\r\n\r\n> [!CAUTION]\r\n> In order to avoid some terrain disappearance while moving the camera, don't forget to set the *\"Extra Cull Margin\"* property to a value greater than 0.\r\n> \r\n\r\n### Rendering the Terrain{#render_terrain}\r\n\r\nTerrain rendering is done using a shader that will adapt vertices position (mosty elevation) according to the texture data generated in the previous section.\r\nFirst, we need to set this info as uniform. It is done once per terrain loading.\r\n\r\n```\r\n\tvar shader : ShaderMaterial = (terrain.material_override as ShaderMaterial)\r\n\tshader.set_shader_parameter(\"terrain_size\", Vector2(size))\r\n\tshader.set_shader_parameter(\"data_tex\", compute_terrain_data(noise, max_height, seal_level, size))\r\n```\r\n\r\nAs we have seen in the [previous section about placing the terrain mesh](#placing_mesh), at each camera update, we will need to update other shader parameters using:\r\n```\r\n\tshader.set_shader_parameter(\"translation\", Vector2(terrain.position.x - 0.5, terrain.position.z - 0.5))\r\n\tshader.set_shader_parameter(\"rotation\", PI - camera.rotation.y)\r\n```\r\n\r\nNow, here comes the shader !\r\nBut first, just a quick reminder. This is based on the previous contribution [Small Terrain Generator](https:\/\/thegodotbarn.com\/contributions\/snippet\/422\/small-terrain-generator) where terrain is meant to be small (128x128) but interpolated using bi-cubic B\u00e9zier interpolation (a \"mathy\" trick to make it look bigger). The subsequent shader is the following:\r\n\r\n??? guide Terrain Shader\r\n```glsl\r\nshader_type spatial;\r\nconst float ONE_THIRD = 1.\/3.;\r\n\r\nconst vec2 PATCH_OFFSET[4] = {\r\n\tvec2( 1., 1.), vec2( 0., 1.), vec2( 1., 0.), vec2( 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\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 transforms;\r\n\r\nuniform vec2 translation;\r\n\r\nuniform float rotation;\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_thickness : 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\tfloat cs = cos(rotation), sn = sin(rotation);\r\n\tvec2 a = vec2(VERTEX.x, VERTEX.z);\r\n\tvec2 global_uv = vec2(a.x * cs - a.y * sn + translation.x, a.x * sn + a.y * cs + translation.y);\r\n\tvec2 patch_uv = fract(global_uv);\r\n\tvec2 instance_uv = global_uv - patch_uv;\r\n\tif(patch_uv.x > 0.5) {\r\n\t\tpatch_uv.x -= 1.;\r\n\t\tinstance_uv.x += 1.;\r\n\t}\r\n\tif(patch_uv.y > 0.5) {\r\n\t\tpatch_uv.y -= 1.;\r\n\t\tinstance_uv.y += 1.;\r\n\t}\r\n\r\n\tp_uv = global_uv;\r\n\tvec3 v, n, t, bt;\r\n\tcompute_from_uv(patch_uv, instance_uv, data_tex, terrain_size, v, n, t, bt);\r\n\r\n\tvec3 vn = NORMAL;\r\n\tNORMAL = n;\r\n\tVERTEX = v + vec3(instance_uv.x - translation.x, 0., instance_uv.y - translation.y);\r\n}\r\n\r\nvoid fragment() {\r\n\tif(p_uv.x < 0. || p_uv.x > terrain_size.x || p_uv.y < 0. || p_uv.y > terrain_size.y) {\r\n\t\tdiscard;\r\n\t}\r\n\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\tvec2 b_uv = fract(p_uv);\r\n\tbool border = (b_uv.x < border_thickness) || (b_uv.y < 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\nFor demonstration purpose, it contains additional parameters to render a checker surface.\r\n\r\n### Final thoughts\r\n\r\nAs always, don't hesitate to comment, reach out, here or on our Discord server or even on Bluesky for any question.\r\n\r\n> [!NOTE]\r\n> A git repository containing a minimal demonstration Godot project will be available soon."

Screenshots

Main code

extends Node3D

@export_subgroup("Scene")

@export var terrain : MeshInstance3D
@export var camera : Camera3D
@export var target : Node3D

@export_subgroup("Terrain", "terrain_")

# Noise to generate terrain
@export var terrain_noise : Noise
# Max height (as noise is normalized in [-1, 1]
@export var terrain_height : float = 16.
# Sea level : Terrain height will be clamped below this level
@export var terrain_sea_level : float = -8.
# Terrain size
@export var terrain_size : Vector2i = Vector2i(128, 128)

@export_subgroup("Camera")
# Camera rotation speed around the Y axis.
@export var y_angle_speed : float = PI
# Camera rotation speed around the X axis.
@export var other_value_speed : float = PI

# Clamping values for camera inclinaison (X axis rotation)
@export var min_other_value : float = 0.1
@export var max_other_value : float = PI/2 - PI/5

# Maximum camera distance
@export var max_camera_distance : float = 16.

# Function between camera inclinaison and distance (for example, the more it faces the floor, the further the camera goes).
@export var distance_per_other_value : Curve

@export_subgroup("Subject")
# Maximum target speed in unit/s
@export var max_speed : float = 16.

@onready var camera_distance : float = max_camera_distance

@onready var y_angle : float = PI/4.
@onready var other_value : float = 0.5
@onready var other_value_norm : float = 0.5

@onready var move_speed : float = 0

@onready var move_angle : float = 0

@onready var target_offset_y : float

func _ready() -> void:
	assert(terrain_noise)
	assert(terrain_size.x > 0 and terrain_size.y > 0)
	assert(distance_per_other_value)
	var terrain_tex : ImageTexture = compute_terrain_data(terrain_noise, terrain_height, terrain_sea_level, terrain_size)

	target_offset_y = (target.mesh as CapsuleMesh).height / 2 # WARNING Only works if target main mesh is a capsule
	target.position.x = terrain_size.x / 2.
	target.position.z = terrain_size.y / 2.
	target.position.y = get_height(Vector2(target.position.x, target.position.z)) + target_offset_y
	camera_distance = distance_per_other_value.sample_baked(other_value_norm) * max_camera_distance
	compute_camera_position()
	terrain.position = Vector3(camera.position.x, 0., camera.position.z)

	var shader : ShaderMaterial = (terrain.material_override as ShaderMaterial)
	shader.set_shader_parameter("terrain_size", Vector2(terrain_size))
	shader.set_shader_parameter("data_tex", terrain_tex)
	shader.set_shader_parameter("translation", Vector2(terrain.position.x - 0.5, terrain.position.z - 0.5))
	shader.set_shader_parameter("rotation", PI - camera.rotation.y)

func manage_stick_entries(left_stick : Vector2, right_stick : Vector2, delta : float) -> void:
	# Left stick => Player movement
	# Right stick => Camera movement
	y_angle += right_stick.x * y_angle_speed * delta
	if y_angle < 0: # Value didn't vary enough to justify the use of a loop.
		y_angle = 2 * PI + y_angle
	elif y_angle > 2 * PI:
		y_angle -= 2 * PI
	other_value = clampf(other_value - right_stick.y * other_value_speed * delta, min_other_value, max_other_value)
	other_value_norm = clamp(other_value_norm - right_stick.y * other_value_speed * delta, 0., 1.)
	camera_distance = distance_per_other_value.sample_baked(other_value_norm) * max_camera_distance
	var transformed_left : Vector2 = left_stick.rotated(y_angle) * 0.1
	move_speed = transformed_left.length()
	if not is_zero_approx(move_speed):
		move_angle = atan2(transformed_left.x, transformed_left.y)

@onready var _coming_from_controller_left : Vector2 = Vector2.ZERO
@onready var _coming_from_controller_right : Vector2 = Vector2.ZERO

func compute_camera_position() -> void:
	var camera_ray : Vector3 = Vector3.BACK.rotated(Vector3.LEFT, other_value).rotated(Vector3.DOWN, y_angle)
	var cam_pos : Vector3 = target.position + camera_ray * camera_distance
	camera.look_at_from_position(cam_pos, target.position)

func _process(delta : float) -> void:
	# Left stick, Character move
	# Right stick, Camera move.
	_coming_from_controller_left.x =  Input.get_axis("player_left", "player_right")
	_coming_from_controller_left.y =  Input.get_axis("player_forward", "player_backward")
	_coming_from_controller_right.x =  Input.get_axis("camera_left", "camera_right")
	_coming_from_controller_right.y =  Input.get_axis("camera_zoom_in", "camera_zoom_out")

	manage_stick_entries(_coming_from_controller_left, _coming_from_controller_right, delta)

	target.rotation.y = move_angle
	target.translate(Vector3(0, 0, move_speed * delta * max_speed))

	var logical_position : Vector2 = Vector2(target.position.x, target.position.z)
	target.position.y = get_height(logical_position) + target_offset_y

	compute_camera_position()

	var shader : ShaderMaterial = (terrain.material_override as ShaderMaterial)
	terrain.position = Vector3(camera.position.x, 0., camera.position.z)
	shader.set_shader_parameter("translation", Vector2(terrain.position.x - 0.5, terrain.position.z - 0.5))
	shader.set_shader_parameter("rotation", PI - camera.rotation.y)

@onready var terrain_data : PackedVector3Array = PackedVector3Array()

func compute_terrain_data(noise : Noise, height : float, sea_level : float, size : Vector2i) -> ImageTexture:
	# Generate the terrain.
	var count : int = size.x * size.y
	var heights : PackedFloat32Array = PackedFloat32Array()
	heights.resize(count)
	terrain_data.resize(count)

	# Compute Heights --------------------------------------------------------
	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

	# Compute Texture Data ---------------------------------------------------
	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.
			terrain_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, terrain_data.to_byte_array())
	return ImageTexture.create_from_image(image)

const PATCH_OFFSET : Array[Vector2] = [
	Vector2(1., 1.), Vector2(0., 1.), Vector2(1., 0.), Vector2(0., 0.)
]

const PATCH_POINTS : Array[Vector4i] = [
	Vector4i(0, 1, 3, 4), Vector4i(1, 2, 4, 5), Vector4i(3, 4, 6, 7), Vector4i(4, 5, 7, 8)
]

const T_IDX : Array[Vector2] = [
	Vector2(-1., -1.), Vector2(0., -1.), Vector2(1., -1.),
	Vector2(-1., 0.), Vector2(0., 0.), Vector2(1., 0.),
	Vector2(-1., 1.), Vector2(0., 1.), Vector2(1., 1.)
]

const ONE_THIRD : float = 1. / 3.

func get_height(pos : Vector2) -> float:
	var global_uv : Vector2 = floor(pos)
	var p_uv : Vector2 = pos - global_uv - Vector2(.5, .5)
	var patch_id : int = (2 if p_uv.y > 0. else 0) + (1 if p_uv.x > 0. else 0)

	var l_uv : Vector2 = p_uv + PATCH_OFFSET[patch_id]
	var control_points : Vector4i = PATCH_POINTS[patch_id]

	var map_size : Vector2 = Vector2(terrain_size)
	var factor : Vector2 = (map_size - Vector2(1., 1.)) / map_size
	var uv : Vector2 = global_uv + Vector2(.5, .5)
	var mp0 : Vector2 = clamp((uv + T_IDX[control_points.x]), Vector2.ZERO, map_size) * factor
	var mp1 : Vector2 = clamp((uv + T_IDX[control_points.y]), Vector2.ZERO, map_size) * factor
	var mp2 : Vector2 = clamp((uv + T_IDX[control_points.z]), Vector2.ZERO, map_size) * factor
	var mp3 : Vector2 = clamp((uv + T_IDX[control_points.w]), Vector2.ZERO, map_size) * factor
	var idx0 : int = round(mp0.y) * terrain_size.x + round(mp0.x)
	var idx1 : int = round(mp1.y) * terrain_size.x + round(mp1.x)
	var idx2 : int = round(mp2.y) * terrain_size.x + round(mp2.x)
	var idx3 : int = round(mp3.y) * terrain_size.x + round(mp3.x)
	var p0 : Vector3 = Vector3(T_IDX[control_points.x].x, terrain_data[idx0].x, T_IDX[control_points.x].y)
	var p1 : Vector3 = Vector3(T_IDX[control_points.y].x, terrain_data[idx1].x, T_IDX[control_points.y].y)
	var p2 : Vector3 = Vector3(T_IDX[control_points.z].x, terrain_data[idx2].x, T_IDX[control_points.z].y)
	var p3 : Vector3 = Vector3(T_IDX[control_points.w].x, terrain_data[idx3].x, T_IDX[control_points.w].y)
	var sl0 : Vector2 = Vector2(terrain_data[idx0].y, terrain_data[idx0].z)
	var sl1 : Vector2 = Vector2(terrain_data[idx1].y, terrain_data[idx1].z)
	var sl2 : Vector2 = Vector2(terrain_data[idx2].y, terrain_data[idx2].z)
	var sl3 : Vector2 = Vector2(terrain_data[idx3].y, terrain_data[idx3].z)

	# Time to run bezier interpolation
	var t : float = l_uv.x; var m_t : float = 1. - t; var t2 : float = t * t; var m_t2 : float = m_t * m_t
	var ktu : Vector4 = Vector4(m_t2 * m_t, 3. * t * m_t2, 3. * t2 * m_t, t2 * t)
	t = l_uv.y; m_t = 1. - t; t2 = t * t; m_t2 = m_t * m_t
	var ktv : Vector4 = Vector4(m_t2 * m_t, 3. * t * m_t2, 3. * t2 * m_t, t2 * t)

	var b0 : Vector3; var b1 : Vector3; var b2 : Vector3; var b3 : Vector3
	var u0 : Vector3; var u1 : Vector3; var u2 : Vector3; var u3 : Vector3

	# First and second curves slopes
	var x0_slope : float = sl0.x; var z0_slope : float = sl0.y; var x1_slope : float = sl2.x; var z1_slope : float = sl2.y;
	var shift_0 : Vector3 = Vector3.ZERO; var shift_1 : Vector3 = Vector3.ZERO
	shift_0.x = ONE_THIRD; shift_0.y = x0_slope; shift_0.z = 0.
	shift_1.x = ONE_THIRD; shift_1.y = x1_slope; shift_1.z = 0.
	# First curve interpolation
	b0 = Vector3(p0); b1 = Vector3(p0.x, p0.y + z0_slope, p0.z + ONE_THIRD)
	b2 = Vector3(p2.x, p2.y - z1_slope, p2.z - ONE_THIRD)
	b3 = Vector3(p2)
	u0 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)
	# Second curve interpolation
	b0 += shift_0; b1 += shift_0; b2 += shift_1; b3 += shift_1
	u1 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)
	# Third and fourth curves slopes
	x0_slope = sl1.x; z0_slope = sl1.y; x1_slope = sl3.x; z1_slope = sl3.y
	shift_0.y = x0_slope; shift_1.y = x1_slope
	# Fourth curve interpolation
	b0 = Vector3(p1); b1 = Vector3(p1.x, p1.y + z0_slope, p1.z + ONE_THIRD)
	b2= Vector3(p3.x, p3.y - z1_slope, p3.z - ONE_THIRD); b3 = Vector3(p3)
	u3 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)
	# Third curve interpolation
	b0 -= shift_0; b1 -= shift_0; b2 -= shift_1; b3 -= shift_1
	u2 = (ktv.x * b0) + (ktv.y * b1) + (ktv.z * b2) + (ktv.w * b3)

	# Final point
	return ((ktu.x * u0) + (ktu.y * u1) + (ktu.z * u2) + (ktu.w * u3)).y

Comments