Unity: UNITY_REVERSED_Z разрешен при normal depth

//
// GroundFog 1.0
//
// Panteleymonov Aleksandr 2017
//
// 
// 
//

Shader "FX/GroundFog"
{
  Properties
  {
    _FogColor("Color", Color) = (0.5,0.5,0.5,1.0)
    _Emmission("Emmission", Color) = (0.5,0.5,0.5,1.0)
    _String("String",Range(0.01,5)) = 0.25
    _FogMask ("Fog Mask", 2D) = "white" {}
    _FogNoise("Fog", 2D) = "white" {}
    _Normal("Normal Surface", Vector) = (0,-1,0,0)
    _Depth("Depth", Range(0.1,100)) = 5
    _ScaleTexture ("Texture Scale", Range(0.1,100)) = 1
    _TimeSpeed("Time Speed", Range(0.1,100)) = 2.0
  }
  SubShader
  {
    Tags{ "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
    LOD 100

    Pass
    {
      Blend One OneMinusSrcAlpha

      CGPROGRAM
      #pragma vertex vert
      #pragma fragment frag
      // make fog work
      #pragma multi_compile_fog
      
      #include "UnityCG.cginc"

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

      struct v2f
      {
        float4 pos : SV_POSITION;
        //float2 uv : TEXCOORD0;
        float4 screen : TEXCOORD0;
        float3 ray : TEXCOORD1;
      };

      uniform sampler2D _CameraDepthTexture;
      sampler2D _FogMask;
      sampler2D _FogNoise;
      //float4 _FogMask_ST;
      float4 _FogColor;
      float4 _Emmission;
      float _ScaleTexture;
      float4 _Normal;
      float _String;
      float _Depth;
      float _TimeSpeed;
      
      v2f vert (appdata v)
      {
        float fragTime = _Time.x*10.0;
        v2f o;
        float4 vec = v.vertex;
        o.pos = mul(UNITY_MATRIX_MVP, vec);
        o.screen = ComputeScreenPos(o.pos);
        o.ray = mul(transpose((float3x3)UNITY_MATRIX_V),mul(UNITY_MATRIX_MV, vec).xyz);
        return o;
      }
      
      float4x4 inverse(float4x4 input)
      {
#define minor(a,b,c) determinant(float3x3(input.a, input.b, input.c))
        //determinant(float3x3(input._22_23_23, input._32_33_34, input._42_43_44))

        float4x4 cofactors = float4x4(
          minor(_22_23_24, _32_33_34, _42_43_44),
          -minor(_21_23_24, _31_33_34, _41_43_44),
          minor(_21_22_24, _31_32_34, _41_42_44),
          -minor(_21_22_23, _31_32_33, _41_42_43),

          -minor(_12_13_14, _32_33_34, _42_43_44),
          minor(_11_13_14, _31_33_34, _41_43_44),
          -minor(_11_12_14, _31_32_34, _41_42_44),
          minor(_11_12_13, _31_32_33, _41_42_43),

          minor(_12_13_14, _22_23_24, _42_43_44),
          -minor(_11_13_14, _21_23_24, _41_43_44),
          minor(_11_12_14, _21_22_24, _41_42_44),
          -minor(_11_12_13, _21_22_23, _41_42_43),

          -minor(_12_13_14, _22_23_24, _32_33_34),
          minor(_11_13_14, _21_23_24, _31_33_34),
          -minor(_11_12_14, _21_22_24, _31_32_34),
          minor(_11_12_13, _21_22_23, _31_32_33)
          );
#undef minor
        return transpose(cofactors) / determinant(input);
      }

      fixed4 frag (v2f i) : SV_Target
      {
        float fragTime = _Time.x*_TimeSpeed;
        float3x3 m = transpose((float3x3)UNITY_MATRIX_V);
        float3 posGlob = mul(m, UnityObjectToViewPos(float4(0.0, 0.0, 0.0, 1.0)));
        float3 ray = i.ray;
        float l = length(ray);
        ray = ray / l;
 
        float2 screen = i.screen.xy / i.screen.w;
        float depth = UNITY_SAMPLE_DEPTH(tex2D(_CameraDepthTexture, screen));
        float4 H = mul(inverse(UNITY_MATRIX_P),float4(screen.x * 2 - 1, screen.y * 2 - 1, depth,1));
        H = H / H.w;
        depth = length(H.xyz);

        H.xyz = mul(m,H.xyz);
       
        float scf = 0.25;
        float4 l1 = 0;
        float tsi = 1 / _ScaleTexture;
        float DepthSize = l+_Depth/abs(dot(ray, _Normal.xyz));
        for (int i = 0; i < 4; i++) {
          float f1 = frac(fragTime + i * scf);
          float3 ray1 = ray * lerp(DepthSize, l, f1);
          float3 to1 = ray1 - posGlob;
          float a1 = dot(H.xyz - ray1, _Normal.xyz);
          a1 = clamp(a1*(1 - f1)*_String, 0, 1);
          a1 = a1*a1*(3.0 - 2.0*a1);
          float color = tex2D(_FogMask, to1.xz*tsi + 0.5).a;
          l1 = l1+ color*(tex2D(_FogNoise, to1.xz*tsi +i*scf).a + _Emmission)* a1;
        }

        return float4(_FogColor*clamp(l1, 0, 1));
      }
      ENDCG
    }
  }
}