Unity Earth Height Map Mesh

Question

Trying to create a mesh that uses heights from an earth height map, but running into a couple of issues.

Height map from https://en.wikipedia.org/wiki/Heightmap#/media/File:World_elevation_map.png

• When I increase resolution, the mesh starts folding in on itself (could be because of Unity max vertex limit??)
• I think I can start making out some continents, but mostly just giant mountains.
• Smaller heights are non existent, just mountain looking objects.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;

public class FlatEarth : MonoBehaviour
{

    const int MAP_HEIGHT = 16384; // magic number refers to resolution of map
    const int MAP_WIDTH = 8192;

    [Range(2, 256)]
    public int resolution = 10;

    [Range(1, 100)]
    public int mapSize = 10;

    GameObject meshObj;
    MeshFilter meshFilter;
    Mesh mesh;

    Vector3 localUp = Vector3.up;
    Vector3 axisA;
    Vector3 axisB;

    float[] heightMap;

    // Start is called before the first frame update
    void Start()
    {
        Initialize();
    }

    // Update is called once per frame
    void Update()
    {
        
    }

    private void OnValidate()
    {
        ConstructMesh();
    }

    private void Initialize()
    {
        GameObject meshObj = new GameObject("mesh");
        meshObj.transform.parent = transform;
        meshObj.AddComponent<MeshRenderer>();

        MeshFilter meshFilter = meshObj.AddComponent<MeshFilter>();
        meshFilter.sharedMesh = new Mesh();

        this.meshObj = meshObj;
        this.meshFilter = meshFilter;
        this.mesh = meshFilter.sharedMesh;
        this.mesh.indexFormat = IndexFormat.UInt32;

        axisA = new Vector3(localUp.y, localUp.z, localUp.x);
        axisB = Vector3.Cross(localUp, axisA);

        LoadHeights();
        ConstructMesh();
    }


    /*
     * There's some weird mesh error going on when you raise the resolution too high
     * 
     */
    public void ConstructMesh()
    {
        int xResolution = 2 * resolution;
        int yResolution = resolution;

        Vector3[] vertices = new Vector3[(xResolution + 1) * (yResolution + 1)];
        int[] triangles = new int[xResolution * yResolution * 6];


        // Construct verticies
        for(int y = 0, vertexIndex = 0; y <= yResolution; y++)
        {
            for (int x = 0; x <= xResolution; x++, vertexIndex++)
            {
                vertices[vertexIndex] = (mapSize * x * axisB + mapSize * y * axisA) * 0.5f / Mathf.Sqrt(Mathf.Pow(resolution, 2) + 4 * Mathf.Pow(resolution, 2));

                int closestPixelIndex = GetClosestPixelIndex(new Vector2(x, y));
                float height = heightMap[closestPixelIndex];
                vertices[vertexIndex] += localUp * height;


            }
        }

        // Construct triangles
        for(int y = 0, triangleIndex = 0, vertexIndex = 0; y < yResolution; y++, vertexIndex++)
        {
            for (int x = 0; x < xResolution; x++, vertexIndex++, triangleIndex += 6)
            {
                triangles[triangleIndex] = vertexIndex;
                triangles[triangleIndex + 1] = vertexIndex + xResolution + 1;
                triangles[triangleIndex + 2] = vertexIndex + 1;

                triangles[triangleIndex + 3] = vertexIndex + 1;
                triangles[triangleIndex + 4] = vertexIndex + xResolution + 1;
                triangles[triangleIndex + 5] = vertexIndex + xResolution + 2;
            }
        }


        mesh.Clear();
        mesh.vertices = vertices;
        mesh.triangles = triangles;
        mesh.RecalculateNormals();
    }

    public void LoadHeights()
    {
        // Load map as a texture 2D
        Texture2D heightTexture = Resources.Load<Texture2D>("EarthHeightMap");

        // Load each pixel of texture
        Color[] colorMap = heightTexture.GetPixels();

        // Initialize height map 
        float[] heightMap = new float[colorMap.Length];

        // Loop through each pixel and convert to a height
        for(int y = 0, index = 0; y < MAP_HEIGHT; y++)
        {
            for(int x = 0; x < MAP_WIDTH; x++, index++)
            {

                Color pixelColor = colorMap[index];

                float height = pixelColor.a; // color stored in alpha channel

                heightMap[index] = height; // might need to apply some sort of transform
            }
        }
        this.heightMap = heightMap;
    }

    public int GetClosestPixelIndex(Vector2 vertex)
    {
        Vector2 percent = new Vector2(vertex.x / (resolution * 2 + 1), vertex.y / (resolution + 1)); 
        int x = Mathf.FloorToInt(percent.x * MAP_WIDTH);
        int y = Mathf.FloorToInt(percent.y * MAP_HEIGHT);

        int index = x + y * MAP_WIDTH;
        return index;
    }

}