[Unity]深度バッファを使って表面のみに投影テクスチャマッピング

深度バッファを使うというのは的確なアイディアだと思います。確かに状況がシャドウマッピングとよく似ていますね。

おそらく、うまくいかなかった原因はデプステクスチャのサンプリング位置の狂いのような気がします。それを含め、いくつか変更を加えてみました。まずC#スクリプト側は...

• デプステクスチャの解像度としてprojCam.pixelWidthとprojCam.pixelHeightを使うと、サイズは画面解像度と同じになるかと思います。
  それはそれでいいとも思いますが、個人的には画面サイズによってエッジの精密さが変わってしまうのが気になり、さしあたりbrushTex.widthとbrushTex.heightを使ってブラシテクスチャと同サイズにしました。これでは荒すぎるようでしたら、brushTex.width * 4といった風に何倍かしてやるのもいいでしょう。
• projCamのenabledをSetProjCam内でfalseに変更して自動的レンダリングはさせないようにし、代わりにベイク用コマンドバッファ実行部分の手前で明示的にレンダリングさせるようにしました。順序的にはこちらの方が自然じゃないでしょうかね?
  当初のコードですと、レンダリングされたデプスがベイク結果に反映されるのは次回ベイク時...つまり次のフレームになると思われます。
• projCamの描画に綺麗なシェーディングを施す必要はないので、projCam.renderingPathをRenderingPath.VertexLitに差し替えました。スカイボックスもいらないでしょうから切っています。

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;

            // カメラコンポーネントを非アクティブ化して自動レンダリングをさせなくする
            // また、projCam上でレンダリングする際のパスをVertexLitに差し替える
            // スカイボックスも描画不要
            projCam.enabled = false;
            projCam.renderingPath = RenderingPath.VertexLit;
            projCam.clearFlags = CameraClearFlags.Depth;
        }
    }

    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;

                // デプステクスチャのサイズをブラシテクスチャと同サイズに変更
                var depthBufferWidth = brushTex.width;
                var depthBufferHeight = brushTex.height;
                colorBufferRT = new RenderTexture(depthBufferWidth, depthBufferHeight, 0, RenderTextureFormat.ARGB32);
                colorBufferRT.Create();
                depthBufferRT = new RenderTexture(depthBufferWidth, depthBufferHeight, 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()
    {
        // このタイミングでprojCamを手動描画
        projCam.Render();

        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();
        }
    }
}

次に、シェーダー側は...

• depthVertexは廃止しました。ブラシテクスチャとデプステクスチャはともに同じUV座標をサンプリングするべきだと思いますので、ともにprojUVを使用することにしました。
• フラグメントの前後判定の際に、環境によるクリップ空間の違いを考慮するようにしてみました。おそらくこれでいけるかとは思うのですが、もし前後判定の狂いがあるようでしたら、どのような描画結果になってしまったか、グラフィックスシステムは何を使っているかコメントいただければ、可能であれば直してみようと思います。
  ご提示いただいた渋谷ほととぎす通信さんの製作例の途中に、デプステクスチャの内容を画面上に表示してみせている画像がありますが、そこではカメラに近い部分ほど色が暗くなっています。一方、【Unity】【シェーダ】カメラから見た深度を描画する - LIGHT11にもデプスの可視化を試みている例がありますが、こちらは逆に近い部分が明るくなっています。プラットフォーム特有のレンダリングの違い - Unity マニュアルの「クリップスペース座標」や「シェーダーの深度 (Z) の向き」をご覧いただくと、ごちゃごちゃぶりを察していただけるでしょうか...

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;
            };

            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);

                // 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
            {
                // 環境に応じて奥行き値を加工する際に使う
                #ifdef UNITY_REVERSED_Z
                float inverseZ = 1.0;
                #else
                float inverseZ = 0.0;
                #endif

                fixed4 projColor = fixed4(0, 0, 0, 0);
                float depth = 1.0 - inverseZ;

                if (i.projUV.w > 0.0)
                {
                    // projection to screen space
                    i.projUV /= i.projUV.w;

                    if (i.projUV.x >= 0 && i.projUV.x <= 1 && i.projUV.y >= 0 && i.projUV.y <= 1)
                    {
                        // _BrushTexも_DepthTexも同じ位置をサンプリングする
                        projColor = tex2D(_BrushTex, i.projUV);
                        depth = tex2D(_DepthTex, i.projUV).r;
                    }
                }

                // まずブラシ視点からのクリップ座標z(w除算済み)とdepthを、奥が1・手前が0となるよう加工する
                float near = UNITY_NEAR_CLIP_VALUE;
                float far = 1.0 - inverseZ;
                float normalizedZ = (i.projUV.z - near) / (far - near);
                float normalizedDepth = inverseZ + (1.0 - 2.0 * inverseZ) * depth;

                // 両者を比較して前後を判断する
                // 判定に落ちたフラグメントはclipで破棄する
                // また、Zファイティング現象防止のため、判定値は少しだけ増やしてやる
                clip(normalizedDepth - normalizedZ + 0.001);

                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
        }
    }
}