Unity2D　エラー　OutOfMemoryException

文字数制限があったため、World.csスクリプトを本文に記入出来ませんでした。なので、ここに書き込みます。

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class World : MonoBehaviour
{
    private const int TypeCountMax = 8;

    private static readonly int TypeCountProperty = Shader.PropertyToID("_TypeCount");
    private static readonly int TypeUvsProperty = Shader.PropertyToID("_TypeUvs");
    private static readonly int TileSizeProperty = Shader.PropertyToID("_TileSize");
    private static readonly int TypeLevelsProperty = Shader.PropertyToID("_TypeLevels");

    public int width { get; private set; }
    public int height { get; private set; }

    public Tile[,] tiles;

    public Material material;

    Mesh mesh;

    public string seed;
    public bool randomSeed;

    public float frequency;
    public float amplitude;

    public float lacunarity;
    public float persistance;

    public int octaves;

    Noise noise;

    public float seaLevel;
    public float beachEndHeight;
    public float grassEndHeight;
    public float dirtEndHeight;
    public float stoneEndHeight;

    int typeCount;
    List<Vector4> typeUvs;
    Vector4 tileSize;
    float[] typeLevels;

    public List<Vector2> WaterCoordinates = new List<Vector2>();
    public List<Vector2> NotWaterCoordinates = new List<Vector2>();
    public List<Vector2> GrassCoordinates = new List<Vector2>();
    public List<Vector2> GrassCoordinates2 = new List<Vector2>();
    public List<Vector2> LotusCoordinates = new List<Vector2>();

    public static World instance { get; private set; }

    private void Awake()
    {
        instance = this;

        width = 100;
        height = 100;

        if (randomSeed == true)
        {
            int value = Random.Range(-1000, 10000);
            seed = value.ToString();
        }

        noise = new Noise(seed.GetHashCode(), frequency, amplitude, lacunarity, persistance, octaves);
    }

    // Use this for initialization
    void Start()
    {
        CreateTiles();
        GenerateMesh();
    }

    // Update is called once per frame
    void Update()
    {
        this.material.SetInt(TypeCountProperty, this.typeCount);
        this.material.SetVectorArray(TypeUvsProperty, this.typeUvs);
        this.material.SetVector(TileSizeProperty, this.tileSize);
        this.material.SetFloatArray(TypeLevelsProperty, this.typeLevels);

        Graphics.DrawMesh(mesh, Vector3.zero, Quaternion.identity, material, 0);
    }

    void CreateTiles()
    {
        (Tile.Type, float)[] types = new[]
        {
            (Tile.Type.Water, this.seaLevel),
            (Tile.Type.Sand, this.beachEndHeight),
            (Tile.Type.Grass, this.grassEndHeight),
            (Tile.Type.Dirt, this.dirtEndHeight),
            (Tile.Type.Grass2, this.stoneEndHeight)
        }.OrderBy(pair => pair.Item2).Take(TypeCountMax).ToArray();

        this.tiles = new Tile[this.width, this.height];

        float[,] noiseValues = this.noise.GetNoiseValues(this.width + 1, this.height + 1);

        for (int i = 0; i < this.width; i++)
        {
            for (int j = 0; j < this.height; j++)
            {
                Vector4 weights = new Vector4(noiseValues[i, j], noiseValues[i + 1, j], noiseValues[i, j + 1], noiseValues[i + 1, j + 1]);

                float averageWeight = Vector4.Dot(weights, Vector4.one) * 0.25f;

                var type = types.Where(t => averageWeight < t.Item2).DefaultIfEmpty(types.Last()).Last().Item1;

                this.tiles[i, j] = new Tile(type, weights);

                if(averageWeight < seaLevel + 0.05f)
                {
                    Vector2 pos = new Vector2(i, j);
                    WaterCoordinates.Add(pos);
                }

                if (averageWeight < seaLevel - 0.1f)
                {
                    Vector2 pos = new Vector2(i, j);
                    LotusCoordinates.Add(pos);
                }

                Vector2 allpos = new Vector2(i, j);
                NotWaterCoordinates.Add(allpos);
                GrassCoordinates.Add(allpos);
                GrassCoordinates2.Add(allpos);
            }
        }

        for (var i = 0;i < width; i++)
        {
            for(var j = 0;j < height; j++)
            {
                Vector2 randomPos = new Vector2(i, j);
                var random = Random.Range(0, 100);
                if(random < 99)
                {
                    NotWaterCoordinates.Remove(randomPos);
                }
            }
        }

        for (float i = 0; i < width; i++)
        {
            for (float j = 0; j < height; j++)
            {
                Vector2 randomPos = new Vector2(i, j);
                var random = Random.Range(0, 100);
                if (random < 60)
                {
                    GrassCoordinates.Remove(randomPos);
                }
            }
        }

        for (float i = 0; i < width; i++)
        {
            for (float j = 0; j < height; j++)
            {
                Vector2 randomPos = new Vector2(i, j);
                var random = Random.Range(0, 100);
                if (random < 90)
                {
                    GrassCoordinates2.Remove(randomPos);
                }
            }
        }

        for (var i = 0; i < width; i++)
        {
            for (var j = 0; j < height; j++)
            {
                Vector2 randomPos = new Vector2(i, j);
                var random = Random.Range(0, 100);
                if (random < 99)
                {
                    LotusCoordinates.Remove(randomPos);
                }
            }
        }

        for (var i = 0; i < WaterCoordinates.Count; i++)
        {
            if (NotWaterCoordinates.Contains(WaterCoordinates[i]))
            {
                NotWaterCoordinates.Remove(WaterCoordinates[i]);
            }
            if (GrassCoordinates.Contains(WaterCoordinates[i]))
            {
                GrassCoordinates.Remove(WaterCoordinates[i]);
            }
            if (GrassCoordinates2.Contains(WaterCoordinates[i]))
            {
                GrassCoordinates2.Remove(WaterCoordinates[i]);
            }
        }

        for(var i = 0;i < NotWaterCoordinates.Count; i++)
        {
            GrassCoordinates.Remove(NotWaterCoordinates[i]);
            GrassCoordinates2.Remove(NotWaterCoordinates[i]);
        }

        for(var i = 0;i < GrassCoordinates.Count; i++)
        {
            GrassCoordinates2.Remove(GrassCoordinates[i]);
        }

        GrassAdd();

        int typesLength = types.Length;
        int uvVectorCount = (typesLength / 2) + (typesLength % 2);
        List<Vector4> uvVectors = new List<Vector4>(uvVectorCount);
        for (int i = 0; i < uvVectorCount; i++)
        {
            int j = i * 2;
            Tile.Type type1 = types[j].Item1;
            Tile.Type type2 = (j < typesLength - 1) ? types[j + 1].Item1 : Tile.Type.Void;
            Vector2 uv1 = SpriteLoader.instance.GetTileUVs(type1)[0];
            Vector2 uv2 = SpriteLoader.instance.GetTileUVs(type2)[0];
            uvVectors.Add(new Vector4(uv1.x, uv1.y, uv2.x, uv2.y));        
        }

        Vector2[] voidUvs = SpriteLoader.instance.GetTileUVs(Tile.Type.Void);
        Vector2 size = voidUvs[3] - voidUvs[0];

        this.typeCount = types.Length;
        this.typeUvs = uvVectors;
        this.tileSize = size;
        this.typeLevels = types.Select(t => t.Item2).ToArray();
    }

    void GrassAdd()
    {
        for (var i = 0; i < GrassCoordinates.Count; i++)
        {
            Vector2 centerPos = GrassCoordinates[i];

            Vector2 leftupPos = new Vector2(centerPos.x - 0.35f, centerPos.y + 0.35f);
            Vector2 rightupPos = new Vector2(centerPos.x + 0.35f, centerPos.y + 0.35f);
            Vector2 leftbottomPos = new Vector2(centerPos.x - 0.35f, centerPos.y - 0.35f);
            Vector2 rightbottomPos = new Vector2(centerPos.x + 0.35f, centerPos.y + 0.35f);

            if (leftupPos.x < 0 || leftupPos.x > 100 || leftupPos.y < 0 || leftupPos.y > 100)
            {

            }
            else
            {
                GrassCoordinates.Add(leftupPos);
            }

            if (rightupPos.x < 0 || rightupPos.x > 100 || rightupPos.y < 0 || rightupPos.y > 100)
            {

            }
            else
            {
                GrassCoordinates.Add(rightupPos);
            }

            if (leftbottomPos.x < 0 || leftbottomPos.x > 100 || leftbottomPos.y < 0 || leftbottomPos.y > 100)
            {

            }
            else
            {
                GrassCoordinates.Add(leftbottomPos);
            }

            if (rightbottomPos.x < 0 || rightbottomPos.x > 100 || rightbottomPos.y < 0 || rightbottomPos.y > 100)
            {

            }
            else
            {
                GrassCoordinates.Add(rightbottomPos);
            }
        }
    }

    void GenerateMesh()
    {
        MeshData data = new MeshData(this.tiles);
        this.mesh = new Mesh();

        this.mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;

        this.mesh.vertices = data.vertices.ToArray();
        this.mesh.triangles = data.triangles.ToArray();
        this.mesh.colors = data.colors.ToArray();

        this.mesh.RecalculateNormals();
        this.mesh.RecalculateBounds();
    }

}