Не записывается MRT на URP

public class DOFInternalData
    {
    public RenderTexture m_pTexHDRTargetMaskedScaledNear;
    public RenderTexture m_pTexHDRTargetMaskedScaledFar;
    public RenderTexture m_pTexSceneCoC0;

    public RenderBuffer _depthBuffer;
    public RenderBuffer[] _downscaleLayersBuffers;

    public void Dispose()
        {
      RenderTextureUtils.ReleaseRenderTexture(ref m_pTexHDRTargetMaskedScaledNear);
      RenderTextureUtils.ReleaseRenderTexture(ref m_pTexHDRTargetMaskedScaledFar);
      RenderTextureUtils.ReleaseRenderTexture(ref m_pTexSceneCoC0);
    }
    }

    [DisallowMultipleRendererFeature]
    public class DOF : ScriptableRendererFeature
  {
    private const string k_dofShaderName = "Hidden/CustomRenderer/DOF";

    public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingTransparents;

    private Shader m_dofShader;
    private Material m_dofMaterial;
    private DOFInternalData m_internalData;
    private DOFPass m_dofPass;

    public override void Create()
    {
      if (m_internalData != null) m_internalData.Dispose();
      m_internalData = new DOFInternalData();
      m_dofPass = new DOFPass(m_internalData);
      CustomRenderer.Instance.DOF = this;
        }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
            if (!GetMaterials())
      {
        Debug.LogErrorFormat(
          "{0}.AddRenderPasses(): Missing material. {1} render pass will not be added. Check for missing reference in the renderer resources.",
          GetType().Name, name);
        return;
      }

      bool shouldAdd = m_dofPass.Setup(renderer, m_dofMaterial, renderPassEvent);
      if (shouldAdd) renderer.EnqueuePass(m_dofPass);
    }

    protected override void Dispose(bool disposing)
    {
      if (disposing == false) return;
      CustomRenderer.Instance.DOF = null;
      DestroyImmediate(m_dofMaterial);
      m_internalData.Dispose();
    }

    private bool GetMaterials()
    {
      if (m_dofMaterial != null)
        return true;

      if (m_dofMaterial == null)
      {
        m_dofShader = Shader.Find(k_dofShaderName);
        if (m_dofShader == null) return false;
        m_dofMaterial = new Material(m_dofShader);
      }

            return m_dofMaterial != null;
        }
  }

  public class DOFPass : ScriptableRenderPass
  {
    private const string k_downscaleDofPassName = "DownscaleDof";
    private int m_downscaleDofPassId;

    private ScriptableRenderer m_renderer;
    private DOFInternalData m_internalData;
    private Material m_dofMaterial;

    public DOFPass(DOFInternalData internalData)
        {
      m_internalData = internalData;
    }

    internal bool Setup(ScriptableRenderer renderer, Material dofMaterial, RenderPassEvent renderPassEvent)
    {
      this.renderPassEvent = renderPassEvent;      
      m_renderer = renderer;
      m_dofMaterial = dofMaterial;

      m_downscaleDofPassId = m_dofMaterial.FindPass(k_downscaleDofPassName);

      return m_dofMaterial != null;
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
      if (m_dofMaterial == null)
      {
        Debug.LogErrorFormat("{0}.Execute(): Missing materials. DOF pass will not execute. Check for missing reference in the renderer resources.",
          GetType().Name);
        return;
      }

      CommandBuffer cmd = CommandBufferPool.Get();
      using (new ProfilingScope(cmd, new ProfilingSampler("DepthOfField")))
      {
        ExecuteDOF(cmd, ref renderingData);
      }
        
      context.ExecuteCommandBuffer(cmd);
      CommandBufferPool.Release(cmd);
    }

    private void ExecuteDOF(CommandBuffer cmd, ref RenderingData renderingData)
    {
      var camera = renderingData.cameraData.camera;

      using (new ProfilingScope(cmd, new ProfilingSampler("DownscaleLayers")))
      {
        var downscaledSize = RenderTextureUtils.GetDownscaledSize(camera.scaledPixelWidth, camera.scaledPixelHeight, 1);
        RenderTextureUtils.EnsureRenderTexture("TexHDRTargetMaskedScaledNear", ref m_internalData.m_pTexHDRTargetMaskedScaledNear, downscaledSize.x, downscaledSize.y, GraphicsFormat.R16G16B16A16_SFloat, FilterMode.Point);
        RenderTextureUtils.EnsureRenderTexture("TexHDRTargetMaskedScaledFar", ref m_internalData.m_pTexHDRTargetMaskedScaledFar, downscaledSize.x, downscaledSize.y, GraphicsFormat.R16G16B16A16_SFloat, FilterMode.Point);
        RenderTextureUtils.EnsureRenderTexture("TexSceneCoC_0", ref m_internalData.m_pTexSceneCoC0, downscaledSize.x, downscaledSize.y, GraphicsFormat.R16G16_SFloat, FilterMode.Point);
        if (m_internalData._downscaleLayersBuffers == null || m_internalData._downscaleLayersBuffers.Length != 3)
        {
          m_internalData._downscaleLayersBuffers = new RenderBuffer[]
          {
                m_internalData.m_pTexHDRTargetMaskedScaledNear.colorBuffer,
                m_internalData.m_pTexHDRTargetMaskedScaledFar.colorBuffer,
                m_internalData.m_pTexSceneCoC0.colorBuffer
          };
        }
        else
        {
          m_internalData._downscaleLayersBuffers[0] = m_internalData.m_pTexHDRTargetMaskedScaledNear.colorBuffer;
          m_internalData._downscaleLayersBuffers[1] = m_internalData.m_pTexHDRTargetMaskedScaledFar.colorBuffer;
          m_internalData._downscaleLayersBuffers[2] = m_internalData.m_pTexSceneCoC0.colorBuffer;
        }

        RenderTargetSetup downscaleLayersRenderTargetSetup = new RenderTargetSetup(m_internalData._downscaleLayersBuffers, m_internalData.m_pTexSceneCoC0.depthBuffer);
        RenderTargetBinding rtBinding = new RenderTargetBinding(downscaleLayersRenderTargetSetup);

        cmd.SetRenderTarget(rtBinding);
        cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, m_dofMaterial, 0, m_downscaleDofPassId);
      }
    }
  }