質問をすることでしか得られない、回答やアドバイスがある。

15分調べてもわからないことは、質問しよう!

ただいまの
回答率

88.82%

Unity2D エラー OutOfMemoryException

解決済

回答 2

投稿

  • 評価
  • クリップ 0
  • VIEW 331
退会済みユーザー

退会済みユーザー

実現したいこと

OutOfMemoryExceptionのエラーを解消したい

エラーメッセージ

OutOfMemoryException: Out of memory
ExampleClass.GrassGenerate () (at Assets/Script/ExampleClass.cs:133)
ExampleClass.Start () (at Assets/Script/ExampleClass.cs:36)

該当のソースコード

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

public class ExampleClass : MonoBehaviour
{
    public int rows;
    public int columns;

    Mesh mesh;
    Matrix4x4[][] matrices;
    int count;
    public Material material;

    Mesh grassMesh;
    Matrix4x4[][] grassMatrices;
    int grassCount;
    public Material grassMaterial;

    Mesh grassMesh2;
    Matrix4x4[][] grassMatrices2;
    int grassCount2;
    public Material grassMaterial2;

    Mesh lotusMesh;
    Matrix4x4[][] lotusMatrices;
    int lotusCount;
    public Material lotusMaterial;

    private void Start()
    {
        rows = World.instance.width;
        columns = World.instance.height;
        Instance();
        GrassGenerate();
        GrassGenerate2();
        LotusGenerate();
    }

    void Instance()
    {
        mesh = new Mesh();
        mesh.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        mesh.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        mesh.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        mesh.RecalculateNormals();
        mesh.RecalculateBounds();

        count = rows * columns;
        var flatMatrices = new Matrix4x4[count];

        for(var i = 0;i < World.instance.NotWaterCoordinates.Count; i++)
        {
            var index = i;

            var position = World.instance.NotWaterCoordinates[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        matrices = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void GrassGenerate()
    {
        grassMesh = new Mesh();
        grassMesh.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        grassMesh.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        grassMesh.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        grassMesh.RecalculateNormals();
        grassMesh.RecalculateBounds();

        //grassCount = rows * columns;
        grassCount = World.instance.GrassCoordinates.Count;
        var flatMatrices = new Matrix4x4[grassCount];

        for(var i = 0;i < World.instance.GrassCoordinates.Count; i++)
        {
            var index = i;

            var position = World.instance.GrassCoordinates[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        grassMatrices = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void GrassGenerate2()
    {
        grassMesh2 = new Mesh();
        grassMesh2.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        grassMesh2.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        grassMesh2.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        grassMesh2.RecalculateNormals();
        grassMesh2.RecalculateBounds();

        grassCount2 = rows * columns;
        var flatMatrices = new Matrix4x4[grassCount2];

        for (var i = 0; i < World.instance.GrassCoordinates2.Count; i++)
        {
            var index = i;

            var position = World.instance.GrassCoordinates2[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        grassMatrices2 = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void LotusGenerate()
    {
        lotusMesh = new Mesh();
        lotusMesh.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        lotusMesh.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        lotusMesh.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        lotusMesh.RecalculateNormals();
        lotusMesh.RecalculateBounds();

        lotusCount = rows * columns;
        var flatMatrices = new Matrix4x4[lotusCount];

        for (var i = 0; i < World.instance.LotusCoordinates.Count; i++)
        {
            var index = i;

            var position = World.instance.LotusCoordinates[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        lotusMatrices = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void Update()
    {
        foreach (var m in matrices)
        {
            Graphics.DrawMeshInstanced(mesh, 0, material, m);
        }

        foreach(var g in grassMatrices)
        {
            Graphics.DrawMeshInstanced(grassMesh, 0, grassMaterial, g);
        }

        foreach(var g2 in grassMatrices2)
        {
            Graphics.DrawMeshInstanced(grassMesh2, 0, grassMaterial2, g2);
        }

        foreach(var l in lotusMatrices)
        {
            Graphics.DrawMeshInstanced(lotusMesh, 0, lotusMaterial, l);
        }
    }
}

試したこと

World.csにGrassAddというメソッドがあるのですが、この関数を使用するとエラーになります。
ExampleClass.csのGrassGenerateメソッドで、

grassCount = World.instance.GrassCoordinates.Count;


としていますが、エラーの原因となっているようです。恐らく、grassCountが大きすぎるのかもしれません。
自分がやりたいことは、草のテクスチャが描かれたメッシュを大量に生成することなのですが、OutOfMemoryException、メモリ不足となってしまいます。
どのように書き直せばいいでしょうか? 回答お願いします。

  • 気になる質問をクリップする

    クリップした質問は、後からいつでもマイページで確認できます。

    またクリップした質問に回答があった際、通知やメールを受け取ることができます。

    クリップを取り消します

  • 良い質問の評価を上げる

    以下のような質問は評価を上げましょう

    • 質問内容が明確
    • 自分も答えを知りたい
    • 質問者以外のユーザにも役立つ

    評価が高い質問は、TOPページの「注目」タブのフィードに表示されやすくなります。

    質問の評価を上げたことを取り消します

  • 評価を下げられる数の上限に達しました

    評価を下げることができません

    • 1日5回まで評価を下げられます
    • 1日に1ユーザに対して2回まで評価を下げられます

    質問の評価を下げる

    teratailでは下記のような質問を「具体的に困っていることがない質問」、「サイトポリシーに違反する質問」と定義し、推奨していません。

    • プログラミングに関係のない質問
    • やってほしいことだけを記載した丸投げの質問
    • 問題・課題が含まれていない質問
    • 意図的に内容が抹消された質問
    • 過去に投稿した質問と同じ内容の質問
    • 広告と受け取られるような投稿

    評価が下がると、TOPページの「アクティブ」「注目」タブのフィードに表示されにくくなります。

    質問の評価を下げたことを取り消します

    この機能は開放されていません

    評価を下げる条件を満たしてません

    評価を下げる理由を選択してください

    詳細な説明はこちら

    上記に当てはまらず、質問内容が明確になっていない質問には「情報の追加・修正依頼」機能からコメントをしてください。

    質問の評価を下げる機能の利用条件

    この機能を利用するためには、以下の事項を行う必要があります。

回答 2

check解決した方法

0

新しいメソッドを作り直したら解決しました。

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

public class ExampleClass : MonoBehaviour
{
    public int rows;
    public int columns;

    Mesh mesh;
    Matrix4x4[][] matrices;
    int count;
    public Material material;

    Mesh grassMesh;
    Matrix4x4[][] grassMatrices;
    uint grassCount;
    public Material grassMaterial;

    Mesh grassMesh2;
    Matrix4x4[][] grassMatrices2;
    int grassCount2;
    public Material grassMaterial2;

    Mesh lotusMesh;
    Matrix4x4[][] lotusMatrices;
    int lotusCount;
    public Material lotusMaterial;

    Mesh grassAddMesh;
    Matrix4x4[][] grassAddMatrices;
    int grassAddCount;

    private void Start()
    {
        rows = World.instance.width;
        columns = World.instance.height;
        Instance();
        GrassGenerate();
        GrassGenerate2();
        LotusGenerate();
        GrassAddGenerate();
    }

    void Instance()
    {
        mesh = new Mesh();
        mesh.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 2, 0),
        new Vector3 (2 ,0, 0),
        new Vector3 (2, 2, 0),
    };

        mesh.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        mesh.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        mesh.RecalculateNormals();
        mesh.RecalculateBounds();

        // 各インスタンスの姿勢はMatrix4x4として与える
        count = rows * columns;
        var flatMatrices = new Matrix4x4[count];
        /*for (var i = 0; i < rows; i++)
        {
            for (var j = 0; j < columns; j++)
            {
                var index = (i * columns) + j;

                var position = new Vector3(j, i, 0);

                //var randomAngle = Random.Range(-10.0f, 10.0f);
                //var randomDirection = Random.insideUnitCircle.normalized;
                var rotation = Quaternion.identity;

                var scale = Vector3.one;

                flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
            }
        }*/

        for(var i = 0;i < World.instance.NotWaterCoordinates.Count; i++)
        {
            var index = i;

            var position = World.instance.NotWaterCoordinates[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        // 一度に描画できるインスタンスは1023個までなので、あらかじめそれを超えないよう切り分けておく
        matrices = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void GrassGenerate()
    {
        grassMesh = new Mesh();
        grassMesh.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        grassMesh.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        grassMesh.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        grassMesh.RecalculateNormals();
        grassMesh.RecalculateBounds();

        //grassCount = rows * columns;
        grassCount = (uint)World.instance.GrassCoordinates.Count;
        var flatMatrices = new Matrix4x4[grassCount];

        for(var i = 0;i < World.instance.GrassCoordinates.Count; i++)
        {
            var index = i;

            var position = World.instance.GrassCoordinates[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        // 一度に描画できるインスタンスは1023個までなので、あらかじめそれを超えないよう切り分けておく
        grassMatrices = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void GrassGenerate2()
    {
        grassMesh2 = new Mesh();
        grassMesh2.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        grassMesh2.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        grassMesh2.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        grassMesh2.RecalculateNormals();
        grassMesh2.RecalculateBounds();

        grassCount2 = rows * columns;
        var flatMatrices = new Matrix4x4[grassCount2];

        for (var i = 0; i < World.instance.GrassCoordinates2.Count; i++)
        {
            var index = i;

            var position = World.instance.GrassCoordinates2[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        // 一度に描画できるインスタンスは1023個までなので、あらかじめそれを超えないよう切り分けておく
        grassMatrices2 = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void LotusGenerate()
    {
        lotusMesh = new Mesh();
        lotusMesh.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        lotusMesh.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        lotusMesh.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        lotusMesh.RecalculateNormals();
        lotusMesh.RecalculateBounds();

        lotusCount = rows * columns;
        var flatMatrices = new Matrix4x4[lotusCount];

        for (var i = 0; i < World.instance.LotusCoordinates.Count; i++)
        {
            var index = i;

            var position = World.instance.LotusCoordinates[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        // 一度に描画できるインスタンスは1023個までなので、あらかじめそれを超えないよう切り分けておく
        lotusMatrices = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void GrassAddGenerate()
    {
        grassAddMesh = new Mesh();
        grassAddMesh.vertices = new Vector3[] {
        new Vector3 (0, 0, 0),
        new Vector3 (0, 1, 0),
        new Vector3 (1 ,0, 0),
        new Vector3 (1, 1, 0),
    };

        grassAddMesh.uv = new Vector2[] {
        new Vector2 (0, 0),
        new Vector2 (0, 1),
        new Vector2 (1, 0),
        new Vector2 (1, 1),
    };

        grassAddMesh.triangles = new int[] {
        0, 1, 2,
        1, 3, 2,
    };

        grassAddMesh.RecalculateNormals();
        grassAddMesh.RecalculateBounds();

        grassAddCount = World.instance.GrassAddCoordinates.Count;
        var flatMatrices = new Matrix4x4[grassAddCount];

        for (var i = 0; i < World.instance.GrassAddCoordinates.Count; i++)
        {
            var index = i;

            var position = World.instance.GrassAddCoordinates[i];

            var rotation = Quaternion.identity;

            var scale = Vector3.one;

            flatMatrices[index] = Matrix4x4.TRS(position, rotation, scale);
        }

        // 一度に描画できるインスタンスは1023個までなので、あらかじめそれを超えないよう切り分けておく
        grassAddMatrices = flatMatrices.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();
    }

    void Update()
    {
        foreach (var m in matrices)
        {
            Graphics.DrawMeshInstanced(mesh, 0, material, m);
        }

        foreach(var g in grassMatrices)
        {
            Graphics.DrawMeshInstanced(grassMesh, 0, grassMaterial, g);
        }

        foreach(var g2 in grassMatrices2)
        {
            Graphics.DrawMeshInstanced(grassMesh2, 0, grassMaterial2, g2);
        }

        foreach(var l in lotusMatrices)
        {
            Graphics.DrawMeshInstanced(lotusMesh, 0, lotusMaterial, l);
        }

        foreach(var ga in grassAddMatrices)
        {
            Graphics.DrawMeshInstanced(grassAddMesh, 0, grassMaterial, ga);
        }
    }
}

投稿

  • 回答の評価を上げる

    以下のような回答は評価を上げましょう

    • 正しい回答
    • わかりやすい回答
    • ためになる回答

    評価が高い回答ほどページの上位に表示されます。

  • 回答の評価を下げる

    下記のような回答は推奨されていません。

    • 間違っている回答
    • 質問の回答になっていない投稿
    • スパムや攻撃的な表現を用いた投稿

    評価を下げる際はその理由を明確に伝え、適切な回答に修正してもらいましょう。

-1

文字数制限があったため、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();
    }

}

投稿

  • 回答の評価を上げる

    以下のような回答は評価を上げましょう

    • 正しい回答
    • わかりやすい回答
    • ためになる回答

    評価が高い回答ほどページの上位に表示されます。

  • 回答の評価を下げる

    下記のような回答は推奨されていません。

    • 間違っている回答
    • 質問の回答になっていない投稿
    • スパムや攻撃的な表現を用いた投稿

    評価を下げる際はその理由を明確に伝え、適切な回答に修正してもらいましょう。

  • 2019/04/22 20:49

    文字数をオーバーするということは、回答者にそれだけ長いコードを読ませることになります。
    (少なくとも、私は読む気になれません)
    まずはコードを整理して「エラーが出る最小限のコード」にしてください。

    キャンセル

  • 2019/04/22 21:05

    申し訳ありませんでした。

    キャンセル

  • 2019/04/22 21:07

    次からは気をつけます。

    キャンセル

15分調べてもわからないことは、teratailで質問しよう!

  • ただいまの回答率 88.82%
  • 質問をまとめることで、思考を整理して素早く解決
  • テンプレート機能で、簡単に質問をまとめられる

関連した質問

同じタグがついた質問を見る