unity オブジェクト 衝突 凹ませる

Question

前提・実現したいこと

ここに質問の内容を詳しく書いてください。
Unity 3Dでゲームを作っています。簡単に言うと彫刻ゲームのようなものをつくりたいです。
球状のオブジェクトをマウスで移動させ、左ドラッグしている間、元石が削られるようなものです。
まずは当たり判定したオブジェクトのメッシュ変形をさせるようなものを考えているのですが、なかなか参考になるようなページが見つかりません。
（ブーリアン演算ではなかなかゲーム中リアルタイムに行っているものがなく、またステンシルバッファのようなものを利用したとしても、オブジェクトが削られた後、さらに削っていく、といったプロセスが行えず、やはりメッシュをだんだんと変形させていくしかないかと思っています）。
いちばんイメージに近いものではterrainに洞窟を掘るようなものですが、やはりこちらもゲーム中に操作で穴を掘る、というよりも洞窟のあるシーンを作る、というものでゲーム自体が削るものではありません。

抽象的な質問で申し訳ございませんが、なるべく多くのヒントを頂きたいと思っています。
ご参考になるようなC#スクリプト（例えば削る側/削られる側にアタッチするもの）や、参考になるページやアセットなど、幅広くアドバイス頂きたいです。よろしくお願い致します。

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

エラーメッセージ

該当のソースコード

ソースコード

試したこと

ここに問題に対して試したことを記載してください。

ステンシルバッファ

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

ここにより詳細な情報を記載してください。

Answer 1

SkinnedMeshRendererで表現できないかと思い、下記のようなスクリプトを試してみました。

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
#endif

public class ClayCuboid : MonoBehaviour
{
	[SerializeField] private Material material;
	[SerializeField][Range(1.0f, 32.0f)] private float verticesPerUnitHint = 16.0f;
	[SerializeField][Range(1.0f, 8.0f)] private float controlPointsPerUnitHint = 4.0f;
	[SerializeField][Range(0.0f, 256.0f)] private float controlPointDrag = 32.0f;
	[SerializeField][Range(0.0f, 256.0f)] private float density = 16.0f;
	[SerializeField] private bool useGravity;

	private void Awake()
	{
		// 現在のスケールを粘土ブロックの大きさを示すものとして...
		var size = this.transform.localScale;

		// X、Y、Z方向の頂点数、コントロールポイント数を決める
		var vertexCounts = Vector3Int.Max(Vector3Int.CeilToInt(size * this.verticesPerUnitHint), Vector3Int.one);
		var controlPointCounts = Vector3Int.Max(Vector3Int.CeilToInt(size * this.controlPointsPerUnitHint), Vector3Int.one);
		var controlPointIntervals = new Vector3(
			size.x / controlPointCounts.x,
			size.y / controlPointCounts.y,
			size.z / controlPointCounts.z);

		// コントロールポイントの半径は、さしあたり互いに重ならない最大量とする
		var controlPointRadius = Mathf.Min(
			Mathf.Min(controlPointIntervals.x, controlPointIntervals.y),
			controlPointIntervals.z) * 0.5f;

		// オブジェクト自体のスケールは(1, 1, 1)に戻し...
		this.transform.localScale = Vector3.one;

		// 粘土ブロックの表面下にコントロールポイントを並べる
		var controlPoints = new List<Transform>();
		var controlPointOffset = (controlPointIntervals - size) * 0.5f;
		for (var k = 0; k < controlPointCounts.z; k++)
		{
			for (var j = 0; j < controlPointCounts.y; j++)
			{
				for (var i = 0; i < controlPointCounts.x; i++)
				{
					if ((i != 0) && (i != (controlPointCounts.x - 1)) &&
						(j != 0) && (j != (controlPointCounts.y - 1)) &&
						(k != 0) && (k != (controlPointCounts.z - 1)))
					{
						continue;
					}

					var controlPoint = new GameObject($"({i:D2}, {j:D2}, {k:D2})").transform;
					controlPoints.Add(controlPoint);
					controlPoint.SetParent(this.transform, false);
					controlPoint.localPosition = Vector3.Scale(new Vector3(i, j, k), controlPointIntervals) + controlPointOffset;
				}
			}
		}

		// コントロールポイントにSphereCollider、Rigidbodyをアタッチする
		var controlPointMass = (this.density * size.x * size.y * size.z) / controlPoints.Count;
		foreach (var controlPoint in controlPoints)
		{
			var controlPointCollider = controlPoint.gameObject.AddComponent<SphereCollider>();
			controlPointCollider.radius = controlPointRadius;
			var controlPointRigidbody = controlPoint.gameObject.AddComponent<Rigidbody>();
			controlPointRigidbody.drag = this.controlPointDrag;
			controlPointRigidbody.angularDrag = this.controlPointDrag;
			controlPointRigidbody.mass = controlPointMass;
			controlPointRigidbody.useGravity = this.useGravity;
		}

		// メッシュを作成する
		var vertices = new List<Vector3>();
		var uvs = new List<Vector2>();
		var indices = new List<int>();
		var halfExtents = size * 0.5f;
		CreateFace(
			vertices, uvs, indices,
			-halfExtents,
			Vector3.right, Vector3.up,
			new Vector2(size.x, size.y),
			new Vector2Int(vertexCounts.x, vertexCounts.y));
		CreateFace(
			vertices, uvs, indices,
			-halfExtents,
			Vector3.up, Vector3.forward,
			new Vector2(size.y, size.z),
			new Vector2Int(vertexCounts.y, vertexCounts.z));
		CreateFace(
			vertices, uvs, indices,
			-halfExtents,
			Vector3.forward, Vector3.right,
			new Vector2(size.z, size.x),
			new Vector2Int(vertexCounts.z, vertexCounts.x));
		CreateFace(
			vertices, uvs, indices,
			halfExtents,
			-Vector3.right, -Vector3.up,
			new Vector2(size.x, size.y),
			new Vector2Int(vertexCounts.x, vertexCounts.y),
			true);
		CreateFace(
			vertices, uvs, indices,
			halfExtents,
			-Vector3.up, -Vector3.forward,
			new Vector2(size.y, size.z),
			new Vector2Int(vertexCounts.y, vertexCounts.z),
			true);
		CreateFace(
			vertices, uvs, indices,
			halfExtents,
			-Vector3.forward, -Vector3.right,
			new Vector2(size.z, size.x),
			new Vector2Int(vertexCounts.z, vertexCounts.x),
			true);
		var parentToLocal = Matrix4x4.identity;
		var weights = new BoneWeight1[4];
		var mesh = new Mesh
		{
			name = "Clay Cuboid",
			vertices = vertices.ToArray(),
			uv = uvs.ToArray(),
			triangles = indices.ToArray(),
			bindposes = controlPoints.Select(
				c =>
				{
					Debug.Assert(Matrix4x4.Inverse3DAffine(Matrix4x4.TRS(c.localPosition, c.localRotation, c.localScale), ref parentToLocal));
					return parentToLocal;
				}).ToArray(),
			// 頂点に対して最大4個のコントロールポイントが影響する
			// 影響率はさしあたりコントロールポイントへの距離の2乗に反比例させた
			boneWeights = vertices.Select(
				v =>
				{
					for (var i = 0; i < weights.Length; i++)
					{
						weights[i].boneIndex = 0;
						weights[i].weight = float.PositiveInfinity;
					}

					var j = 0;
					foreach (var sqrDistancesAndIndex in controlPoints.Select((c, i) => ((c.localPosition - v).sqrMagnitude, i)).OrderBy(ci => ci.Item1).Take(weights.Length))
					{
						weights[j].boneIndex = sqrDistancesAndIndex.Item2;
						weights[j].weight = sqrDistancesAndIndex.Item1;
						j++;
					}

					var weightSum = 0.0f;
					for (var i = 0; i < weights.Length; i++)
					{
						weights[i].weight = 1.0f / weights[i].weight;
						weightSum += weights[i].weight;
					}

					var boneWeight = new BoneWeight();
					if (weightSum > 0.0f)
					{
						boneWeight.boneIndex0 = weights[0].boneIndex;
						boneWeight.boneIndex1 = weights[1].boneIndex;
						boneWeight.boneIndex2 = weights[2].boneIndex;
						boneWeight.boneIndex3 = weights[3].boneIndex;
						boneWeight.weight0 = weights[0].weight / weightSum;
						boneWeight.weight1 = weights[1].weight / weightSum;
						boneWeight.weight2 = weights[2].weight / weightSum;
						boneWeight.weight3 = weights[3].weight / weightSum;
					}

					return boneWeight;
				}).ToArray()
		};
		mesh.RecalculateNormals();
		mesh.RecalculateTangents();

		// レンダラーを作成しメッシュをセットする
		var meshRenderer = this.gameObject.AddComponent<SkinnedMeshRenderer>();
		meshRenderer.sharedMesh = mesh;
		meshRenderer.bones = controlPoints.ToArray();
		meshRenderer.sharedMaterial = this.material;
	}

	private static void CreateFace(
		List<Vector3> vertices,
		List<Vector2> uvs,
		List<int> indices,
		Vector3 origin,
		Vector3 u,
		Vector3 v,
		Vector2 size,
		Vector2Int divisions,
		bool invert = false)
	{
		var indexOffset = vertices.Count;
		vertices.AddRange(
			Enumerable.Range(0, divisions.y + 1).SelectMany(
				j => Enumerable.Range(0, divisions.x + 1).Select(
					i => origin + (u * ((i * size.x) / divisions.x)) + (v * ((j * size.y) / divisions.y)))));
		uvs.AddRange(
			Enumerable.Range(0, divisions.y + 1).SelectMany(
				j => Enumerable.Range(0, divisions.x + 1)
					.Select(i => new Vector2((float)i / divisions.x, (float)j / divisions.y))));
		indices.AddRange(
			Enumerable.Range(0, divisions.y).SelectMany(
				j => Enumerable.Range(0, divisions.x)
					.SelectMany(
						i =>
						{
							var i00 = i + (j * (divisions.x + 1));
							var i01 = i00 + 1;
							var i10 = i00 + divisions.x + 1;
							var i11 = i10 + 1;
							i00 += indexOffset;
							i01 += indexOffset;
							i10 += indexOffset;
							i11 += indexOffset;
							return invert
								? new[] {i00, i01, i10, i11, i10, i01}
								: new[] {i00, i10, i01, i11, i01, i10};
						})));
	}

	#if UNITY_EDITOR
	private void OnDrawGizmos()
	{
		if (EditorApplication.isPlaying)
		{
			return;
		}

		// シーン編集中の段階では、シーンビューに直方体を描画して
		// オブジェクトの大きさや配置を確認しやすくする
		Gizmos.color = new Color(0.8f, 0.2f, 0.0f);
		Gizmos.matrix = this.transform.localToWorldMatrix;
		Gizmos.DrawCube(Vector3.zero, Vector3.one);
	}

	[MenuItem("GameObject/3D Object/Clay Cuboid")]
	public static void Create()
	{
		var newObject = new GameObject("Clay Cuboid");
		Undo.RegisterCreatedObjectUndo(newObject, "Create Clay Cuboid");
		var clayCuboid = Undo.AddComponent<ClayCuboid>(newObject);
		var dummyObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
		clayCuboid.material = dummyObject.GetComponent<Renderer>().sharedMaterial;
		DestroyImmediate(dummyObject);
	}
	#endif
}

メニューからオブジェクトを作成し...

適当に伸縮させて配置すると下図のように見えます。

実行時には、下図のようにブロック表面に沿ってSphereColliderを持ったオブジェクトが配置されます。

SkinnedMeshRendererの皮をかぶせた状態でこれらオブジェクトが物理的相互作用によって動けば、メッシュがひずんで見えるんじゃないかと考えました。

まあそれなりの見た目になったんじゃないかと思いますが、このやり方では上図のように物体を貫通して穴を開けようとしても、トポロジー的に異なる形状にはなれないため表面が引き伸ばされるだけとなってしまいます。
また、粘土細工のように精密な変形をさせるにはもっと大量のコライダーを配置する必要がありそうで、重すぎて実用に耐えないかもしれません。スカルプトモデリングソフトのようなことをさせたいのでしたら、おそらく根本的に方針を変えなければならないような気がします。

この方式だと大ざっぱな変形しか対応困難でしょうが、Unityの物理シミュレーションシステムをそのまま使っているので、シーン上の物体と相互作用させてそれっぽく見せかけるのには向いていると思います。たとえばDragをもっと小さくし、Use Gravityをオンにすると落下するようになり、地面と衝突して潰れてひしゃげます。

今回の例では個々のコントロールポイントが自由に動けますが、たとえば互いにジョイントで連結してある程度の復元力を持たせれば、ところてんの塊のようなプルンプルンした物体を作ることもできそうな気がします。

Comments

[911RSR]

大変気合の入ったご回答、動画までつけて頂き、詳細なスクリプトまで本当にありがとうございます！
mesh deformationに近いですね。最終的な力技はこちらい行きつくかもしれません。
もう少し試してみます！ありがとうございます。

Answer 2

凹みtipsのブーリアン演算を実装し解決しました！ご教示ありがとうございました。