unity 画面上での重なり判定がしたい

Question

前提・実現したいこと

平行投影のカメラで3Dオブジェクトどうし(A、B)が画面上で重なっているかどうかを判定したいです。
カメラ、オブジェクトは回転させません。

考えたこと

Aを埋めるようにカメラからAに向けてBoxCast、SphereCastを沢山やって判定する。
→丸と四角でどう形を作るかがとても面倒です。

補足情報（FW/ツールのバージョンなど）

Unity 2019.4.19を使っています。

Answer 1

一案としてはMeshからPolygonCollider2Dを作り（参考:Generate 2D polygon collider from 3D mesh - Unity Answers）、それを利用して重なり判定を行う手がありそうです。
あるいは私からも別案として、カメラに下記のようなスクリプトをアタッチし...

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

// カメラにアタッチして使うことを想定しました
[RequireComponent(typeof(Camera))]
public class OverlapDetector : MonoBehaviour
{
    private static readonly int IntersectionTexture = Shader.PropertyToID("_IntersectionTexture");
    private static readonly int ObjectTexture = Shader.PropertyToID("_ObjectTexture");
    private static readonly int ReductionTexture0 = Shader.PropertyToID("_ReductionTexture0");
    private static readonly int ReductionTexture1 = Shader.PropertyToID("_ReductionTexture1");

    // ここに後述のHidden/OverlapDetectorをセットしておきます
    [SerializeField] private Shader detectorShader;

    private readonly List<Material> materials = new List<Material>();
    private readonly List<Renderer> renderers = new List<Renderer>();
    private new Camera camera;
    private CommandBuffer detectionCommands;
    private Material detectorMaterial;
    private RenderTexture resultRenderTexture;
    private Texture2D resultTexture;

    private void Awake()
    {
        if (this.detectorShader == null)
        {
            Debug.LogError($"{nameof(this.detectorShader)} not set.");
            Destroy(this);
            return;
        }

        this.detectorMaterial = new Material(this.detectorShader);
        this.resultRenderTexture = new RenderTexture(1, 1, 0, RenderTextureFormat.ARGB32);
        this.resultTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false);
        this.camera = this.GetComponent<Camera>();
        this.detectionCommands = new CommandBuffer
        {
            name = "Overlap Detection"
        };
    }

    private void OnDestroy()
    {
        Destroy(this.detectorMaterial);
        Destroy(this.resultRenderTexture);
        Destroy(this.resultTexture);
    }

    // オブジェクト同士の映像上の重なりを判定したいときにこのメソッドを実行することにしました
    // 引数として与えたオブジェクトがすべて重なっている領域があればtrue、さもなくばfalseを返します
    // レンダーテクスチャ上に別途オブジェクトをレンダリングしてみて判定する作りのため、
    // 多数のオブジェクトを判定、あるいは高頻度で判定しようとするとそれなりに描画負荷を要します
    public bool DetectOverlap(params GameObject[] gameObjects)
    {
        if (gameObjects == null)
        {
            return false;
        }
        
        // 判定用のテクスチャサイズは、さしあたり画面サイズよりも大きな2の冪乗の正方形としました
        // 高解像度だとこれも負荷増大の原因となるので、もっと粗い判定で十分ならば
        // このサイズをもっと小さくするのも一案かと思います
        var size = Mathf.NextPowerOfTwo(Mathf.Max(Screen.width, Screen.height));

        // CommandBufferを構築
        var c = this.detectionCommands;
        c.Clear();

        // このカメラのビュー・プロジェクション行列を用い...
        c.SetViewProjectionMatrices(
            this.camera.worldToCameraMatrix,
            GL.GetGPUProjectionMatrix(this.camera.projectionMatrix, true));
        
        // 重なり部分を表すテクスチャ、および個々のオブジェクトの描画に使うテクスチャを用意し...
        c.GetTemporaryRT(IntersectionTexture, size, size, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
        c.GetTemporaryRT(ObjectTexture, size, size, 0, FilterMode.Point, RenderTextureFormat.R8);
        
        // まず重なりテクスチャを白で塗りつぶし...
        c.SetRenderTarget(IntersectionTexture);
        c.ClearRenderTarget(true, true, Color.white);

        // 処理対象のオブジェクトそれぞれについて...
        foreach (var o in gameObjects)
        {
            if (o == null)
            {
                continue;
            }

            // 描画用テクスチャを透明で塗りつぶし...
            c.SetRenderTarget(ObjectTexture);
            c.ClearRenderTarget(true, true, Color.clear);

            // オブジェクトを構成するすべてのレンダラーを集めて...
            o.GetComponentsInChildren(this.renderers);
            foreach (var r in this.renderers)
            {
                if (r == null)
                {
                    continue;
                }

                // レンダラーを白色で描画し...
                r.GetSharedMaterials(this.materials);
                var materialCount = this.materials.Count;
                for (var i = 0; i < materialCount; i++)
                {
                    c.DrawRenderer(r, this.detectorMaterial, i, 0);
                }
            }

            // オブジェクトの描画結果を重なりテクスチャへ乗算合成することで、
            // オブジェクト同士が重なっている部分だけが白色として残るようにして...
            c.Blit(ObjectTexture, IntersectionTexture, this.detectorMaterial, 1);
        }

        // それを半々に縮小していき（このとき、近傍4ピクセルのうち1つ以上白色の
        // ピクセルがあれば、縮小結果も白色になるようにしています）...
        var fromTexture = ReductionTexture0;
        var toTexture = ReductionTexture1;
        c.GetTemporaryRT(fromTexture, size, size, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
        c.Blit(IntersectionTexture, fromTexture);
        while (size > 1)
        {
            size >>= 1;
            c.GetTemporaryRT(toTexture, size, size, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
            c.Blit(fromTexture, toTexture, this.detectorMaterial, 2);
            c.ReleaseTemporaryRT(fromTexture);
            var previousFromTexture = fromTexture;
            fromTexture = toTexture;
            toTexture = previousFromTexture;
        }

        // 最終的に1ピクセルまで縮め、その色を取得して
        // 白色かどうかで重なりがあるかを判定しました
        // わざわざこのように縮小する処理を加えた理由としては、広い面積の色を
        // ReadPixelsで取得するのは高コストであるためで、そうするよりはGPU上で
        // 縮小してから1ピクセル取得する方がマシだろうと思ってのことです
        c.Blit(fromTexture, this.resultRenderTexture);
        c.ReleaseTemporaryRT(fromTexture);
        c.ReleaseTemporaryRT(IntersectionTexture);
        c.ReleaseTemporaryRT(ObjectTexture);
        var activeTexture = RenderTexture.active;
        Graphics.ExecuteCommandBuffer(c);
        RenderTexture.active = this.resultRenderTexture;
        this.resultTexture.ReadPixels(new Rect(0, 0, 1, 1), 0, 0, false);
        RenderTexture.active = activeTexture;
        var result = this.resultTexture.GetPixel(0, 0);
        return result.r > 0.0f;
    }
}

detectorShaderとして下記シェーダーを用い...

Shader "Hidden/OverlapDetector"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Cull Off
        ZWrite Off
        ZTest Always

        CGINCLUDE
        #include "UnityCG.cginc"

        struct appdata
        {
            float4 vertex : POSITION;
            float2 uv : TEXCOORD0;
        };

        struct v2f
        {
            float2 uv : TEXCOORD0;
            float4 vertex : SV_POSITION;
        };

        v2f vert(appdata v)
        {
            v2f o;
            o.vertex = UnityObjectToClipPos(v.vertex);
            o.uv = v.uv;
            return o;
        }

        sampler2D _MainTex;
        ENDCG

        // 単純な白色塗り...オブジェクト描画用
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            fixed4 frag(v2f i) : SV_Target
            {
                return 1.0;
            }
            ENDCG
        }

        // 乗算合成...重なり領域抽出用
        Pass
        {
            Blend DstColor Zero

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            fixed4 frag(v2f i) : SV_Target
            {
                return tex2D(_MainTex, i.uv);
            }
            ENDCG
        }

        // 取得した色を切り上げて出力...テクスチャサイズ縮小用
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            fixed4 frag(v2f i) : SV_Target
            {
                return ceil(tex2D(_MainTex, i.uv));
            }
            ENDCG
        }
    }
}

実験用に別途用意した下記スクリプトで判定を行ったところ...

using UnityEngine;

public class OverlapDetectorTest : MonoBehaviour
{
    [SerializeField] private OverlapDetector detector;
    [SerializeField] private GameObject[] targets;

    private bool previousResult;

    private void Update()
    {
        var result = this.detector.DetectOverlap(this.targets);
        if (result == this.previousResult)
        {
            return;
        }

        Debug.Log(result);
        this.previousResult = result;
    }
}

下図のように重なりが判定されました。

前者のPolygonCollider2D案なら、一度外形を生成すればそれを使い回すことで動作時の負荷を抑えられそうに思います。また必要に応じて物理的応答をさせるのにも使えるでしょう。
後者の画像による判定方式は、描画負荷と引き換えにオブジェクトやカメラの回転、あるいはオブジェクトのアニメーションによってカメラから見たときの外形がころころ変化するケースでも対応しやすい利点があるかと思います。
ですが今回はオブジェクトもカメラも回転しないとのことですので、前者の案の方が向いているかもしれませんね。回転する場合であっても、カメラのZ軸に沿った回転ならば外形が変化しないはずですので、前者の案で対応可能かと思います。

Comments

[Shi-553]

2案もありがとうございます！
DirectXのステンシルバッファをみて描画してみれば判定出来そうとは思ってたんですが、unityでの座標変換からシェーダーまで未知のエリアだったので勉強になります。