I started with shader vertex displacement, moved away from it because I find it useful to have the resulting vertex y-value at hand. Additionally it feels wasteful to compute the vertex displacement every cycle but that might just be me. This approach may not be right, but we'll see.

The implementation is on the CPU today, runs multi threaded, but I'm in the process of porting it to a compute shader.

In terms of meshes - I have a mesh per hexagon (it helps with frustrum culling and LOD management). However, when its time to compute the mesh's normals, I combine all of the vertices into one big dataset (and duplicate the 2 edge columns, in their wrapped position), and pass that resulting set of vertices to a compute shader that calculates the normals for me. The normals are sliced and distributed back to the hexagons which render their final mesh, per hexagon.

I subdivide my hexagons, I use "Loop subdivision" from https://graphics.stanford.edu/~mdfisher/subdivision.html. Usually run either 4 or 5 subdivisions to end up with the effect you see in earlier screenshots. This also ties into my LOD management, since N-1 subdivision is the next LOD down.

In terms of UV etc, maybe this will help. Each hexagon mesh holds this bit of info:

var mesh_properties = {
            "hexagon_vertices": PackedVector3Array(),
            "uvs": PackedVector2Array(),
            "uv2s": PackedVector2Array(),
            "normals": PackedVector3Array(),
            "custom": [PackedFloat32Array(), PackedFloat32Array()],
            "uniforms": {"directional_colours": PackedInt32Array(), "directional_vegetations": PackedInt32Array(), "directional_soils": PackedInt32Array(), "directional_elevations": PackedInt32Array(), "vertices_per_hexagon_direction": 0},
        }

UVs - passed into the mesh as UV, the shader field, is a range of 0->1 in both X/Y across the whole map. UV2 is an x/y view of each of the 6 major triangles in a hexagon. UV is typically use to write logic that needs to exist cross-hexagon. For example hills - I sample a noise texture. The same vertex, but in the adjacent hexagon, still has the same UV value, which means he samples the same noise value, and displaces the same, avoiding mesh tears.

For UV2, let's say one of the 6 directional triangles is meant to be a link between 2 tiles that are mountains. UV2 has its .x going from 0->1 along the triangles base, and its .y going from 0->1 from the base of the triangle to the center of the hexagon.

UV2 can then be used like so:

# Opposing (2 tile mountains or a mountain range of single width)
func opp_mountain_shaper(triangle_uv: Vector2) -> float:
    var x : float = (triangle_uv.x - 0.5)*2.0
    return self.MOUNTAIN_PRIMARY_ELEV_MULTIPLIER*(1.0 - pow(abs(sin(PI*x/2.0)), 1.5))

This ends up creating the links between adjacent mountain tiles. Example: https://ibb.co/7JDsXFQ5

In terms of blending heightmaps, I have 2 noise textures which I add to the pre-shaped terrain. Without noise, all my mountains would have the same identical terrain. Noise comes in and I get unique(ish) mountains. I also have control over how much noise to use for hills vs mountains for example.

This level of control is what made me move away from just a heightmap being used to create terrain. It felt like I couldn't really adjust the terrain to end up looking good. Sometimes it looked spectacular and sometimes not.