Unity2D テクスチャブレンド

たとえば、タイルおよびメッシュに前景・背景情報とそれらのブレンド率を追加して、描画時にはそれに基づいて前景と背景のグラフィックを混ぜ合わせて表示してやる方法が考えられるでしょう。

まず、Tileは下記のようにして...

public class Tile{

    public enum Type { Dirt, Grass }
    public Type type; // ゲームロジックのための地形タイプ
    public Type foregroundType; // 描画のための前景の地形タイプ
    public Type backgroundType; // 描画のための背景の地形タイプ
    public Vector4 blendWeights; // 描画のための前景・背景混合率（x、y、z、wが左下、右下、左上、右上の角に対応）

    public Tile(Type type, Type foreground, Type background, Vector4 weights)
    {
        this.type = type;
        this.foregroundType = foreground;
        this.backgroundType = background;
        this.blendWeights = weights;
    }
}

WorldのCreateTilesは下記のように変え...

void CreateTiles()
{
    this.tiles = new Tile[this.width, this.height];

    // ノイズのサイズを縦横1だけ広げて、それをタイル中心ではなくタイル四隅における値として利用する
    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++)
        {
            // 4点のノイズ値を取得して、それを四隅における前景・背景混合率とし...
            Vector4 weights = new Vector4(noiseValues[i, j], noiseValues[i + 1, j], noiseValues[i, j + 1], noiseValues[i + 1, j + 1]);

            // 4点の平均値を中心の値として、それをもとに地形タイプを決定し...
            float averageWeight = Vector4.Dot(weights, Vector4.one) * 0.25f;
            Tile.Type type = (averageWeight > 0.5f) ? Tile.Type.Grass : Tile.Type.Dirt;

            // 前景を草地、背景を裸地としてタイルを生成する
            this.tiles[i, j] = new Tile(type, Tile.Type.Grass, Tile.Type.Dirt, weights);
        }
    }
}

SpriteLoaderのGetTileUVsは、引数としてタイルではなく地形タイプを受け取るようにし...

public Vector2[] GetTileUVs(Tile.Type type)
{

    string key = type.ToString();

    if (this.tileUVMap.ContainsKey(key) == true)
    {

        return this.tileUVMap[key];
    }
    else
    {

        Debug.LogError("There is no UV map for tile type: " + key);
        return this.tileUVMap["Void"];
    }
}

MeshDataにも追加情報を持たせ...

public class MeshData
{

    public List<Vector3> vertices;
    public List<int> triangles;
    public List<Vector4> UVs; // Vector4に変更し、xyに前景、zwに背景のUVを格納することにする
    public List<Color> colors; // 混合率は色として表現する（UV2以降を使ってもいいと思います）

    public MeshData(Tile[,] data)
    {
        vertices = new List<Vector3>();
        triangles = new List<int>();
        UVs = new List<Vector4>();
        colors = new List<Color>();

        for (int i = 0; i < data.GetLength(0); i++)
        {
            for (int j = 0;j < data.GetLength(1); j++)
            {
                CreateSquare(data[i, j], i, j);
            }
        }
    }

    void CreateSquare(Tile tile, int x, int y)
    {
        vertices.Add(new Vector3(x + 0, y + 0));
        vertices.Add(new Vector3(x + 1, y + 0));
        vertices.Add(new Vector3(x + 0, y + 1));
        vertices.Add(new Vector3(x + 1, y + 1));

        triangles.Add(vertices.Count - 1);
        triangles.Add(vertices.Count - 3);
        triangles.Add(vertices.Count - 4);

        triangles.Add(vertices.Count - 2);
        triangles.Add(vertices.Count - 1);
        triangles.Add(vertices.Count - 4);

        // 前景・背景についてそれぞれUVを取得し、合成してUVsに追加する
        // （Zipで合成しましたが、この場合「using System.Linq;」が必要になります）
        Vector2[] foregroundUVs = SpriteLoader.instance.GetTileUVs(tile.foregroundType);
        Vector2[] backgroundUVs = SpriteLoader.instance.GetTileUVs(tile.backgroundType);
        UVs.AddRange(foregroundUVs.Zip(backgroundUVs, (f, b) => new Vector4(f.x, f.y, b.x, b.y)));

        // 混合率はA成分に埋め込む
        // RGBに他の情報を埋め込む余地があります
        // 例えばランダムな色を入れてやり、描画時にそれを利用することで地形に色ムラをつけるとか...
        for (int i = 0; i < 4; i++)
        {
            colors.Add(new Color(0.0f, 0.0f, 0.0f, tile.blendWeights[i]));
        }
    }
}

そしてWorldのGenerateMeshも変更します。

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

    // 頂点インデックスのフォーマットを32ビット整数に変更する
    this.mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;

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

    // uvへの代入だとVector2しか受け付けてくれないので、代わりにSetUVsを使う
    this.mesh.SetUVs(0, data.UVs);

    // 混合率もセットする
    this.mesh.colors = data.colors.ToArray();

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

Worldにセットするマテリアルについては、単純には下記のような合成でいいかと思います。

Shader "Unlit/World"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _EdgeSoftness ("Edge Softness", Range(0.0, 1.0)) = 0.05
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float4 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float4 uv : TEXCOORD0;
                float weight : TEXCOORD1;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float _EdgeSoftness;

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = float4(TRANSFORM_TEX(v.uv.xy, _MainTex), TRANSFORM_TEX(v.uv.zw, _MainTex));
                o.weight = v.color.a;
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                fixed4 foreColor = tex2D(_MainTex, i.uv.xy);
                fixed4 backColor = tex2D(_MainTex, i.uv.zw);
                float smoothingWidth = _EdgeSoftness * 0.5;
                float ratio = smoothstep(0.5 - smoothingWidth, 0.5 + smoothingWidth, i.weight);
                return lerp(backColor, foreColor, ratio);
            }
            ENDCG
        }
    }
}

ですがご提示の理想図を見ますと、境界部分にフラクタルノイズっぽい乱れがあるようにも見えます。一例としては、下記のようにするとそれに近づけられるのではないでしょうか?

Shader "Unlit/World"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _EdgeSoftness ("Edge Softness", Range(0.0, 1.0)) = 0.025
        _EdgeDist ("Edge Disturbance", Range(0.0, 1.0)) = 0.05
        _EdgeDistFreq ("Edge Disturbance Frequency", Range(0.0, 16.0)) = 4.0
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float4 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float4 uv : TEXCOORD0;
                float weight : TEXCOORD1;
                float2 modelPos : TEXCOORD2;
            };

            // https://thebookofshaders.com/11/ の方法によるバリューノイズの生成
            inline float random(float2 st) {
                return frac(sin(dot(st, float2(12.9898, 78.233))) * 43758.5453123);
            }

            float noise(float2 st)
            {
                float2 i = floor(st);
                float2 f = frac(st);
                float a = random(i);
                float b = random(i + float2(1.0, 0.0));
                float c = random(i + float2(0.0, 1.0));
                float d = random(i + float2(1.0, 1.0));
                float2 u = f * f * (3.0 - 2.0 * f);

                return dot(float2(lerp(a, b, u.x), lerp(c - a, d - b, u.x)), float2(1.0, u.y));
            }

            // バリューノイズを適当に重ね合わせてフラクタルっぽくする
            float fractal(float2 st)
            { 
                float4 amp = float4(1.0, 0.5, 0.25, 0.125);
                float4 v;

                v.x = noise(st);
                st = st * 2.0 + float2(14.1421356237, 17.3205080757);
                v.y = noise(st);
                st = st * 2.0 + float2(22.360679775, 26.4575131106);
                v.z = noise(st);
                st = st * 2.0 + float2(31.4159265359, 27.1828182846);
                v.w = noise(st);

                return dot(v, amp) / dot(1.0, amp);
            }

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float4 _MainTex_TexelSize;
            float _EdgeSoftness;
            float _EdgeDist;
            float _EdgeDistFreq;

            v2f vert(appdata v)
            {
                v2f o;
                o.uv = float4(TRANSFORM_TEX(v.uv.xy, _MainTex), TRANSFORM_TEX(v.uv.zw, _MainTex));
                o.weight = v.color.a;
                o.modelPos = v.vertex.xy;
                o.vertex = UnityObjectToClipPos(v.vertex);
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                fixed4 foreColor = tex2D(_MainTex, i.uv.xy);
                fixed4 backColor = tex2D(_MainTex, i.uv.zw);
                float smoothingWidth = _EdgeSoftness * 0.5;
                float f = dot(float2(_EdgeDist, 1.0 - _EdgeDist), float2(fractal(i.modelPos * _EdgeDistFreq), 0.5));
                float upper = 1.0 - 2.0 * (1.0 - i.weight) * (1.0 - f);
                float lower = 2.0 * i.weight * f;
                float weight = lerp(lower, upper, step(0.5, i.weight));
                float ratio = smoothstep(0.5 - smoothingWidth, 0.5 + smoothingWidth, weight);
                return lerp(backColor, foreColor, ratio);
            }
            ENDCG
        }
    }
}

※実験中に気付いたのですが、シードの値によってはノイズパターンの水平方向周波数が極端に小さくなってしまうことがあるようでしたので、さらに下記のような変更を加えています。

public float [,] GetNoiseValues(int width,int height)
{
    float[,] noiseValues = new float[width, height];

    float max = 0f;
    float min = float.MaxValue;

    // seedに極端に大きな値が入ると、(i + seed) / (float)width * frequencyの部分で
    // 精度不足となるようだったため、適当に小さくしました
    seed %= 1024;

    // 省略

    return noiseValues;
}