Unity 爆風の射線が通っているかどうかの判定

Question

実現したいこと

Unityで3Dシューティングゲームを作ってます。
爆風の射線が通っているかどうかの判定を取りたいです。

前提

Unityのバージョンは2021.3.16f1です。
C#を使ってます。

発生している問題・エラーメッセージ

現在Physics.OverlapCapsuleを用いて爆風の判定を取っています。以下の画像で黒い円が爆風範囲、緑の四角がプレイヤーのコライダーです。

上記の場合ではプレイヤーが爆風範囲内に居るので、爆風が当たったという判定で問題ありません。

しかし、爆風地点とプレイヤーの間に壁(画像の赤色の線)があった場合は爆風が壁に遮られるので、爆風の判定は以下の画像の青い範囲になるべきです。

上記の場合ではPhysics.OverlapCapsuleだけでは当たった判定になってしまうので、爆風地点からプレイヤーの座標までPhysics.Raycastで壁があるかどうかを調べれば解決します。

ですが、壁が複雑な形をしている場合はそうも行きません。以下の画像の場合、最終的には当たった判定になるべきです。ですが、爆風範囲にプレイヤーが居るのでPhysics.Raycastの判定をしますが、爆風とプレイヤーの座標の間に壁があるので当たってない判定になります。また、より正確に判定する為にコライダーの角に対してもPhysics.Raycastの判定をしようと考えましたが、この場合だと当たってない判定になってしまいます。

判定するコライダーの座標を増やせばかなり正確に判定できますが、爆風の範囲が広がる程、そして座標を増やす程重い処理になってしまいます。また、プレイヤーだけではなく複雑な形のオブジェクトにも適用したいので、汎用的な対処方法を教えて頂きたいです。
宜しくお願いします。

Comments

[fana]

Unityのことは全くしりませんが，
正確さと処理速度を天秤にかけて「どこで妥協するか」という話が必要なのではないでしょうか？

例えば，爆心からの方向をサンプリングするような方法（いろんな方向にレイを飛ばすよな）では隙間を正確に扱えない場合が生じるでしょうけど，そもそも本当に「どこまでも小さな隙間でも正確にやれる」を達成せねばならないのか？　という．

[korokorokeke]

正確性はある程度あれば大丈夫なので、プレイヤーは座標を元にしたいくつかの定点に対するRayで済むでしょう。
しかし、複雑な形のオブジェクトの場合は｢座標+Vector3に飛ばせば良い｣というものが無いです。イメージとしては爆心にカメラを置いてRenderer.isVisibleやOnWillRenderObjectで判定するというのが近いのですが、影だけが映っててもtrueになったり、見た目とコライダーが違うものもあるのでどうしたものかなぁといった次第です。
https://teratail.com/questions/307597
↑似たような感じの質問はありましたが、数が増えるとこの解決法も重くなりそうです。
質問では内容が分かりやすい様に+より良い解決法があったら知りたいという事でプレイヤーを例にしました。

[fana]

> しかし、複雑な形のオブジェクトの場合は｢座標+Vector3に飛ばせば良い｣というものが無いです

どういう意味かよくわかりませんが，爆心から見て対象物を包括するだけの立体角範囲内を適当にサンプリングするのではダメなのですか？
その立体角範囲というのは対象物の形状に見合う形にした方が無駄なレイは減るのでしょうけど，処理の簡単さ/単純さ を考えるならば，「十分広い（＝対象を包括する），且つ，簡単に扱える形状な範囲」で良いのでは？　例えば，対象の外接球とかから定める等．

例えるなら，「十分な角度範囲に弾が散らばるショットガンを対象に向けてぶっ放したときに，その散弾のうちの一発でも対象にヒットするか？」みたいな．
各弾の軌道（レイ）に関する判定さえできるならば，残る問題は レイの密度 vs 処理速度 のトレードオフかと思うのですが．

Answer 1

追記

LayerMaskで特定のLayerと当たり判定をとる
扇状の当たり判定の取り方
扇状に当たり判定を取れば3枚目の画像でも判定を取ることができるのではないでしょうか？
↓プレイヤーにつける疑似的なコード

public class Player : MonoBehaviour
{
    private void Start()
    {
        LayerMask layerMask = 1 << LayerMask.NameToLayer("ObstacleLayer");

        if(Physics.Raycast(
            transform.position,
            new Vector3(-1f,0,0),
            out RaycastHit hit,
            Mathf.Infinity,
            layerMask))
        {
            Debug.Log("視認");
        }
    }
}

Comments

[korokorokeke]

Raycastを飛ばす適切な方向はどうやって求めるのでしょうか？
その場その場で壁の隙間の幅、位置、そもそも隙間があるかどうかも変わります。

[korokorokeke]

編集ありがとうございます。
ですが、そのスクリプトだと画像3枚目の場合当たってないと判断されてしまうと思います。

Answer 2

fanaさんの案は適切かと思います。レイをばらまく範囲を決める目安としてはboundsを使うのはどうでしょうか。

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

public static class BlastAreaRaycaster
{
	private static readonly Vector2[] Corners = new Vector2[8];
	private static readonly List<Vector2Int> Points = new List<Vector2Int>();

	/// <summary>
	///     <paramref name="collider" />が爆風の範囲内にあるかを判定します。
	/// </summary>
	/// <param name="collider">判定対象の<c>Collider</c>。</param>
	/// <param name="center">爆風の中心。</param>
	/// <param name="radius">爆風の半径。</param>
	/// <param name="ray"><paramref name="collider" />が爆風の範囲内にある場合、<paramref name="collider" />に衝突した<c>Ray</c>。</param>
	/// <param name="hitInfo"><paramref name="collider" />が爆風の範囲内にある場合、<paramref name="collider" />と<paramref name="ray" />の衝突情報。 </param>
	/// <param name="rayResolution"><c>Ray</c>の密度。</param>
	/// <returns><paramref name="collider" />が爆風の範囲内にある場合は<c>true</c>、それ以外の場合は<c>false</c>。</returns>
	/// <exception cref="ArgumentNullException" />
	public static bool Raycast(
		Collider collider,
		Vector3 center,
		float radius,
		out Ray ray,
		out RaycastHit hitInfo,
		int rayResolution = 8)
	{
		if (collider == null)
		{
			throw new ArgumentNullException(nameof(collider));
		}

		radius = Mathf.Max(radius, 0.0f);
		ray = new Ray();
		hitInfo = new RaycastHit();

		// 対象が非アクティブならヒットしない
		if (!collider.enabled || !collider.gameObject.activeInHierarchy)
		{
			return false;
		}

		// コライダーと爆風中心の距離が爆風の半径以上ならヒットしない
		if ((collider.ClosestPoint(center) - center).sqrMagnitude > (radius * radius))
		{
			return false;
		}

		// レイを発射する位置を決める
		// 縦横に走査する代わりに、ちょっと変則的にして範囲の中心付近を優先してみました
		// おそらく中心付近の方がレイがヒットする確率が高く、レイキャストをより早めに
		// 切り上げられるだろうと予想してのことです
		rayResolution = Mathf.Max(rayResolution, 1);
		var levelCount = Mathf.CeilToInt(rayResolution * 0.5f);
		var origin = rayResolution >> 1;
		var edgeLength = 2 - (rayResolution % 2);
		Points.Clear();
		for (var l = 0; l < levelCount; l++, origin++, edgeLength += 2)
		{
			var p = new Vector2Int(origin, origin);
			if (edgeLength < 2)
			{
				Points.Add(p);
			}
			else
			{
				var pa = p;
				var antipode = rayResolution - 1 - origin;
				var pb = new Vector2Int(antipode, antipode);
				for (var i = 0; i < edgeLength; i++)
				{
					Points.Add(pa);
					Points.Add(pb);
					if (i == (edgeLength - 1))
					{
						pa.y--;
						pb.y++;
						break;
					}

					pa.x--;
					pb.x++;
				}

				var trimmedEdgeLength = edgeLength - 2;
				for (var i = 0; i < trimmedEdgeLength; i++)
				{
					Points.Add(pa);
					Points.Add(pb);
					pa.y--;
					pb.y++;
				}
			}
		}

		// バウンディングボックス中心と爆風中心を結ぶ直線を基準とした、ボックスの角8点の位置を求める
		var bounds = collider.bounds;
		var viewToWorld = Matrix4x4.TRS(center, Quaternion.LookRotation(bounds.center - center), Vector3.one);
		var worldToView = viewToWorld.inverse;
		{
			var min = bounds.min;
			var max = bounds.max;
			for (var z = 0; z < 2; z++)
			{
				for (var y = 0; y < 2; y++)
				{
					for (var x = 0; x < 2; x++)
					{
						var v = worldToView.MultiplyPoint3x4(
							new Vector3(
								x == 0 ? min.x : max.x,
								y == 0 ? min.y : max.y,
								z == 0 ? min.z : max.z));
						Corners[(z << 2) | (y << 1) | x] = (Vector2)v / v.z;
					}
				}
			}
		}

		// 走査範囲の上下左右を決める
		var left = float.PositiveInfinity;
		var right = float.NegativeInfinity;
		var bottom = float.PositiveInfinity;
		var top = float.NegativeInfinity;
		var near = radius * 0.5f;
		foreach (var c in Corners)
		{
			var p = c * near;
			left = Mathf.Min(left, p.x);
			right = Mathf.Max(right, p.x);
			bottom = Mathf.Min(bottom, p.y);
			top = Mathf.Max(top, p.y);
		}

		// 走査範囲空間からワールド空間への変換行列を作成する
		var projectionToWorld =
			viewToWorld *
			Matrix4x4.Scale(new Vector3(1.0f, 1.0f, -1.0f)) *
			Matrix4x4.Frustum(left, right, bottom, top, near, radius).inverse;

		// レイキャストを行う
		foreach (var p in Points)
		{
			var r = new Ray(
				center,
				projectionToWorld.MultiplyPoint(
					new Vector3(
						(((p.x * 2.0f) + 1.0f) / rayResolution) - 1.0f,
						(((p.y * 2.0f) + 1.0f) / rayResolution) - 1.0f,
						0.0f)) - center);

			// レイを視覚的に確認するため、シーンビューにレイを描画する
			Debug.DrawRay(r.origin, r.direction * radius, Color.green);

			// レイがヒットし、かつそれが判定対象のコライダーなら爆風が当たったと判断して処理を打ち切る
			if (Physics.Raycast(r, out hitInfo, radius) && (hitInfo.collider == collider))
			{
				ray = r;
				return true;
			}
		}

		return false;
	}
}

下図はrayResolutionを8にセットした場合で、爆心地の周りを移動するオブジェクトに対して最大64本のレイキャストを行っています。ヒットした場合はオブジェクトを赤色に変えました。

爆心地にカメラを設置してオブジェクトを追跡したところ、このレイ密度だとかすかにカメラから見える状況では判定に落ちてしまうようでした。ですが爆風を受けるのがプレイヤー側なら、わずかに爆風がかすめただけでヒット判定が出てしまうのはむしろ理不尽に感じるかもしれませんので、これはこれでありなんじゃないかと思いました。

また、「Unityでオブジェクトの全体、もしくは一部がカメラに映っているかを判定したい」のikadzuchiさんの案も妥当なアプローチに感じましたので試してみました。こちらはシェーダー3つ、スクリプト1つの構成になっています。

障害物のマッピングを行うシェーダー

Shader "Hidden/BlastAreaObstacleMapping"
{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}
		_Color ("Main Color", Color) = (1.0, 1.0, 1.0, 1.0)
		_Cutoff ("Alpha cutoff", Range(0.0, 1.0)) = 0.5
	}

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

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

			struct appdata
			{
				float4 vertex : POSITION;
			};

			struct v2f
			{
				float3 viewPos : TEXCOORD0;
				float4 vertex : SV_POSITION;
			};

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

			float4 frag(v2f i) : SV_Target
			{
				return dot(i.viewPos, i.viewPos);
			}
			ENDCG
		}
	}

	SubShader
	{
		Tags { "Queue"="AlphaTest" "RenderType"="TransparentCutout" }

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

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

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

			sampler2D _MainTex;
			float4 _MainTex_ST;
			fixed4 _Color;
			fixed _Cutoff;

			v2f vert(appdata v)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.viewPos = UnityObjectToViewPos(v.vertex);
				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
				return o;
			}

			float4 frag (v2f i) : SV_Target
			{
				clip(tex2D(_MainTex, i.uv).a * _Color.a - _Cutoff);
				return dot(i.viewPos, i.viewPos);
			}
			ENDCG
		}
	}
}

遮蔽判定を行うシェーダー

Shader "Hidden/BlastAreaCheck"
{
	Properties {}

	SubShader
	{
		Pass
		{
			Name "Opaque"

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

			struct appdata
			{
				float4 vertex : POSITION;
			};

			struct v2f
			{
				float3 worldPos : TEXCOORD0;
				float4 vertex : SV_POSITION;
			};

			v2f vert(appdata v)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.worldPos = mul(unity_ObjectToWorld, v.vertex);
				return o;
			}

			samplerCUBE _ObstacleMap;
			float4 _CenterSqrRadius;

			float4 frag(v2f i) : SV_Target
			{
				float3 relativePos = i.worldPos - _CenterSqrRadius.xyz;
				float sqrDist = dot(relativePos, relativePos);
				clip(_CenterSqrRadius.w - sqrDist);
				clip(texCUBE(_ObstacleMap, relativePos).r - sqrDist);
				return 1.0;
			}
			ENDCG
		}

		Pass
		{
			Name "TransparentCutout"

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

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

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

			sampler2D _MainTex;
			float4 _MainTex_ST;
			fixed4 _Color;
			fixed _Cutoff;
			samplerCUBE _ObstacleMap;
			float4 _CenterSqrRadius;

			v2f vert(appdata v)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.worldPos = mul(unity_ObjectToWorld, v.vertex);
				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
				return o;
			}

			float4 frag (v2f i) : SV_Target
			{
				clip(_CenterSqrRadius.w - sqrDist);
				clip(tex2D(_MainTex, i.uv).a * _Color.a - _Cutoff);
				
				float3 relativePos = i.worldPos - _CenterSqrRadius.xyz;
				float sqrDist = dot(relativePos, relativePos);
				clip(texCUBE(_ObstacleMap, relativePos).r - sqrDist);
				return 1.0;
			}
			ENDCG
		}
	}
}

判定結果を集約するシェーダー

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

		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag

			#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;
			float4 _MainTex_TexelSize;

			fixed4 frag(v2f i) : SV_Target
			{
				float2 d = _MainTex_TexelSize.xy;
				return sign(dot(float4(
					tex2D(_MainTex, i.uv + d).r,
					tex2D(_MainTex, i.uv + float2(-d.x, d.y)).r,
					tex2D(_MainTex, i.uv + float2(d.x, -d.y)).r,
					tex2D(_MainTex, i.uv - d).r), 1.0));
			}
			ENDCG
		}
	}
}

（字数が尽きてしまったため、パート2に移ります...）

Answer 3

パート2

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

public static class BlastAreaChecker
{
	public enum TextureResolution
	{
		Low,
		Medium,
		High
	}

	/// <summary>
	///     障害物マップ作成時のニアプレーン。これより中心に近い障害物はマップに書き込まれません。
	/// </summary>
	public const float Near = 0.3f;

	private const string ObstacleMapShaderName = "Hidden/BlastAreaObstacleMapping";
	private const string CheckShaderName = "Hidden/BlastAreaCheck";
	private const string ReductionShaderName = "Hidden/BlastAreaReduction";
	private static Shader obstacleMapShader;
	private static Camera obstacleMapCamera;
	private static Transform obstacleMapCameraTransform;
	private static Vector4 centerAndSqrRadius;
	private static readonly List<RenderTexture> IntermediateBuffers = new List<RenderTexture>();
	private static Texture2D resultBuffer;
	private static readonly List<Renderer> TargetRenderers = new List<Renderer>();
	private static readonly List<Material> TargetMaterials = new List<Material>();
	private static readonly CommandBuffer CheckCommands = new CommandBuffer { name = "BlastAreaCheck" };
	private static readonly List<RenderingCommand> RenderingCommands = new List<RenderingCommand>();
	private static Material checkMaterial;
	private static Material reductionMaterial;
	private static readonly int MainTexProperty = Shader.PropertyToID("_MainTex");
	private static readonly int MainTexSTProperty = Shader.PropertyToID("_MainTex_ST");
	private static readonly int ColorProperty = Shader.PropertyToID("_Color");
	private static readonly int CutoffProperty = Shader.PropertyToID("_Cutoff");
	private static readonly int ObstacleMapProperty = Shader.PropertyToID("_ObstacleMap");
	private static readonly int CenterSqrRadiusProperty = Shader.PropertyToID("_CenterSqrRadius");
	private static readonly Vector3[] Corners = new Vector3[8];

	public static RenderTexture ObstacleMap { get; private set; }

	/// <summary>
	///     障害物マップを更新します。
	/// </summary>
	/// <param name="center">爆風の中心。</param>
	/// <param name="radius">爆風の半径。</param>
	/// <param name="obstacleLayerMask">障害物として扱うオブジェクトのレイヤーマスク。該当するレイヤーであっても、マテリアルが不透明やアルファカットアウトでないものは対象外となります。</param>
	/// <param name="resolution">マップの各面の解像度。<c>Low</c>は64x64、<c>Medium</c>は256x256、<c>High</c>は1024x1024です。</param>
	public static void CaptureObstacles(
		Vector3 center,
		float radius,
		int obstacleLayerMask = -5,
		TextureResolution resolution = TextureResolution.Medium)
	{
		if (obstacleMapShader == null)
		{
			obstacleMapShader = FindShader(ObstacleMapShaderName);
		}

		// マップが未作成なら新規作成、または解像度設定が変更されたら再作成する
		var resolutionInPixels = 1 << ((3 + (int)resolution) * 2);
		if ((ObstacleMap == null) || (ObstacleMap.width != resolutionInPixels))
		{
			Object.Destroy(ObstacleMap);
			ObstacleMap = new RenderTexture(resolutionInPixels, resolutionInPixels, 24, RenderTextureFormat.RFloat)
			{
				dimension = TextureDimension.Cube
			};
			ObstacleMap.Create();
		}

		// マップキャプチャー用のカメラが未作成なら作成する
		if (obstacleMapCamera == null)
		{
			var cameraObject = new GameObject("Obstacle Map Camera");
			var camera = cameraObject.AddComponent<Camera>();
			camera.clearFlags = CameraClearFlags.SolidColor;
			camera.enabled = false;
			cameraObject.hideFlags = HideFlags.NotEditable;
			obstacleMapCamera = camera;
			obstacleMapCameraTransform = camera.transform;
		}

		// カメラの周囲を撮影し、マップ上にカメラからの2乗距離をレンダリングする
		// 解像度設定によっては、なぜか背景がうまくクリアされないことがあったが
		// 背景だけを一度レンダリングしてからあらためてオブジェクトをレンダリングすると
		// 意図通りになったため、RenderToCubemapを2回実行している
		radius = Mathf.Max(radius, Near);
		var sqrRadius = radius * radius;
		obstacleMapCamera.backgroundColor = new Color(sqrRadius, sqrRadius, sqrRadius);
		obstacleMapCamera.farClipPlane = radius;
		obstacleMapCamera.nearClipPlane = Near;
		obstacleMapCamera.SetReplacementShader(obstacleMapShader, "RenderType");
		obstacleMapCameraTransform.position = center;
		obstacleMapCamera.cullingMask = 0;
		obstacleMapCamera.RenderToCubemap(ObstacleMap);
		obstacleMapCamera.cullingMask = obstacleLayerMask;
		obstacleMapCamera.RenderToCubemap(ObstacleMap);
		centerAndSqrRadius = center;
		centerAndSqrRadius.w = sqrRadius;
	}

	/// <summary>
	///     現在の障害物マップを使って、<paramref name="gameObject" />が爆風の範囲内にあるかを判定します。
	/// </summary>
	/// <param name="gameObject">判定対象のオブジェクト。マテリアルが不透明やアルファカットアウトでないものは対象外となります。</param>
	/// <param name="resolution">判定用テクスチャの解像度。<c>Low</c>は64x64、<c>Medium</c>は256x256、<c>High</c>は1024x1024です。</param>
	/// <returns><paramref name="gameObject" />が爆風の範囲内にある場合は<c>true</c>、それ以外の場合は<c>false</c>。</returns>
	public static bool Check(GameObject gameObject, TextureResolution resolution = TextureResolution.Medium)
	{
		if (gameObject == null)
		{
			throw new ArgumentNullException(nameof(gameObject));
		}

		if (ObstacleMap == null)
		{
			Debug.LogError($"Execute {nameof(CaptureObstacles)} to create obstacle map.");
			return false;
		}

		// 非アクティブならヒットしない
		if (!gameObject.activeInHierarchy)
		{
			return false;
		}

		CreateMaterialIfNeeded(CheckShaderName, ref checkMaterial);
		CreateMaterialIfNeeded(ReductionShaderName, ref reductionMaterial);

		// 判定結果を段階的に縮小して集約するためのテクスチャを用意する
		var requiredBufferCount = 4 + (int)resolution;
		var currentBufferCount = IntermediateBuffers.Count;
		for (var i = currentBufferCount; i < requiredBufferCount; i++)
		{
			var size = 1 << (i * 2);
			var buffer = new RenderTexture(size, size, 0, RenderTextureFormat.R8);
			buffer.autoGenerateMips = false;
			buffer.Create();
			IntermediateBuffers.Add(buffer);
		}

		// 1ピクセルに集約された判定結果を受け取るためのテクスチャを用意する
		if (resultBuffer == null)
		{
			resultBuffer = new Texture2D(1, 1, TextureFormat.R8, false, true, true);
		}

		// 判定対象の条件に合致するレンダラーを抜き出して描画コマンドを構築する
		// 併せて、描画範囲を決めるためにレンダラーのバウンディングボックスを求める
		var totalBounds = new Bounds(new Vector3(float.NaN, float.NaN, float.NaN), Vector3.zero);
		RenderingCommands.Clear();
		gameObject.GetComponentsInChildren(TargetRenderers);
		foreach (var targetRenderer in TargetRenderers)
		{
			if (!targetRenderer.enabled)
			{
				continue;
			}

			var mesh = (targetRenderer as SkinnedMeshRenderer)?.sharedMesh;
			if ((mesh == null) && targetRenderer is MeshRenderer)
			{
				mesh = targetRenderer.GetComponent<MeshFilter>().sharedMesh;
			}

			var subMeshCount = mesh == null ? 1 : mesh.subMeshCount;
			targetRenderer.GetSharedMaterials(TargetMaterials);
			var materialCount = TargetMaterials.Count;
			var willBeRendered = false;
			for (var i = 0; i < materialCount; i++)
			{
				var command = new RenderingCommand();
				var material = TargetMaterials[i];
				var renderType = material.GetTag("RenderType", false);
				if (renderType == "TransparentCutout")
				{
					var textureScale = material.GetTextureScale(MainTexProperty);
					var textureOffset = material.GetTextureOffset(MainTexProperty);
					command.IsCutout = true;
					command.Texture = material.mainTexture;
					command.ScaleOffset = new Vector4(textureScale.x, textureScale.y, textureOffset.x, textureOffset.y);
					command.Color = material.color;
					command.Cutoff = material.GetFloat(CutoffProperty);
				}
				else if (renderType != "Opaque")
				{
					continue;
				}

				command.Renderer = targetRenderer;
				command.SubmeshIndex = i % subMeshCount;
				RenderingCommands.Add(command);
				willBeRendered = true;
			}

			if (willBeRendered)
			{
				var bounds = targetRenderer.bounds;
				if (float.IsNaN(totalBounds.center.x))
				{
					totalBounds = bounds;
				}
				else
				{
					totalBounds.Encapsulate(bounds);
				}
			}
		}

		// バウンディングボックスが得られなければ中断する
		if (float.IsNaN(totalBounds.center.x))
		{
			return false;
		}

		// 求めたバウンディングボックスを狙う形の座標変換行列を作る
		// バウンディングボックス中心と爆風中心を結ぶ直線を基準とした、ボックスの角8点の位置を求める
		var center = (Vector3)centerAndSqrRadius;
		var viewToWorld = Matrix4x4.TRS(center, Quaternion.LookRotation(totalBounds.center - center), Vector3.one);
		var worldToView = viewToWorld.inverse;
		{
			var min = totalBounds.min;
			var max = totalBounds.max;
			for (var z = 0; z < 2; z++)
			{
				for (var y = 0; y < 2; y++)
				{
					for (var x = 0; x < 2; x++)
					{
						var p = worldToView.MultiplyPoint3x4(
							new Vector3(
								x == 0 ? min.x : max.x,
								y == 0 ? min.y : max.y,
								z == 0 ? min.z : max.z));
						p.z = Mathf.Max(p.z, Near);
						Corners[(z << 2) | (y << 1) | x] = p;
					}
				}
			}
		}

		// プロジェクション行列の前後を決める
		var near = float.PositiveInfinity;
		var far = Near;
		foreach (var c in Corners)
		{
			near = Mathf.Min(near, c.z);
			far = Mathf.Max(far, c.z);
		}

		var radius = Mathf.Max(Mathf.Sqrt(centerAndSqrRadius.w), Near);
		near = Mathf.Max(near, Near);
		far = Mathf.Min(far, radius);

		// プロジェクション行列の上下左右を決める
		var left = float.PositiveInfinity;
		var right = float.NegativeInfinity;
		var bottom = float.PositiveInfinity;
		var top = float.NegativeInfinity;
		foreach (var c in Corners)
		{
			var p = (Vector2)c * (near / c.z);
			left = Mathf.Min(left, p.x);
			right = Mathf.Max(right, p.x);
			bottom = Mathf.Min(bottom, p.y);
			top = Mathf.Max(top, p.y);
		}

（スクリプトの途中ですが、また字数が尽きたためパート3に移ります...）

Answer 4

パート3

		// 判定用レンダリングを行うCommandBufferを構築する
		var bufferIndex = requiredBufferCount - 1;
		CheckCommands.Clear();
		CheckCommands.SetRenderTarget(IntermediateBuffers[bufferIndex]);
		CheckCommands.ClearRenderTarget(true, true, Color.black);
		CheckCommands.SetGlobalTexture(ObstacleMapProperty, ObstacleMap);
		CheckCommands.SetGlobalVector(CenterSqrRadiusProperty, centerAndSqrRadius);
		CheckCommands.SetViewProjectionMatrices(
			Matrix4x4.Scale(new Vector3(1.0f, 1.0f, -1.0f)) * worldToView,
			Matrix4x4.Frustum(left, right, bottom, top, near, far));
		foreach (var command in RenderingCommands)
		{
			var pass = 0;
			if (command.IsCutout)
			{
				pass = 1;
				CheckCommands.SetGlobalTexture(MainTexProperty, command.Texture);
				CheckCommands.SetGlobalVector(MainTexSTProperty, command.ScaleOffset);
				CheckCommands.SetGlobalColor(ColorProperty, command.Color);
				CheckCommands.SetGlobalFloat(CutoffProperty, command.Cutoff);
			}

			CheckCommands.DrawRenderer(command.Renderer, checkMaterial, command.SubmeshIndex, pass);
		}

		for (var i = bufferIndex; i > 0; i--)
		{
			CheckCommands.Blit(IntermediateBuffers[i], IntermediateBuffers[i - 1], reductionMaterial);
		}

		// 判定用レンダリングを実行し、結果を取得する
		var currentTarget = RenderTexture.active;
		Graphics.ExecuteCommandBuffer(CheckCommands);
		RenderTexture.active = IntermediateBuffers[0];
		resultBuffer.ReadPixels(new Rect(0, 0, 1, 1), 0, 0);
		RenderTexture.active = currentTarget;
		var result = resultBuffer.GetPixel(0, 0);
		TargetRenderers.Clear();
		TargetMaterials.Clear();
		return result.r > 0.5f;
	}

	private static void CreateMaterialIfNeeded(string shaderName, ref Material material)
	{
		if (material != null)
		{
			return;
		}

		material = new Material(FindShader(shaderName));
	}

	private static Shader FindShader(string shaderName)
	{
		var shader = Shader.Find(shaderName);
		if (shader == null)
		{
			throw new ShaderNotFoundException($"{shaderName} not found.");
		}

		return shader;
	}

	private static void DestroyResources()
	{
		if (obstacleMapCameraTransform != null)
		{
			Object.Destroy(obstacleMapCameraTransform.gameObject);
		}

		Object.Destroy(ObstacleMap);
		foreach (var buffer in IntermediateBuffers)
		{
			Object.Destroy(buffer);
		}

		Object.Destroy(resultBuffer);
		Object.Destroy(checkMaterial);
		Object.Destroy(reductionMaterial);
		Application.quitting -= DestroyResources;
	}

	[RuntimeInitializeOnLoadMethod]
	private static void RegisterDestroyResources()
	{
		Application.quitting += DestroyResources;
	}

	public class ShaderNotFoundException : Exception
	{
		public ShaderNotFoundException(string message) : base(message)
		{
		}
	}

	private struct RenderingCommand
	{
		public Renderer Renderer;
		public int SubmeshIndex;
		public bool IsCutout;
		public Texture Texture;
		public Vector4 ScaleOffset;
		public Color Color;
		public float Cutoff;
	}
}

今回の実験では、判定メソッドをCaptureObstaclesとCheckの2段階に分けました。まずCaptureObstaclesで爆心地から見た周囲の状況をキャプチャーします。結果をスカイボックスとして可視化すると下図のように見えます。

その後、CheckではオブジェクトのレンダラーのバウンディングボックスをBlastAreaRaycasterのときと同様に狙って、判定用のレンダリングを行います。描画された判定結果は、ikadzuchiさんの案を採用して1x1に縮小してから読み取りました。

メソッドを2段階に分けたのは、複数個のオブジェクトを判定する場合の効率化を狙ってのことです。障害物マップは爆心地の位置と半径、および半径内の障害物が変化しない限りは再利用できますので、CaptureObstaclesを1回行ってから爆風が当たる可能性のあるオブジェクトにそれぞれCheckを行うことにすれば、やや高コストであるキューブマップレンダリングの回数を抑えられるだろうと考えました。

実行時の様子は下図のようになりました。CaptureObstaclesはリフレクションプローブを更新するのと同じぐらいの、Checkはオブジェクトをレンダリングするのと同じぐらいの描画コストがかかるだろうと思いますが、判定の解像度はレイ数万～100万本に相当するレベルが期待できますので、精密な判定が必要なら手段の候補に入れてみてもいいんじゃないかと思います。

ただし判定はコライダーではなくレンダラーに基づいていますので、ご質問者さんがおっしゃるようなレンダラーとコライダーの形が違うケースでは使いづらいかもしれません。コライダーの形で判定するには、コライダーの形の判定用メッシュを生成するなどのさらなる改造が必要になるかと思います。また、判定結果を取得するコストを削減するため1x1ピクセルに縮小する処理を加えましたので、どの位置に当たったかを特定する情報は失われてしまうのも弱点と言えそうです。