常連

### やりたいこと
3Dモデルのテクスチャに直接書き込むようなペイントアプリを作成したいと思っています。方法としては、メインカメラの他にカメラを用意しそこからレイをとばしヒットした場所に投影テクスチャマッピングしてレンダーテクスチャに直接書き込もうと考えています。（毎フレームテクスチャでスタンプしていくようなイメージです。）
投影テクスチャマッピングしたものをそのモデルのテクスチャに反映する部分で苦戦していたのですが、ありがたいことにその問題はここで質問し、解決することができました。
[[Unity]Graphics.Blitで投影テクスチャマッピングシェーダーをテクスチャに反映できない](https://teratail.com/questions/178300)

### 問題点
しかし次の問題として、投影テクスチャマッピングの仕様上カメラから見えない場所（モデルの凹凸に隠れる場所や、裏側など）にも投影されてしまうことに気づきました。以下のようなものです。
![イメージ説明](c64f50c43ad7e580407e9b9e6929d091.png)
![イメージ説明](8d4f0b43b98d9e79dbc716ae36765c14.png)
Gameビューをマウスでクリックし、そこからレイをとばしてヒットポイントに塗っているのですが、ご覧の通り塗られるべきでない場所にも塗られてしまっているので、解決したいです。

### 試したこと
いろいろと調べてみた結果、深度バッファを使えば解決できそうだということがわかりました。カメラからピクセルまでの距離と深度情報を比べて深度のほうが小さければ塗らない、といった具合です。そして幸運にも似たようなことをやっている人を発見しました。
[Unity デプスシャドウ技法を自前で書いて影を落としてみる](https://www.shibuya24.info/entry/shadowmap)
しかし、これを真似て実装してみたのですがうまくいきませんでした。

### スクリプトと再現方法
前回の質問したときのスクリプトを、解決法にそって改善し、自分なりに上のことを実現しようとしたスクリプトです。前回と同様、塗られるモデルにこのスクリプトをアタッチし、各種パラメータを設定します。projectorには空のゲームオブジェクトにCameraコンポーネントを付けたものを入れます。Cameraの設定はOcclusion Culling, Allow HDR, Allow MSAAをオフにしてます。（orthoSizeなどはスクリプトから調節するようにしてます。）
前回と違い、今回は深度情報を使いたかったので疑似ではなくCameraコンポーネントを使用しています。またモデルには他の適当なマテリアル（スタンダードシェーダなど）を使用しています。Bakeファンクションで実際の塗りが発生しますが、これはテスト用のスクリプトなので毎フレーム塗っています。

先のデプスシャドウの実装では、予めRenderTextureをつくりCameraのTargetTextureにつけているようですが、この方法は自分ではなぜかうまく深度値がとれなかったのでスクリプトで動的にバッファを作成しカメラをDepthモードに切り替えています。

おそらくカメラからピクセルまでの距離か深度情報どちらかの値が間違っていると思うのですが、もしかしたら深度がうまくとれていないのかもしれません...
深度を扱うのは今回がはじめてで試行錯誤しながらやっていて、よくある例のようにポストエフェクトでメインカメラからの深度を直接画面に反映する方法で深度テクスチャの方法はうまくいっていました。しかし今回のようにシーンにカメラを二つ使用し、サブカメラのほうで深度をとろうとするとうまくいかなかったです。そもそも深度テクスチャはほぼ真っ黒なので、Inspectorだけではうまく深度とれてるか確認できず、デバッグのために深度テクスチャをGraphics.Blitで他のシェーダ（rの値が0と1意外の値のとき色をはっきりさせるもの）を使ってコピーし、uGUIで画面に表示してみたのですが、うまく深度テクスチャがコピーできなかったです...


```C#
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;

public class DepthProjection : MonoBehaviour
{
    [SerializeField] Color brushColor;
    [SerializeField] Texture brushTex;
    [SerializeField] GameObject projector;
    [SerializeField] float zNear = 0.01f, zFar = 1, orthoSize = 0.5f;
    [SerializeField] Material paintMat;

    Material objMat;
    Renderer renderer;
    RenderTexture modelMainRT, colorBufferRT, depthBufferRT;
    public RenderTexture depthTex
    {
        get
        {
            return depthBufferRT;
        }
    }

    int ProjectorVPMat, brushColorId, projTexId, depthTexId;
    CommandBuffer bakeCommand;
    Camera projCam;

    private void OnValidate()
    {
        SetProjCam();
    }

    void SetProjCam()
    {
        if (projCam)
        {
            projCam.orthographic = true;
            projCam.orthographicSize = orthoSize;
            projCam.nearClipPlane = zNear;
            projCam.farClipPlane = zFar;
            projCam.aspect = 1;
        }
    }

    private void Awake()
    {
        renderer = GetComponent<Renderer>();
        objMat = renderer?.material;
        ProjectorVPMat = Shader.PropertyToID("ProjectorVPMat");
        brushColorId = Shader.PropertyToID("_BrushColor");
        projTexId = Shader.PropertyToID("_BrushTex");
        depthTexId = Shader.PropertyToID("_DepthTex");

        projCam = projector?.GetComponent<Camera>();

        if (projCam == null)
        {
            Debug.LogAssertion("projector needs Camera Component");
        }

        SetProjCam();

        InitProjectorAndDepthTexture();
        InitCommand();

    }

    void InitProjectorAndDepthTexture()
    {
        if (objMat)
        {
            var mainTex = objMat.mainTexture;

            if (mainTex && projCam)
            {
                modelMainRT = new RenderTexture(mainTex.width, mainTex.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default);

                projCam.depthTextureMode = DepthTextureMode.Depth;

                colorBufferRT = new RenderTexture(projCam.pixelWidth, projCam.pixelHeight, 0, RenderTextureFormat.ARGB32);
                colorBufferRT.Create();
                depthBufferRT = new RenderTexture(projCam.pixelWidth, projCam.pixelHeight, 24, RenderTextureFormat.Depth);
                depthBufferRT.Create();

                projCam.SetTargetBuffers(colorBufferRT.colorBuffer, depthBufferRT.depthBuffer);

                Graphics.Blit(mainTex, modelMainRT);
                objMat.mainTexture = modelMainRT;

                if (paintMat)
                {
                    paintMat.mainTexture = modelMainRT;
                    paintMat.SetTexture(depthTexId, depthBufferRT);
                }
            }
        }
    }

    void InitCommand()
    {
        if (renderer & modelMainRT & paintMat)
        {

            var c = new CommandBuffer();
            c.name = "Bake Projection Command";

            var RTBufferId = Shader.PropertyToID("_RTBuffer");

            c.GetTemporaryRT(RTBufferId, modelMainRT.descriptor);
            c.Blit(modelMainRT, RTBufferId);
            c.SetRenderTarget(RTBufferId);
            c.DrawRenderer(renderer, paintMat);
            c.Blit(RTBufferId, modelMainRT);
            c.ReleaseTemporaryRT(RTBufferId);

            bakeCommand = c;
        }
    }

    void SetMatProperties()
    {
        if (projector && paintMat && projCam != null)
        {
            Matrix4x4 projMat = GL.GetGPUProjectionMatrix(projCam.projectionMatrix, true);
            Matrix4x4 viewMat = projCam.worldToCameraMatrix;

            Matrix4x4 vpMat = projMat * viewMat;

            paintMat.SetMatrix(ProjectorVPMat, vpMat);
            paintMat.SetColor(brushColorId, brushColor);
            paintMat.SetTexture(projTexId, brushTex);
        }
    }

    // Update is called once per frame
    void Update()
    {
        SetMatProperties();
        Bake();
    }

    public void Bake()
    {
        if (bakeCommand != null)
        {
            Graphics.ExecuteCommandBuffer(bakeCommand);
        }
    }

    private void OnDestroy()
    {
        ReleaseAllRT();
    }

    void ReleaseAllRT()
    {
        ReleaseRT(modelMainRT);
        ReleaseRT(colorBufferRT);
        ReleaseRT(depthBufferRT);
    }

    void ReleaseRT(RenderTexture rt)
    {
        if (rt)
        {
            rt.Release();
        }
    }
}

```

深度を利用した投影テクスチャマッピングのシェーダーコードです。

```ここに言語を入力
Shader "Painter/Test/DepthProjectionTest"
{
	Properties
	{
		_MainTex("Main Texture", 2D) = "white" { }
		_BrushColor("Brush Color", Color) = (1, 1, 1, 1)
		_BrushTex("Projection Texture", 2D) = "white" { }
		_DepthTex("Depth Texture", 2D) = "white" { }
	}

		SubShader
	{
		Tags { "RenderType" = "Opaque" }
		LOD 100

		Pass
		{
		// 裏を向いた面に対応するためカリングを切る
		Cull Off

		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;
			float4 projUV: TEXCOORD1;
			float4 depthVertex : TEXCOORD2;
		};

		sampler2D _MainTex;
		sampler2D _BrushTex;
		sampler2D _DepthTex;
		float4 _MainTex_ST;
		float4 _BrushColor;

		uniform float4x4 ProjectorVPMat;

		v2f vert(appdata v)
		{
			v2f o;

			// ベイク時はメッシュのUV座標を頂点の位置と見なして描画させる
			float2 position = v.uv * 2.0 - 1.0;
			#if UNITY_UV_STARTS_AT_TOP
			// DirectX系の場合は上下を逆転させる
			position.y *= -1.0;
			#endif
			o.vertex = float4(position, 0.0, 1.0);
		
			o.depthVertex = ComputeGrabScreenPos(mul(ProjectorVPMat, v.vertex));

			// SkinnedMeshRendererに対応するため、モデル行列はUnity組み込みのものを用いる
			float4x4 mvpMat = mul(ProjectorVPMat, unity_ObjectToWorld);
			o.projUV = ComputeGrabScreenPos(mul(mvpMat, v.vertex));
			o.uv = TRANSFORM_TEX(v.uv, _MainTex);
			return o;
		}

		fixed4 frag(v2f i) : SV_Target
		{
			fixed4 projColor = fixed4(0, 0, 0, 0);
			// depth textureから深度値をサンプリング。線形になるようLinear01Depthを使ったほうがいい？
			fixed4 depthColor = tex2D(_DepthTex, i.depthVertex.xy);
			float diff = i.depthVertex.z - depthColor.r;

			if (diff <= 0 && i.projUV.w > 0.0)
			{
				// projection to screen space
				i.projUV.x /= i.projUV.w;
				i.projUV.y /= i.projUV.w;

				if (i.projUV.x >= 0 && i.projUV.x <= 1 && i.projUV.y >= 0 && i.projUV.y <= 1)
				{
					projColor = tex2D(_BrushTex, i.projUV);
				}
			}

			fixed4 mainColor = tex2D(_MainTex, i.uv);

			// if _BrushColor.a = 0 or projColor.a = 0, then mainColor. if both 1, then _BrushColor.
			return mainColor * (1 - _BrushColor.a * projColor.a) + _BrushColor * _BrushColor.a * projColor.a;
		}
		ENDCG
	}
	}
}

```

### 他
思いついた方法が新しくカメラを用意し深度テクスチャを使う、というものだったのですが、もし他に良い方法があれば教えてほしいです。できれば二度レンダリングしたくないので...

### 環境
Unity 2018.3.9f1で作成したプロジェクトです。（レンダリング設定はforwardだと思います。）
プラットフォームはデフォルトのものです。

よろしくお願いいたします。

	@@ -1,1 +1,1 @@
1	- [Unity]深度バッファを使って表面のみに投影テクスチャマッピング~~がしたい~~
1	+ [Unity]深度バッファを使って表面のみに投影テクスチャマッピング

質問編集履歴