Dirctional LightのBias値はどのように内部で格納されますか

Question

知りたいこと

unityのシェーダーを勉強中のものです．
シャドウアクネを解消するために，ShadowCastのパスの際に3Dモデルをオフセットする処理があると思います．Directional LightのBiasやNormal Biasです．
Directional LightのInspectorにBiasやNormalBiasを入力する箇所がありますが，それらが何という変数に格納されるかを知りたいです．

###今わかっていること

unity_LightShadowBiasという変数に，BiasやNormalBiasに関係した値が入っていることまでは分かりましたが，その値はBias，NormalBiasそのものではありませんでした．
以下のコードはBias及びNormalBiasの処理のマクロを書き下したものです．

例えば，DirctionalLightのNormalBiasを1にしたときと，以下コードのunity_LightShadowBias.zを1で置換してレンダリングされたときでは，影のつき方が変わりました．なので，NormalBiasの値を何かしら処理された後の値がunity_LightShadowBias.zに格納されていると思います．

unity_LightShadowBiasにはどのような値が入っているかということも知りたいです．

struct v2f_forShadowCast{	//ShadowCastパスの頂点シェーダー出力型
    float4 pos : SV_POSITION;
};


v2f_forShadowCast vs_forShadowCast(appdata v)    //ShadowCast用頂点シェーダー
{
	v2f_shadow o;

	float4 worldPos = mul(unity_ObjectToWorld, v.pos);
	half3 worldNormal = UnityObjectToWorldNormal(v.normal);

	half3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos.xyz));
	half NdotL = dot(worldNormal, lightDir);
	half Sine = sqrt(1 - NdotL * NdotL);

	o.pos.xyz = worldPos.xyz - worldNormal * _NormalBias * unity_LightShadowBias.z * Sine;

	o.pos.w = worldPos.w;
	o.pos = UnityWorldToClipPos(o.pos);

	#if defined(UNITY_REVERSED_Z)
		o.pos.z += max(-1, min(unity_LightShadowBias.x / o.pos.w, 0));
		float clamped = min(o.pos.z, o.pos.w * UNITY_NEAR_CLIP_VALUE);
	#else
		o.pos.z += saturate(unity_LightShadowBias.x / o.pos.w);
		float clamped = max(o.pos.z, o.pos.w * UNITY_NEAR_CLIP_VALUE);
	#endif
		o.pos.z = lerp(o.pos.z, clamped, unity_LightShadowBias.y);

	return o;
}

Answer 1

おっしゃるとおりunity_LightShadowBiasが一体何なのか検索してみても、明確な情報はひっかかりませんね...
かろうじてヒントになりそうなのはUnityCG.cgincに記述されている...

float4 UnityClipSpaceShadowCasterPos(float4 vertex, float3 normal)
{
    float4 wPos = mul(unity_ObjectToWorld, vertex);

    if (unity_LightShadowBias.z != 0.0)
    {
        float3 wNormal = UnityObjectToWorldNormal(normal);
        float3 wLight = normalize(UnityWorldSpaceLightDir(wPos.xyz));

        // apply normal offset bias (inset position along the normal)
        // bias needs to be scaled by sine between normal and light direction
        // (http://the-witness.net/news/2013/09/shadow-mapping-summary-part-1/)
        //
        // unity_LightShadowBias.z contains user-specified normal offset amount
        // scaled by world space texel size.

        float shadowCos = dot(wNormal, wLight);
        float shadowSine = sqrt(1-shadowCos*shadowCos);
        float normalBias = unity_LightShadowBias.z * shadowSine;

        wPos.xyz -= wNormal * normalBias;
    }

    return mul(UNITY_MATRIX_VP, wPos);
}

のコメントぐらいでしょうか。ですがそれもzについてだけであり、xやyについては言及されていないようです。

多少なりともご参考になれば...と思いまして、「マテリアルのインスペクター上でBiasとNormal Biasを独自に設定して影を描く」というのを目標にフレームデバッガーで変数の値を観察しつつ試行錯誤して、下記のような計算式をひねり出してみました。

Shader "Unlit/CustomShadowBias"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _ShadowIntensity ("Shadow Intensity", Range(0.0, 1.0)) = 0.5
        [Toggle(CUSTOM_BIAS_ENABLED)] _UseCustomBias ("Use Custom Bias", Float) = 0
        _ShadowMapResolution ("Shadow Map Resolution", Int) = 1024
        _Bias ("Bias", Range(0.0, 2.0)) = 0.05
        _NormalBias ("Normal Bias", Range(0.0, 3.0)) = 0.4
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase" }
        
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdbase

            #include "UnityCG.cginc"
            #include "AutoLight.cginc"

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                SHADOW_COORDS(1)
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float _ShadowIntensity;

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

            fixed4 frag(v2f i) : SV_Target
            {
                fixed4 color = tex2D(_MainTex, i.uv);
                color.rgb *= lerp(1.0, SHADOW_ATTENUATION(i), _ShadowIntensity);
                return color;
            }
            ENDCG
        }

        Pass
        {
            Tags { "LightMode"="ShadowCaster" }

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_shadowcaster
            #pragma multi_compile _ CUSTOM_BIAS_ENABLED
            #include "UnityCG.cginc"

            struct v2f { 
                V2F_SHADOW_CASTER;
            };

            int _ShadowMapResolution;
            float _Bias;
            float _NormalBias;

            float3 shadowBias()
            {
                float3 bias = unity_LightShadowBias.xyz;
                
                #ifdef CUSTOM_BIAS_ENABLED
                    // yはDirectionalなら1、それ以外なら0になる?
                    float isDirectional = bias.y;

                    // xはBiasに比例して変化しているように見える
                    // Directionalの場合はBiasにクリップ空間の奥行きスケールを乗じたもの?
                    // Directional以外だと、xの絶対値はBiasがそのまま入ってくるように見える
                    // 符号はPointだと1、それ以外だと-1?
                    #ifdef SHADOWS_CUBE
                        float biasXSign = 1.0;
                    #else
                        float biasXSign = -1.0;
                    #endif
                    bias.x = lerp(1.0, UNITY_MATRIX_P._33, isDirectional) * biasXSign * _Bias;

                    // zはNormal Biasに比例して変化しているように見える
                    // Directionalの場合はNormal Biasを2倍し、クリップ空間の水平スケール×ビューポートサイズで割ったもの?
                    // Directional以外だと常に0?
                    // ビューポートサイズがやっかいで、おそらく https://docs.unity3d.com/Manual/shadow-mapping.html で
                    // 説明されているShadow map resolutionと同一だと思うが、それをシェーダー上で取得する方法がわからない...
                    // さしあたり_ShadowMapResolutionとしてインスペクター上で与えるようにしたが、これだとシャドウマップの
                    // 実際の解像度に応じて自動的に設定することができず、いまいち便利でない
                    // スクリプト上で計算してシェーダーに与えてやることになるのだろうか?
                    bias.z = lerp(0.0, 2.0 / (UNITY_MATRIX_P._11 * _ShadowMapResolution), isDirectional) * _NormalBias;

                    // ShadowCasterパスはカメラ視点でのデプスレンダリング(UpdateDepthTexture)と
                    // ライト視点でのシャドウマップレンダリング(Shadows.RenderShadowMap)の両方で使われるが
                    // どうやらUpdateDepthTextureではunity_LightShadowBiasは(0, 0, 0, 0)となり
                    // バイアスがかからないようになっているらしい?
                    // UpdateDepthTextureでバイアスをかけてしまうと、カメラ視点でのデプスが狂い
                    // スクリーンスペースでの影レンダリング(Shadows.CollectShadows)時に異常な影を
                    // 生じてしまいそうだった
                    // UpdateDepthTextureとShadows.RenderShadowMapのどちらであるかをシェーダー上で
                    // 区別する方法がわからず、しかたないのでunity_LightShadowBiasがゼロベクトルなら
                    // biasも全成分ゼロにすることにした
                    bias = lerp(0.0, bias, sign(dot(unity_LightShadowBias, unity_LightShadowBias)));
                #endif

                return bias;
            }

            // Normal Biasの適用
            float4 clipSpaceShadowCasterPos(float4 vertex, float3 normal, float3 bias)
            {
                float4 wPos = mul(unity_ObjectToWorld, vertex);

                if (bias.z != 0.0)
                {
                    float3 wNormal = UnityObjectToWorldNormal(normal);
                    float3 wLight = normalize(UnityWorldSpaceLightDir(wPos.xyz));
                    float shadowCos = dot(wNormal, wLight);
                    float shadowSine = sqrt(1 - shadowCos * shadowCos);
                    float normalBias = bias.z * shadowSine;

                    wPos.xyz -= wNormal * normalBias;
                }

                return mul(UNITY_MATRIX_VP, wPos);
            }

            // Biasの適用
            float4 applyLinearShadowBias(float4 clipPos, float3 bias)
            {
                #if !(defined(SHADOWS_CUBE) && defined(SHADOWS_CUBE_IN_DEPTH_TEX))
                    #if defined(UNITY_REVERSED_Z)
                        clipPos.z += max(-1, min(bias.x / clipPos.w, 0));
                    #else
                        clipPos.z += saturate(bias.x / clipPos.w);
                    #endif
                #endif

                #if defined(UNITY_REVERSED_Z)
                    float clamped = min(clipPos.z, clipPos.w * UNITY_NEAR_CLIP_VALUE);
                #else
                    float clamped = max(clipPos.z, clipPos.w * UNITY_NEAR_CLIP_VALUE);
                #endif

                clipPos.z = lerp(clipPos.z, clamped, bias.y);
                
                return clipPos;
            }

            v2f vert(appdata_base v)
            {
                v2f o;
                float3 bias = shadowBias();
                
                #if defined(SHADOWS_CUBE) && !defined(SHADOWS_CUBE_IN_DEPTH_TEX)
                    o.vec = mul(unity_ObjectToWorld, v.vertex).xyz - _LightPositionRange.xyz;
                    o.pos = UnityObjectToClipPos(v.vertex);
                #else
                    o.pos = clipSpaceShadowCasterPos(v.vertex, v.normal, bias);
                    o.pos = applyLinearShadowBias(o.pos, bias);
                #endif

                return o;
            }

            float4 frag(v2f i) : SV_Target
            {
                float3 bias = shadowBias();

                #if defined(SHADOWS_CUBE) && !defined(SHADOWS_CUBE_IN_DEPTH_TEX)
                    return UnityEncodeCubeShadowDepth((length(i.vec) + bias.x) * _LightPositionRange.w);
                #else
                    return 0;
                #endif
            }
            ENDCG
        }
    }
}

ですが、シャドウマップの解像度をインスペクターで指定してやらなければならず不便で、計算式もあれでいいのか自信がありません。信頼できる情報筋...できればUnity Technologiesの方からの意見をいただきたいところではあります。
「What's in unity_LightShadowBias? - Unity Answers」で類似した質問が出ているようですが（もしかしてご質問者さんご本人でしょうかね?）、あちらならUnityの開発者さんの目にとまりやすいかもしれません。時折チェックして新情報が投稿されていないかご確認いただくといいかと思います。

Comments

[RY__]

何とご丁寧に，ありがとうございます！
実験的に値を確かめていただいたようで，非常に感謝します．
プロジェクション行列などでスケーリングされているような感じなんですね．
まだじっくり意味を見て読むところまでできていないので，また質問をさせていただくかもしれません．

少し話がそれますが，フレームデバッガーを使ってシェーダーが持つ変数の値を見れるのですね．
フレームデバッガ―はシャドウマップのレンダリング確認くらいでしか使用したことがなく，そのような使い方ができることを初めて知り感動しました．
シェーダーのデバッグ(特に変数の値のデバッグ)が今までできなくて，かなり苦労したので非常にありがたい知見になりました．

最後におっしゃっていただいた，Unityの掲示板での質問はご推測通り私が投稿したものです．(笑)
まだご回答が得られず，こちらで質問させていただいた次第です．

改めましてじっくり調査していただいて誠に感謝いたします．
また質問をさせていただくかもしれませんが，非常に助かりました．