unity 3D 切り取り

Question

前提・実現したいこと

物体（削られる側）と対象A（削る側）が位置しており、物体に対象Aが接触すると物体が削れていく3D Unityを作成したい。
ゲームでは3Dで彫刻ができるイメージで、物体（削られる側）対象A（削る側）はblenderで出力された.objが使えればよいと考えています。
2020.4にBongoさんが回答されていたスクリプトhttps://teratail.com/questions/252026?sort=2#3794を拝見しましたが、応用できなかったので質問させていただきました。unityで3Dの切り取りは可能でしょうか。

Comments

[Bongo]

確かにあれは見た目こそ3Dではあるものの、実態は2Dでの削り取りですからね...

後ろ向きな意見で申しわけないのですが、何かもっと妥協できる要素はないでしょうかね?
といいますのも、もし本気で削られる側も任意のOBJ、削る側も任意のOBJとなりますと、以前別の方の「unityでgameobjectを部分的に消去したい」（https://teratail.com/questions/210980 ）で挙げさせていただいた「Simple and Robust Boolean Operations for Triangulated Surfaces」（https://arxiv.org/pdf/1308.4434.pdf ）みたいな方法で頑張らないといけない気がしまして、2Dの「unity 切り取り」ですら3回答にまたがってしまったことを考えると、回答に投稿するには相当長大になってしまう、まともな速度で動かせるか分からない、そもそも実装できるか自信がない...という印象です（自身の勉強には面白そうな題材ですので挑戦するのはやぶさかではないのですが、おそらくだいぶ時間がかかってしまうでしょう...）。
「unityでgameobjectを部分的に消去したい」の回答で申し上げた妥協案の場合、モデルを単なるキューブの集合体で表現しているため1回答におさまりました。また、さらに別の方で「unity オブジェクト　衝突　凹ませる」（https://teratail.com/questions/287774 ）ではSkinnedMeshRendererで直方体をへこませてみましたが、彫刻のような精密な変形はできないでしょう。

アセットストアを探してみても、なかなかこれぞというものはなさそうな感じですね...
「Sculpt」で検索（https://assetstore.unity.com/?category=tools&q=Sculpt&orderBy=1 ）してみたところ出てきたVoxel Generator（https://assetstore.unity.com/packages/tools/terrain/voxel-generator-162883 ）だとかはすごそうに思えますが、任意のモデル同士で削り取りを行うものではなさそうに見えます。
EditorSculpt（https://assetstore.unity.com/packages/tools/modeling/editorsculpt-63320 ）も面白そうですが、エディター上でのモデリングであることと、「任意のモデルを任意のモデルで削り取る」というのとはちょっと違うかな...という印象ですね。
何か「これと似た挙動にしたい」みたいな実例をご提示いただけると実現（あるいは妥協点の模索）の手がかりになるかもしれません。

[T_T2]

Bongoさんから直接ご連絡いただけるとは思ってもいませんでした！こんな抽象的な質問にも丁寧に対応してくださって感謝しかありません。
さて本題ですが、添付された資料を拝見しましたが、やはり現状では一筋縄ではいかなそうですね…
しかしそのなかでも、https://teratail.com/questions/287774に記載されていた「ブロック表面に沿ってSphereColliderを持ったオブジェクト」をみて思いついたのですが、任意のOBJをすべて細かいドット状にして、その細かいドットに当たったものを消していく？ような方法はいかかでしょうか。
自分が考えている彫刻は、小さいものでアクセサリーなんかを細かくかたちずくれたらいいなと思っています。

Answer 1

パート3

削り役の棍棒もシーンに配置し、こちらには下記スクリプトをアタッチしました。ですが実際のところこちらのスクリプトは削り取りを実演してみせる上での脇役で、マウス操作に応じて棍棒を動かし、スペースキーで削り取りを実行する機能しかありません。

using System.Collections;
using UnityEngine;

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class Carver : MonoBehaviour
{
	[SerializeField] private Carvee target;
	[SerializeField][Range(0.0f, 50.0f)] private float rotationSpeed = 10.0f;
	[SerializeField][Range(0.0f, 5.0f)] private float pushPullSpeed = 1.0f;
	[SerializeField] private Color inactiveColor = Color.green;
	[SerializeField] private Color activeColor = Color.red;

	private Material carverMaterial;
	private Mesh carverMesh;
	private float distance;
	private float horizontalAngle;
	private float verticalAngle;

	private IEnumerator Start()
	{
		yield return null;
		Cursor.lockState = CursorLockMode.Locked;
		var meshFilter = this.GetComponent<MeshFilter>();
		this.carverMesh = meshFilter.sharedMesh;
		var meshRenderer = this.GetComponent<MeshRenderer>();
		this.carverMaterial = meshRenderer.material;
		var relativePosition = this.transform.position - this.target.Center;
		this.distance = relativePosition.magnitude;
		var direction = relativePosition.normalized;
		this.verticalAngle = Mathf.Asin(direction.y) * Mathf.Rad2Deg;
		this.horizontalAngle = Mathf.Atan2(direction.z, direction.x) * Mathf.Rad2Deg;
	}
	
	private void Update()
	{
		if (this.carverMesh == null)
		{
			return;
		}

		// マウス左右で水平に、上下で垂直に回転し
		// 左ボタン・右ボタンで前後に動かす
		var mouseX = Input.GetAxis("Mouse X");
		var mouseY = Input.GetAxis("Mouse Y");
		var push = Input.GetMouseButton(0) ? this.pushPullSpeed * Time.deltaTime : 0.0f;
		var pull = Input.GetMouseButton(1) ? this.pushPullSpeed * Time.deltaTime : 0.0f;
		this.distance = Mathf.Max(0.0f, (this.distance - push) + pull);
		this.horizontalAngle = (this.horizontalAngle + (mouseX * this.rotationSpeed)) % 360.0f;
		this.verticalAngle = Mathf.Clamp(this.verticalAngle + (mouseY * this.rotationSpeed), -90.0f, 90.0f);
		var h = this.horizontalAngle * Mathf.Deg2Rad;
		var v = this.verticalAngle * Mathf.Deg2Rad;
		var sinH = Mathf.Sin(h);
		var cosH = Mathf.Cos(h);
		var sinV = Mathf.Sin(v);
		var cosV = Mathf.Cos(v);
		var direction = new Vector3(cosH * cosV, sinV, sinH * cosV);
		var center = this.target.Center;
		this.transform.position = center + (direction * this.distance);
		this.transform.LookAt(center);

		// スペースキーを押している間、毎フレームCarveを行う
		if (Input.GetKey(KeyCode.Space))
		{
			this.carverMaterial.color = this.activeColor;
			this.target.Carve(this.carverMesh, this.transform);
		}
		else
		{
			this.carverMaterial.color = this.inactiveColor;
		}
	}
	
	private void OnDestroy()
	{
		Cursor.lockState = CursorLockMode.None;
	}
}

プレイモードにすると、Carveeが元々のメッシュをベースにモアイ像の断面を描き、ボリュームテクスチャを生成します。
スクリプト内のvolumeは下図のようになっており、Carve実行によってボクセルを消していくことで削られたように見せようと考えました。

削る様子はこんな感じです。彫刻...というにはちょっと精密さに欠け、貴重な遺物を破壊しているだけになってしまいました。

弱点としては、やはりある程度の解像度がないと精密に削れない点でしょうね。今回はvoxelsPerUnitが128で、身長をおよそ2mに調整した状態でボクセル化しており、テクスチャのサイズは120×95×272です。元々のモアイ像は下図のようになめらかですが...

今回の程度のボクセル密度だと、実行時の外観は3Dプリンターで成形したばかりのようにデコボコです。

かといってもっと解像度を上げようにも、縦横高さが2倍になると体積は8倍に膨れ上がってしまいますから簡単にはいかないでしょうね...

また、彫り上がったものを保存する機能は省略しました。保存するとしたらボリュームデータとしてそのまま保存するか、あるいはマーチングキューブ法だとかで表面を張り、メッシュに変換してやることになるかと思います。

Answer 2

パート2

断面描画用、およびシーン上での描画用に下記シェーダーを作成しました。

Shader "Volume/Slice"
{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}
	}
	SubShader
	{
		// メッシュの断面を描くパス
		// 両面描画とし、表面なら透明、裏面なら白で塗る
		// これを使い、閉じたポリゴンモデルをニアクリップ面で切断するような構図で
		// 描画すると、切断面から裏面を覗く形になって断面の形が描かれるはず
		Pass
		{
			Cull Off

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

			float4 vert(float4 vertex : POSITION) : SV_POSITION
			{
				return UnityObjectToClipPos(vertex);
			}

			fixed4 frag(fixed faceDirection : VFACE) : SV_Target
			{
				return (1.0 - faceDirection) * 0.5;
			}
			ENDCG
		}

		// 断面を削り取るパス
		// 削られる側の断面画像を削る側の断面画像で削る際に使う
		// 削る側の断面を白黒反転し、削られる側の断面に
		// 乗算合成することで削り取る
		Pass
		{
			Cull Off
			ZWrite Off
			ZTest Always
			Blend DstColor Zero

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

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

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

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

			sampler2D _MainTex;

			fixed4 frag(v2f i) : SV_Target
			{
				return 1.0 - tex2D(_MainTex, i.uv);
			}
			ENDCG
		}
	}
}

Shader "Volume/Volume"
{
	Properties
	{
		_MainTex ("Volume", 3D) = "white" {}
		_Color ("Color", Color) = (1.0, 1.0, 1.0, 1.0)
	}
	SubShader
	{
		Tags { "Queue" = "AlphaTest" "RenderType" = "Opaque" }

		Pass
		{
			Tags { "LightMode" = "ForwardBase" }

			Cull Back
			ZTest Always

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

			#define DIRECTIONAL_EPSILON 0.0009765625
			#define INITIAL_STEP_LENGTH 0.03125
			#define TERMINAL_EXTENSION (INITIAL_STEP_LENGTH * 2.0)
			#define STEP_COUNT 64
			#define EXTRA_DEPTH_BIAS 0.03125
			
			sampler3D _MainTex;
			fixed4 _Color;
			float3 _VoxelSize;
			float3 _BoundsSize;
			float4x4 _VolumeToLocal;
			float4x4 _LocalToVolume;
			sampler2D _CameraDepthTexture;
						
			float3 worldToObjectPos(float3 worldPos) {return mul(unity_WorldToObject, float4(worldPos, 1.0)).xyz;}
			float3 objectToWorldPos(float3 localPos) {return mul(unity_ObjectToWorld, float4(localPos, 1.0)).xyz;}
			float3 worldToObjectVec(float3 worldVec) {return mul((float3x3)unity_WorldToObject, worldVec);}
			float3 objectToWorldVec(float3 localVec) {return mul((float3x3)unity_ObjectToWorld, localVec);}
			float3 getWorldCameraPos() {return UNITY_MATRIX_I_V._14_24_34;}
			float3 getWorldCameraDir() {return -UNITY_MATRIX_V._31_32_33;}
			bool isPerspective() {return any(UNITY_MATRIX_P._41_42_43);}

			float3 getWorldCameraOrigin(float3 worldPos)
			{
				return isPerspective()
					? getWorldCameraPos()
					: worldPos + dot(getWorldCameraPos() - worldPos, getWorldCameraDir()) * getWorldCameraDir();
			}

			float3 getVolumeBoundsFaces(float3 volumePos, float3 volumeViewDir, float faceOffset)
			{
				float3 signs = sign(volumeViewDir);
				return -(signs * (volumePos - 0.5) + faceOffset) / (abs(volumeViewDir) + (1.0 - abs(signs)) * DIRECTIONAL_EPSILON);
			}

			float getVolumeBoundsFrontFace(float3 volumePos, float3 volumeViewDir)
			{
				float3 lengths = getVolumeBoundsFaces(volumePos, volumeViewDir, 0.5);
				return max(max(max(lengths.x, lengths.y), lengths.z), 0.0);
			}

			float sampleOpaqueZ(float4 screenPos)
			{
				float rawDepth = SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(screenPos));
				return isPerspective()
					? LinearEyeDepth(rawDepth)
					: -dot(unity_CameraInvProjection._33_34, float2(_ProjectionParams.x * (rawDepth * 2.0 - 1.0), 1.0));
			}

			// worldPosからworldViewDir方向を見た時の、ボリューム空間における衝突点を求める
			// wはヒットした場合1.0、ヒットしなかった場合-1.0となる
			float4 getVolumeContact(float3 worldPos, float3 worldViewDir, float4 screenPos)
			{
				float3 worldOrigin = getWorldCameraOrigin(worldPos);
				float3 localOrigin = worldToObjectPos(worldOrigin);
				float3 volumeOrigin = mul(_LocalToVolume, float4(localOrigin, 1.0)).xyz;
				float maxZ = min(dot(worldPos - worldOrigin, worldViewDir), sampleOpaqueZ(screenPos));
				float3 worldTerminal = worldOrigin + worldViewDir * maxZ;
				float3 localTerminal = worldToObjectPos(worldTerminal);
				float3 volumeTerminal = mul(_LocalToVolume, float4(localTerminal, 1.0)).xyz;
				float3 volumeViewDir = normalize(volumeTerminal - volumeOrigin);
				float3 volumeContact = volumeOrigin;
				float terminalDistance = distance(volumeOrigin, volumeTerminal) + TERMINAL_EXTENSION;
				float progress = getVolumeBoundsFrontFace(volumeOrigin, volumeViewDir);
				float step = INITIAL_STEP_LENGTH;
				float sign = 1.0;
				float hit = -1.0;
				[loop]
				for (int i = 0; i < STEP_COUNT; i++)
				{
					progress += step;
					if (progress > terminalDistance)
					{
						hit = -1.0;
						break;
					}
					volumeContact = volumeOrigin + volumeViewDir * progress;
					if ((tex3D(_MainTex, volumeContact).r - 0.5) * sign > 0.0)
					{
						hit = 1.0;
						sign *= -1.0;
						step *= -0.5;
					}
				}
				return float4(volumeContact, hit);
			}

			// ボリューム空間上の座標から、その周辺を観察してワールド法線を求める
			// 傾きを算出できなかった場合はゼロベクトルを返す
			float3 getWorldNormal(float3 volumePos)
			{
				float3 volumeNormal;
				volumeNormal.x = tex3D(_MainTex, volumePos - float3(_VoxelSize.x, 0.0, 0.0)).r - tex3D(_MainTex, volumePos + float3(_VoxelSize.x, 0.0, 0.0)).r;
				volumeNormal.y = tex3D(_MainTex, volumePos - float3(0.0, _VoxelSize.y, 0.0)).r - tex3D(_MainTex, volumePos + float3(0.0, _VoxelSize.y, 0.0)).r;
				volumeNormal.z = tex3D(_MainTex, volumePos - float3(0.0, 0.0, _VoxelSize.z)).r - tex3D(_MainTex, volumePos + float3(0.0, 0.0, _VoxelSize.z)).r;
				float3 localNormal = mul(volumeNormal, (float3x3)_LocalToVolume);
				float3 worldNormal = mul(localNormal, (float3x3)unity_WorldToObject);
				float normalSqrLength = dot(worldNormal, worldNormal);
				if (normalSqrLength > 0.0)
				{
					return worldNormal / sqrt(normalSqrLength);
				}
				return 0.0;
			}

			struct v2f
			{
				float4 vertex : SV_POSITION;
				float3 worldPos : TEXCOORD0;
				float3 worldViewDir : TEXCOORD1;
				float4 screenPos : TEXCOORD2;
			};

			v2f vert(float4 vertex : POSITION)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(vertex);
				o.worldPos = objectToWorldPos(vertex.xyz);
				o.worldViewDir = isPerspective() ? -UnityWorldSpaceViewDir(o.worldPos) : getWorldCameraDir();
				o.screenPos = ComputeScreenPos(o.vertex);
				return o;
			}

			half4 frag(v2f i) : SV_Target
			{
				float4 contact = getVolumeContact(i.worldPos, normalize(i.worldViewDir), i.screenPos);
				clip(contact.w);
				float3 worldNormal = getWorldNormal(contact.xyz);

				// ディレクショナルライト1個のランバートライティングで
				// 影も省略した簡易な（手抜きの）陰影付け
				half3 color = max(dot(_WorldSpaceLightPos0.xyz, worldNormal), 0.0) * _LightColor0 * _Color.rgb + ShadeSH9(half4(worldNormal, 1.0));
				return half4(color, 1.0);
			}
			ENDCG
		}
	}
}

モアイ像はスケールを調整して身長2mぐらいでシーン上に配置しました。
モアイ像にCarveeをアタッチし、これらシェーダーファイルをsliceShader、volumeShaderにセットしています。

なお、もう一つMoaiControllerというものがアタッチされていますが、これは下記のようにモアイ像をくるくる回すだけのもので、本題の削り取りとは関係ありません。

using UnityEngine;

public class MoaiController : MonoBehaviour
{
	[SerializeField][Range(0.0f, 90.0f)] private float angularSpeed = 90.0f;

	private void Update()
	{
		this.transform.Rotate(0.0f, this.angularSpeed * Time.deltaTime, 0.0f, Space.World);
	}
}

（パート3へ続く...）

Answer 3

モデルを細かいドットの集合体として扱うとおっしゃるのも候補として適切だと思います。ボクセル的なアプローチと言えるかもしれませんね。

その方針でどうなるか試してみました。実験材料として、まず削られる役は大英博物館によるモアイ像を...

削る役として自前でちょこっと作った謎の棍棒を用意しました。

モアイ像をインポートすると、ガワとなるゲームオブジェクトの中に「default」という名称のメッシュオブジェクトが入った構造のプレハブになるかと思います。このdefaultを取り出して「Moai」と名前を変え、下記スクリプトをアタッチしました。

using UnityEngine;
using UnityEngine.Rendering;

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class Carvee : MonoBehaviour
{
	[SerializeField] private Shader sliceShader; // ここにインスペクター上で断面描画用シェーダーをセットする
	[SerializeField] private Shader volumeShader; // ここにインスペクター上でボリューム描画用シェーダーをセットする
	[SerializeField][Min(0)] private int voxelsPerUnit = 128; // 1mあたりのボクセル数
	[SerializeField] private Color color = Color.white;

	private Bounds volumeBounds;
	private Material initialMaterial;
	private Material sliceMaterial;
	private Material volumeMaterial;
	private Matrix4x4 orthoMatrix;
	private Matrix4x4 sliceMatrix;
	private Mesh sourceMesh;
	private Mesh volumeMesh;
	private MeshFilter meshFilter;
	private MeshRenderer meshRenderer;
	private RenderTexture slice0;
	private RenderTexture slice1;
	private RenderTexture volume;
	private readonly Vector3[] carverBoundsVertices = new Vector3[8];
	private Vector3 initialScale;
	private Vector3 voxelSize;
	private Vector3Int textureSizeInt;

	public Vector3 Center => this.transform.TransformPoint(this.volumeBounds.center);

	private void Start()
	{
		// 本来のメッシュのバウンディングボックス、オブジェクトのスケール、
		// voxelsPerUnitをもとにボリュームのサイズを決める
		this.meshFilter = this.GetComponent<MeshFilter>();
		this.sourceMesh = this.meshFilter.sharedMesh;
		this.initialScale = this.transform.localScale;
		var sourceBounds = this.sourceMesh.bounds;
		var scaledSourceBounds = new Bounds(
			Vector3.Scale(sourceBounds.center, this.initialScale),
			Vector3.Scale(sourceBounds.size, this.initialScale));
		var textureSize = scaledSourceBounds.size * this.voxelsPerUnit;
		this.textureSizeInt = new Vector3Int(
			Mathf.CeilToInt(textureSize.x) + 2,
			Mathf.CeilToInt(textureSize.y) + 2,
			Mathf.CeilToInt(textureSize.z) + 2);
		textureSize = this.textureSizeInt;

		// 本来のメッシュを包むようにボリューム描画用メッシュを作る
		this.volumeBounds = new Bounds(scaledSourceBounds.center, textureSize / this.voxelsPerUnit);
		var vMin = this.volumeBounds.min;
		var vMax = this.volumeBounds.max;
		this.volumeMesh = new Mesh
		{
			name = this.sourceMesh.name + " Volume",
			vertices = new[]
			{
				vMin,
				new Vector3(vMax.x, vMin.y, vMin.z),
				new Vector3(vMin.x, vMax.y, vMin.z),
				new Vector3(vMax.x, vMax.y, vMin.z),
				new Vector3(vMin.x, vMin.y, vMax.z),
				new Vector3(vMax.x, vMin.y, vMax.z),
				new Vector3(vMin.x, vMax.y, vMax.z),
				vMax
			},
			triangles = new[]
			{
				0, 1, 2, 3, 2, 1,
				0, 2, 4, 6, 4, 2,
				0, 4, 1, 5, 1, 4,
				7, 5, 6, 4, 6, 5,
				7, 3, 5, 1, 5, 3,
				7, 6, 3, 2, 3, 6
			}
		};
		this.volumeMesh.RecalculateBounds();
		this.meshFilter.sharedMesh = this.volumeMesh;

		// 単純化のため、オブジェクト自体のスケールは1倍とした
		this.transform.localScale = Vector3.one;

		// ボリュームを作る
		this.volume = new RenderTexture(this.textureSizeInt.x, this.textureSizeInt.y, 0, RenderTextureFormat.R8)
		{
			dimension = TextureDimension.Tex3D,
			volumeDepth = this.textureSizeInt.z,
			useMipMap = false
		};
		this.volume.Create();

		// ボリュームにメッシュの断面を描く
		var activeTexture = RenderTexture.active;
		this.sliceMaterial = new Material(this.sliceShader);
		this.slice0 = new RenderTexture(this.textureSizeInt.x * 4, this.textureSizeInt.y * 4, 24, RenderTextureFormat.R8);
		this.slice1 = new RenderTexture(this.textureSizeInt.x * 2, this.textureSizeInt.y * 2, 0, RenderTextureFormat.R8);
		this.slice0.Create();
		this.slice1.Create();
		var volumeSize = this.volumeBounds.size;
		this.sliceMatrix = Matrix4x4.TRS(
			Vector3.zero,
			Quaternion.identity,
			new Vector3(
				this.initialScale.x / volumeSize.x,
				this.initialScale.y / volumeSize.y,
				this.initialScale.z / volumeSize.z)) * Matrix4x4.TRS(
			-sourceBounds.center,
			Quaternion.identity,
			Vector3.one);
		var modelMatrix = this.sliceMatrix;
		var translationZ = modelMatrix.m23;
		this.voxelSize = new Vector3(1.0f / textureSize.x, 1.0f / textureSize.y, 1.0f / textureSize.z);
		this.orthoMatrix = Matrix4x4.Ortho(-0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f);
		GL.PushMatrix();
		GL.LoadIdentity();
		GL.LoadProjectionMatrix(this.orthoMatrix);
		for (var i = 1; i < (this.textureSizeInt.z - 1); i++)
		{
			RenderTexture.active = this.slice0;
			modelMatrix.m23 = translationZ - ((i + 0.5f) * this.voxelSize.z);
			this.sliceMaterial.SetPass(0);
			GL.Clear(true, true, Color.clear);
			Graphics.DrawMeshNow(this.sourceMesh, modelMatrix);
			Graphics.Blit(this.slice0, this.slice1);
			Graphics.Blit(this.slice1, this.volume, 0, i);
		}
		GL.PopMatrix();
		RenderTexture.active = activeTexture;

		// sliceMatrixはゲーム実行中にCarveを行う際にも使用されるが、
		// Carvee自体のスケールは1倍に修正しているので、それに合わせて
		// 変更を加えておく
		this.sliceMatrix = Matrix4x4.TRS(
			Vector3.zero,
			Quaternion.identity,
			new Vector3(
				1.0f / volumeSize.x,
				1.0f / volumeSize.y,
				1.0f / volumeSize.z)) * Matrix4x4.TRS(
			-this.volumeBounds.center,
			Quaternion.identity,
			Vector3.one);

		// ボリューム描画用マテリアルを作り、レンダラーにセットする
		this.meshRenderer = this.GetComponent<MeshRenderer>();
		this.initialMaterial = this.meshRenderer.sharedMaterial;
		this.volumeMaterial = new Material(this.volumeShader);
		this.meshRenderer.sharedMaterial = this.volumeMaterial;
		var volumeToLocal = Matrix4x4.TRS(vMin, Quaternion.identity, volumeSize);
		var localToVolume = Matrix4x4.Inverse(volumeToLocal);
		this.volumeMaterial.mainTexture = this.volume;
		this.volumeMaterial.color = this.color;
		this.volumeMaterial.SetVector("_VoxelSize", this.voxelSize);
		this.volumeMaterial.SetVector("_BoundsSize", volumeSize);
		this.volumeMaterial.SetMatrix("_VolumeToLocal", volumeToLocal);
		this.volumeMaterial.SetMatrix("_LocalToVolume", localToVolume);
	}

	// 削り取りを行う時は、削りに使うメッシュとそれのTransformを引数にしてCarveを実行する
	public void Carve(Mesh carverMesh, Transform carverTransform)
	{
		// まず削りメッシュとボリュームの交差範囲を求めて、
		// 更新するテクスチャの範囲を決める
		var v = this.carverBoundsVertices;
		var carverLocalBounds = carverMesh.bounds;
		v[0] = carverLocalBounds.min;
		v[7] = carverLocalBounds.max;
		v[1] = new Vector3(v[7].x, v[0].y, v[0].z);
		v[2] = new Vector3(v[0].x, v[7].y, v[0].z);
		v[3] = new Vector3(v[7].x, v[7].y, v[0].z);
		v[4] = new Vector3(v[0].x, v[0].y, v[7].z);
		v[5] = new Vector3(v[7].x, v[0].y, v[7].z);
		v[6] = new Vector3(v[0].x, v[7].y, v[7].z);
		var min = new Vector3(Mathf.Infinity, Mathf.Infinity, Mathf.Infinity);
		var max = new Vector3(Mathf.NegativeInfinity, Mathf.NegativeInfinity, Mathf.NegativeInfinity);
		foreach (var carverLocalPosition in v)
		{
			var carveeLocalPosition =
				this.transform.InverseTransformPoint(carverTransform.TransformPoint(carverLocalPosition));
			min = Vector3.Min(min, carveeLocalPosition);
			max = Vector3.Max(max, carveeLocalPosition);
		}
		if (!this.volumeBounds.Intersects(new Bounds((min + max) * 0.5f, max - min)))
		{
			return;
		}
		var volumeMinZ = this.volumeBounds.min.z;
		var volumeMaxZ = this.volumeBounds.max.z;
		int GetIndex(float z, float minZ, float maxZ, int texSize) => Mathf.Clamp(
			Mathf.RoundToInt((Mathf.InverseLerp(minZ, maxZ, z) * texSize) - 0.5f),
			0,
			texSize - 1);
		var fromIndex = GetIndex(Mathf.Max(volumeMinZ, min.z), volumeMinZ, volumeMaxZ, this.textureSizeInt.z);
		var toIndex = GetIndex(Mathf.Min(volumeMaxZ, max.z), volumeMinZ, volumeMaxZ, this.textureSizeInt.z);

		// ボリュームをメッシュの形で削り取る
		var activeTexture = RenderTexture.active;
		var modelMatrix = this.sliceMatrix * this.transform.worldToLocalMatrix * carverTransform.localToWorldMatrix;
		var translationZ = modelMatrix.m23;
		GL.PushMatrix();
		GL.LoadIdentity();
		GL.LoadProjectionMatrix(this.orthoMatrix);
		for (var i = fromIndex; i <= toIndex; i++)
		{
			RenderTexture.active = this.slice0;
			modelMatrix.m23 = translationZ - ((i + 0.5f) * this.voxelSize.z);
			this.sliceMaterial.SetPass(0);
			GL.Clear(true, true, Color.clear);
			Graphics.DrawMeshNow(carverMesh, modelMatrix);
			Graphics.Blit(this.slice0, this.slice1);
			Graphics.Blit(this.slice0, this.volume, this.sliceMaterial, 1, i);
		}
		GL.PopMatrix();
		RenderTexture.active = activeTexture;
	}

	private void OnDestroy()
	{
		this.meshRenderer.sharedMaterial = this.initialMaterial;
		this.meshFilter.sharedMesh = this.sourceMesh;
		this.transform.localScale = this.initialScale;
		Destroy(this.sliceMaterial);
		Destroy(this.volumeMaterial);
		Destroy(this.volumeMesh);
		Destroy(this.volume);
		Destroy(this.slice0);
		Destroy(this.slice1);
	}
}

（パート2へ続く...）

Comments

[T_T2]

素晴らしいです！やりたいことができていて感動しました。
早速実行してみたのですが、どうもプレイモードにするとUnityが強制終了してしまします。
色々と落ちる原因を探ってみますと、「Carvee」によるボリュームテクスチャ生成時の実行が原因のようです。この解決策はありますでしょうか。

[T_T2]

追記です！
単純な立方体で実行してみたところ、正常に動きました！PCの限界が来ていたのかもしれません...
今後は、形作ったデータの保存や表面のガタガタへの対策をしていこうかと思います。
この技術力は凄まじいですね...今後もつまずいたらご相談させていただきたいと思います！
本当にありがとうございました。

[T_T2]

D3D11: Failed to create render texture resource (3D, 1164x2821x1392 mips=1 dxfmt=60, hr=0x0)

任意のオブジェクトを実行しようとすると、上記のエラーメッセージが表示されていまいます。
サイズが小さすぎるのでしょうか？

[Bongo]

生成されるテクスチャのサイズが大きすぎるようですね。メッセージに1164x2821x1392と表示されているようですが、普通の2Dのテクスチャにたとえれば1164x2821のテクスチャを1392枚確保することに相当するはずです。ヤバさをご想像いただけますでしょうか...

オブジェクトのサイズをもっと小さくしたり、voxelsPerUnitをもっと小さくしたりしてボリュームのサイズを抑えないとならないでしょう。
回答中でも申し上げましたが、精密にするには解像度を上げたいけれど、3Dテクスチャは簡単にサイズが膨れ上がってハードウェアの限界に達しやすいのが最大の弱点ですね...

[fana]

用いている実装手段を全く知らない者が適当ほざきますが，
Octree的な構造でボクセルデータを軽くできたり…みたいな可能性はないのでしょうか？

[Bongo]

いえ、貴重なご意見ありがとうございました。可能性としてはあり得るかと思います。追記依頼欄でちょっと言及しましたVoxel Generatorの紹介ムービーでは、掘っている部分の周辺だけ局所的に分割数を上げているようなシーンがあり（https://youtu.be/_Hc3H5EhoTI?t=72 ）、ボリュームの全体の大きさとボクセルの精密さを両立させるには、ああいった工夫が必要なのかもしれません。
今回はボリューム全体を一塊の3Dテクスチャにする方針にしてしまいましたので、ボクセルの密度は全領域で一定になってしまいました。八分木的なデータ構造にするとなると、だいぶ改修を加えないとならなそうです...

[追記]
Sparse Voxel Octree（https://ja.wikipedia.org/wiki/Sparse_Voxel_Octree ）みたいな分野の文献が手がかりになるかもしれませんね。面白そうではありますが、あいにくこういった技術は未経験で、仮にやってみるにしてもじっくり下調べが必要そうです。

[T_T2]

貴重なご意見ありがとうございます！
Sparse Voxel Octreeに関する論文を読みましたが、理論理屈など言いたいことはわかるのですが、実装させるとなると厳しいですね...
これは新たな質問になると思いますので、新たなQuestionとして投稿させて頂きたいと思います。

[fana]

> Sparse Voxel Octree

私が Octree的な構造でどうの とか言った際のイメージは，まさにこれです．
（ボクセルのデータサイズ削減　と　当たり判定処理の枝刈り　の両方に利用できそうに思うけど，実装しろと言われると激しくつらそう）