Корявый блюр

public class Bloom
    {
    private int m_HDRBloomGaussianPass;
    private Material m_HDRPostProcessMaterial;

    private readonly float m_sigma1 = Mathf.Sqrt(0.008f);
    private readonly float m_sigma2 = Mathf.Sqrt(0.0568f);

    private readonly int m_HDRBloomParamsProperty = Shader.PropertyToID("_HDRBloomParams");
    private readonly int m_HDRBloomParams2Property = Shader.PropertyToID("_HDRBloomParams2");
    private readonly int m_HDRBloomParams3Property = Shader.PropertyToID("_HDRBloomParams3");
    private readonly int m_HDRBloomParams4Property = Shader.PropertyToID("_HDRBloomParams4");
    private readonly int m_HDRBloom_TempProperty = Shader.PropertyToID("_HDRBloom_Temp");
    private readonly int m_HDRBloom_Temp2Property = Shader.PropertyToID("_HDRBloom_Temp2");
    private readonly int m_HDRBloomPassCountProperty = Shader.PropertyToID("_HDRBloomPassCount");

    private Vector4 m_passFirstHorBloomParams;
    private Vector4 m_passFirstVerBloomParams;
    private Vector4 m_passSecondHorBloomParams;
    private Vector4 m_passSecondVerBloomParams;

    public void Deinitialize()
        {
      //...
        }

    public bool Initialize(CommandBuffer commandBuffer)
    {
      Deinitialize();

      if (HDRTargetRTs.IsReady == false) return false;

      if (m_HDRPostProcessMaterial == null)
      {
        var shader = Shader.Find("Renderer/HDRPostProcess");
        if (shader == null) return false;
        m_HDRPostProcessMaterial = new Material(shader);
      }

      m_HDRPostProcessMaterial.name = "HDRPostProcess";
      m_HDRBloomGaussianPass = m_HDRPostProcessMaterial.FindPass("HDRBloomGaussian");

      // Pass 1 Horizontal
      {
        commandBuffer.SetGlobalInt(m_HDRBloomPassCountProperty, 1);
        commandBuffer.SetGlobalTexture(m_HDRBloom_TempProperty, HDRTargetRTs.m_rtHDRTargetScaled[1][0]);
        commandBuffer.Blit(HDRTargetRTs.m_rtHDRTargetScaled[1][0], HDRTargetRTs.m_rtHDRTargetScaled[1][1], m_HDRPostProcessMaterial, m_HDRBloomGaussianPass);
      }

      // Pass 1 Vertical
      {
        commandBuffer.SetGlobalInt(m_HDRBloomPassCountProperty, 2);
        commandBuffer.SetGlobalTexture(m_HDRBloom_TempProperty, HDRTargetRTs.m_rtHDRTargetScaled[1][1]);
        commandBuffer.Blit(HDRTargetRTs.m_rtHDRTargetScaled[1][1], HDRTargetRTs.m_rtHDRTargetScaled[1][0], m_HDRPostProcessMaterial, m_HDRBloomGaussianPass);
      }

      // Pass 2 Horizontal
      {
        commandBuffer.SetGlobalInt(m_HDRBloomPassCountProperty, 3);
        commandBuffer.SetGlobalTexture(m_HDRBloom_TempProperty, HDRTargetRTs.m_rtHDRTargetScaled[1][0]);
        commandBuffer.Blit(HDRTargetRTs.m_rtHDRTargetScaled[1][0], HDRTargetRTs.m_rtHDRTargetScaled[1][1], m_HDRPostProcessMaterial, m_HDRBloomGaussianPass);
      }

      // Pass 2 Vertical
      {
        commandBuffer.SetGlobalInt(m_HDRBloomPassCountProperty, 4);
        commandBuffer.SetGlobalTexture(m_HDRBloom_TempProperty, HDRTargetRTs.m_rtHDRTargetScaled[1][1]);
        commandBuffer.SetGlobalTexture(m_HDRBloom_Temp2Property, HDRTargetRTs.m_rtHDRTargetScaled[1][0]);
        commandBuffer.Blit(HDRTargetRTs.m_rtHDRTargetScaled[1][1], HDRTargetRTs.m_rtHDRFinalBloom, m_HDRPostProcessMaterial, m_HDRBloomGaussianPass);
      }

      return true;
    }

    public void Update()
        {
      int width = HDRTargetRTs.m_rtHDRFinalBloom.width;
      int height = HDRTargetRTs.m_rtHDRFinalBloom.height;
      float scaleW = ((float)width / 400.0f) / (float)width;
      float scaleH = ((float)height / 225.0f) / (float)height;

      m_passFirstHorBloomParams = new Vector4(scaleW, 0, 0, 0);
      m_passFirstVerBloomParams = new Vector4(0, scaleH, 0, 0);
      m_passSecondHorBloomParams = new Vector4((m_sigma2 / m_sigma1) * scaleW, 0, 0, 0);
      m_passSecondVerBloomParams = new Vector4(0, (m_sigma2 / m_sigma1) * scaleH, 0, 0);
      Shader.SetGlobalVector(m_HDRBloomParamsProperty, m_passFirstHorBloomParams);
      Shader.SetGlobalVector(m_HDRBloomParams2Property, m_passFirstVerBloomParams);      
      Shader.SetGlobalVector(m_HDRBloomParams3Property, m_passSecondHorBloomParams);
      Shader.SetGlobalVector(m_HDRBloomParams4Property, m_passSecondVerBloomParams);
    }
  }

Pass
    {
      Name "HDRBloomGaussian"
      CGPROGRAM
      #pragma vertex vert_img
      #pragma fragment frag
      #include "UnityCG.cginc"
      #include "..//CommonMath.hlsl"
      
      uniform sampler2D _HDRBloom_Temp; // 1/4 от исходного разрешения
      uniform sampler2D _HDRBloom_Temp2; // 1/4 от исходного разрешения

      float4 _HDRBloomParams;
      float4 _HDRBloomParams2;
      float4 _HDRBloomParams3;
      float4 _HDRBloomParams4;
      int _HDRBloomPassCount;

      half3 frag(v2f_img IN) : COLOR
      {
        const float weights[15] = { 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153 };
        const float weightSum = 262106.0;

        float4 bloomParams = _HDRBloomParams;
        if (_HDRBloomPassCount == 2) bloomParams = _HDRBloomParams2;
        if (_HDRBloomPassCount == 3) bloomParams = _HDRBloomParams3;
        if (_HDRBloomPassCount == 4) bloomParams = _HDRBloomParams4;

        float2 coords = IN.uv.xy - bloomParams.xy * 7.0;
        half3 vColor = 0;

        [unroll]
        for (int i = 0; i < 15; ++i)
        {
          vColor += tex2D(_HDRBloom_Temp, coords).rgb * (weights[i] / weightSum);
          coords += bloomParams.xy;
        }

        if (_HDRBloomPassCount == 4)
        {
          half3 bloom0 = tex2D(_HDRBloom_Temp2, IN.uv.xy).rgb;
          half3 bloom1 = vColor;
          vColor = (0.0174 * bloom0 + 0.192 * bloom1) / (0.0174 + 0.192);
        }

        return vColor;
      }

    ENDCG
        }