Unity 変換行列からPositionを取り出す

Question

前提・実現したいこと

変換行列からPositionを取り出したい

該当のソースコード

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

public class Example : MonoBehaviour
{
    Matrix4x4[][] matrix4X4s;
    Matrix4x4[] flatMatrix;

    public Material material;

    HashSet<Matrix4x4> matriHash = new HashSet<Matrix4x4>();

    private void Start()
    {
        int seed = Random.Range(-999999, 999999);

        float[,] noiseMap = Noise.GenerateNoiseMap(200, 200, seed, 50, 4, 0.5f, 2, Vector2.zero);

        int rows = 200;
        int columns = 200;

        flatMatrix = new Matrix4x4[rows * columns];

        for (int x = 0; x < rows; x++)
        {
            for (int y = 0; y < columns; y++)
            {
                float height = noiseMap[y, x];

                int index = (x * columns) + y;

                Vector2 pos = new Vector2(x, y);
                Quaternion rotation = Quaternion.identity;
                Vector3 scale = Vector3.one;

                if (height < 0.35f)
                {
                    flatMatrix[index] = Matrix4x4.TRS(pos, rotation, scale);
                    matriHash.Add(flatMatrix[index]);
                }
            }
        }

        foreach (Matrix4x4 hash in matriHash)
        {
            var position = new Vector3(hash[0, 3], hash[1, 3], hash[2, 3]);
            Vector2 pos = new Vector2(position.x, position.y);
            posHash.Add(pos);
        }
    }

    Vector2 getScreenDownLeft()
    {
        Vector2 pos = new Vector2(0, 0);
        Vector2 downLeft = Camera.main.ScreenToWorldPoint(pos);
        return downLeft;
    }

    Vector2 getScreenUpRight()
    {
        Vector2 pos = new Vector2(Screen.width, Screen.height);
        Vector2 upRight = Camera.main.ScreenToWorldPoint(pos);
        return upRight;
    }

    HashSet<Vector2> getScreenPos()
    {
        HashSet<Vector2> hash = new HashSet<Vector2>();

        for (int x = (int)getScreenDownLeft().x - 5; x < (int)getScreenUpRight().x + 5; x++)
        {
            for (int y = (int)getScreenDownLeft().y - 5; y < (int)getScreenUpRight().y + 5; y++)
            {
                Vector2 pos = new Vector2(x, y);
                hash.Add(pos);
            }
        }

        return hash;
    }

    Matrix4x4[] array = new Matrix4x4[1023];

    HashSet<Matrix4x4> hashMat = new HashSet<Matrix4x4>();

    HashSet<Vector2> posHash = new HashSet<Vector2>();

    private void Update()
    {
        foreach (Vector2 item in getScreenPos())
        {
            GetMatrix(item);
        }

        foreach (var m in matrix4X4s)
        {
            Graphics.DrawMeshInstanced(MeshGenerator.basicMesh, 0, material, m);
        }
    }

    Matrix4x4[][] GetMatrix(Vector2 pos)
    {
        if (posHash.Contains(pos))
        {
            foreach(Matrix4x4 item in matriHash)
            {
                var position = new Vector2(item[0, 3], item[1, 3]);
                Vector2 matriPos = new Vector2(position.x, position.y);
                if(pos == matriPos)
                {
                    hashMat.Add(item);
                }
            }
        }

        array = hashMat.ToArray();

        matrix4X4s = array.Select((m, i) => (m, i / 1023))
            .GroupBy(t => t.Item2)
            .Select(g => g.Select(t => t.Item1).ToArray()).ToArray();

        return matrix4X4s;
    }
}

using UnityEngine;
using System.Collections;

public static class Noise
{

	public static float[,] GenerateNoiseMap(int mapWidth, int mapHeight, int seed, float scale, int octaves, float persistance, float lacunarity, Vector2 offset)
	{
		float[,] noiseMap = new float[mapWidth, mapHeight];

		System.Random prng = new System.Random(seed);
		Vector2[] octaveOffsets = new Vector2[octaves];
		for (int i = 0; i < octaves; i++)
		{
			float offsetX = prng.Next(-1000000, 1000000) + offset.x;
			float offsetY = prng.Next(-1000000, 1000000) + offset.y;
			octaveOffsets[i] = new Vector2(offsetX, offsetY);
		}

		if (scale <= 0)
		{
			scale = 0.0001f;
		}

		float maxNoiseHeight = float.MinValue;
		float minNoiseHeight = float.MaxValue;

		float halfWidth = mapWidth / 2f;
		float halfHeight = mapHeight / 2f;


		for (int y = 0; y < mapHeight; y++)
		{
			for (int x = 0; x < mapWidth; x++)
			{

				float amplitude = 1;
				float frequency = 1;
				float noiseHeight = 0;

				for (int i = 0; i < octaves; i++)
				{
					float sampleX = (x - halfWidth) / scale * frequency + octaveOffsets[i].x;
					float sampleY = (y - halfHeight) / scale * frequency + octaveOffsets[i].y;

					float perlinValue = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;
					noiseHeight += perlinValue * amplitude;

					amplitude *= persistance;
					frequency *= lacunarity;
				}

				if (noiseHeight > maxNoiseHeight)
				{
					maxNoiseHeight = noiseHeight;
				}
				else if (noiseHeight < minNoiseHeight)
				{
					minNoiseHeight = noiseHeight;
				}
				noiseMap[x, y] = noiseHeight;
			}
		}

		for (int y = 0; y < mapHeight; y++)
		{
			for (int x = 0; x < mapWidth; x++)
			{
				noiseMap[x, y] = Mathf.InverseLerp(minNoiseHeight, maxNoiseHeight, noiseMap[x, y]);
			}
		}

		return noiseMap;
	}

}

試したこと

カメラに映っているメッシュだけをGraphics.DrawMeshInstancedを使って描画したかったのですが、カメラに映っているワールド座標と、変換行列に代入されている座標を一致しているか確認する方法が、分からなかったため、質問しました。

【追記】

回答者様の回答をもとに、スクリプトを変更しました。
ですが、カメラに映っているメッシュだけを描画はしているのですが、0.1~0.3FPSしか出ません。
Graphics.DrawMeshのほうが軽いくらいです……。どのように書き換えたらよいでしょうか？

Answer 1

UnityEngine.Matrix4x4 - Unity スクリプトリファレンスによると...

Matrices in Unity are column major; i.e. the position of a transformation matrix is in the last column, and the first three columns contain x, y, and z-axes.

Unityの行列は列優先です。すなわち変換行列の「位置」は最終列にあり、最初の3列が「X軸」「Y軸」「Z軸」です。

とのことです。そしてその下のサンプルコードでは...

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        // get matrix from the Transform
        var matrix = transform.localToWorldMatrix;
        // get position from the last column
        var position = new Vector3(matrix[0,3], matrix[1,3], matrix[2,3]);
        Debug.Log("Transform position from matrix is: " + position);
    }
}

といった風に、変換行列から平行移動成分を取り出している例が載っていました。

やたら遅い件について追記

カメラ範囲内のタイルを抜き出す処理がうまくいってないんじゃないかと思います。Updateの...

foreach (Vector2 item in this.getScreenPos())
{
    this.GetMatrix(item);
}

の部分がいまいち意図不明ですね...
不必要そうな部分をばっさりカットして下記のようにしてみました。rowsとcolumnsはStartとUpdateの両方で使用する形になったのでローカル変数からフィールドに変更しました。flatMatrixを作るときのxとyの使い方も「横方向がx、縦方向がy」に統一した方が自然だろうと思って変更しています。

using UnityEngine;

public class Example : MonoBehaviour
{
    public Material material;
    public int rows = 200;
    public int columns = 200;

    Matrix4x4[] flatMatrix;
    readonly Matrix4x4[] array = new Matrix4x4[1023];

    void Start()
    {
        int seed = Random.Range(-999999, 999999);
        float[,] noiseMap = Noise.GenerateNoiseMap(columns, rows, seed, 50, 4, 0.5f, 2, Vector2.zero);
        flatMatrix = new Matrix4x4[rows * columns];
        for (int y = 0; y < rows; y++)
        {
            for (int x = 0; x < columns; x++)
            {
                float height = noiseMap[x, y];
                int index = (y * columns) + x;
                Vector2 pos = new Vector2(x, y);
                Quaternion rotation = Quaternion.identity;
                Vector3 scale = Vector3.one;
                if (height < 0.35f)
                {
                    flatMatrix[index] = Matrix4x4.TRS(pos, rotation, scale);
                }
            }
        }
    }

    Vector2 GetScreenDownLeft()
    {
        Vector2 pos = new Vector2(0, 0);
        Vector2 downLeft = Camera.main.ScreenToWorldPoint(pos);
        return downLeft;
    }

    Vector2 GetScreenUpRight()
    {
        Vector2 pos = new Vector2(Screen.width, Screen.height);
        Vector2 upRight = Camera.main.ScreenToWorldPoint(pos);
        return upRight;
    }

    void Update()
    {
        // まずスクリーン左下・右上座標を求めて...
        Vector2 downLeft = GetScreenDownLeft();
        Vector2 upRight = GetScreenUpRight();

        // 余白分だけ範囲を拡張し...
        Vector2 margin = new Vector2(5, 5);
        downLeft -= margin;
        upRight += margin;

        // 整数化し...
        Vector2Int downLeftInt = new Vector2Int(Mathf.RoundToInt(downLeft.x), Mathf.RoundToInt(downLeft.y));
        Vector2Int upRightInt = new Vector2Int(Mathf.RoundToInt(upRight.x), Mathf.RoundToInt(upRight.y));

        // 200x200の範囲をはみ出さないようにクランプする
        downLeftInt = Vector2Int.Min(
            Vector2Int.Max(downLeftInt, Vector2Int.zero),
            new Vector2Int(columns - 1, rows - 1));
        upRightInt = Vector2Int.Min(
            Vector2Int.Max(upRightInt, Vector2Int.zero),
            new Vector2Int(columns - 1, rows - 1));

        // 右上から左下を引き、描画領域のサイズとする
        Vector2Int areaSize = upRightInt - downLeftInt;

        // 描画するべきタイルの総数は、描画領域の幅×高さとなる
        int tileCount = areaSize.x * areaSize.y;

        // 描画済みタイル数を記録する変数を用意する
        int drawnTileCount = 0;

        // タイルを描画していく
        while (drawnTileCount < tileCount)
        {
            // まず、今回のループで描画するべきタイル数を求める
            // 未描画のタイル数は「タイル総数 - 描画済みタイル数」であり
            // さらにそれを1023個を超えないようにクランプする
            int tileCountToDraw = Mathf.Min(tileCount - drawnTileCount, 1023);

            // 描画したい領域をflatMatrixからarrayへコピーしていく
            // このとき、連続している部分はなるべく丸ごとコピーしてやった方が効率的だと思われる
            // そこで、まずコピー済みタイル数を記録する変数を用意する
            int transferredTileCount = 0;

            // そして横方向オフセットを表す変数を用意する
            // 初期値は描画済みタイル数を領域幅で割った余りとなる
            int xOffset = drawnTileCount % areaSize.x;
            while (transferredTileCount < tileCountToDraw)
            {
                // 今回のループでコピーするべきタイル数を求める
                // まず、未コピーのタイル数を超えてはならず...
                int tileCountToTransfer = tileCountToDraw - transferredTileCount;

                // 現在の横オフセットから描画領域右端までのタイル数を超えてはならない
                tileCountToTransfer = Mathf.Min(tileCountToTransfer, areaSize.x - xOffset);

                // 描画領域座標系におけるコピー開始点の位置はこうなり...
                int localTileIndex = drawnTileCount + transferredTileCount;
                Vector2Int localTilePosition = new Vector2Int(localTileIndex % areaSize.x, localTileIndex / areaSize.x);

                // それに描画領域の左下隅を足せばワールド座標系における位置となり...
                Vector2Int worldTilePosition = localTilePosition + downLeftInt;

                // flatMatrixのインデックスに直すとこうなる
                int worldTileIndex = (worldTilePosition.y * columns) + worldTilePosition.x;

                // flatMatrixのworldTileIndex番から数えてtileCountToTransfer個のデータを
                // arrayのtransferredTileCount番以降にコピーする
                System.Array.Copy(flatMatrix, worldTileIndex, array, transferredTileCount, tileCountToTransfer);

                // 横オフセットを更新する
                // とはいえ、2回目以降のループでは常に0となるはず
                // 末尾では0でない可能性があるが、そもそもループが終了するので考慮不要
                xOffset = 0;

                // コピー済みタイル数を更新する
                transferredTileCount += tileCountToTransfer;
            }

            // タイルをtileCountToDraw個描画する
            Graphics.DrawMeshInstanced(MeshGenerator.basicMesh, 0, material, array, tileCountToDraw);

            // 描画済みタイル数を更新する
            drawnTileCount += tileCountToDraw;
        }
    }
}

また、MeshGeneratorはどのような作りになっているでしょうか?
もしbasicMeshが「アクセスするたびに新規Meshを生成して返すプロパティ」みたいな作りだったとすると、ここもスピードダウンの原因になりそうです。
さしあたり私の場合は下記のように「アクセスされたときにMeshが未生成なら生成し、それ以降は生成済みのMeshオブジェクトを返すプロパティ」としてみました。もしご自身で作成されたMeshGeneratorが速度低下を起こしそうか気になるようでしたら、コードをご提示いただければ何かアドバイスできるかもしれません。

using UnityEngine;

public static class MeshGenerator
{
    private static Mesh quadMesh;

    public static Mesh basicMesh
    {
        get
        {
            if (quadMesh == null)
            {
                quadMesh = new Mesh
                {
                    name = "Quad",
                    vertices = new[]
                    {
                        new Vector3(-0.5f, -0.5f, 0),
                        new Vector3(-0.5f, 0.5f, 0),
                        new Vector3(0.5f, -0.5f, 0),
                        new Vector3(0.5f, 0.5f, 0),
                    },
                    uv = new[]
                    {
                        new Vector2(0, 0),
                        new Vector2(0, 1),
                        new Vector2(1, 0),
                        new Vector2(1, 1),
                    },
                    triangles = new[]
                    {
                        0, 1, 2,
                        3, 2, 1,
                    }
                };

                quadMesh.RecalculateNormals();
                quadMesh.RecalculateBounds();
                quadMesh.UploadMeshData(true);
            }

            return quadMesh;
        }
    }
}

Comments

[退会済みユーザー]

一行一行、説明まで書いていただき、ありがとうございます！　とても参考になります。