Problem with URP RendererFeatures

[bo198214]

I am rather a newbee to Unity and recently wanted to experiment with the URP RendererFeatures and Blitting. I am using Unity 2022.3.17 with the default URP setup.
So I looked at the Unity documentation examples

• Example of a complete Scriptable Renderer Feature | Universal RP | 14.0.11 (This is a Blur in two passes)
• Perform a full screen blit in URP | Universal RP | 15.0.7 (This just filters the green component of scene and uses _CameraOpaqueTexture)

But there are problems. If I don’t press “Play” both RendererFeatures work well (screen blurred or screen greenish; switchable via the checkbox in the URP-HighFidelity-Renderer).
But after I press “Play”, switching on the BlurRendererFeature makes the cube disappear instead of blurred.
The screen is filled with a gray - which I am not sure where it comes from - I changed cube color and background color, but it seems unrelated.

Here are the Execute-Methods of both examples (the first one (blur) doesn’t work when “play” is pressed, the second one (green filter) works reliably (with and without pressing play)).

    public override void Execute(ScriptableRenderContext context,
        ref RenderingData renderingData)
    {
        //Get a CommandBuffer from pool.
        CommandBuffer cmd = CommandBufferPool.Get();

        RTHandle cameraTargetHandle =
            renderingData.cameraData.renderer.cameraColorTargetHandle;

        UpdateBlurSettings();

        // Blit from the camera target to the temporary render texture,
        // using the first shader pass.
        Blit(cmd, cameraTargetHandle, blurTextureHandle, material, 0);
        // Blit from the temporary render texture to the camera target,
        // using the second shader pass.
        Blit(cmd, blurTextureHandle, cameraTargetHandle, material, 1);

        //Execute the command buffer and release it back to the pool.
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

 public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        var cameraData = renderingData.cameraData;
        if (cameraData.camera.cameraType != CameraType.Game)
            return;

        if (m_Material == null)
            return;

        CommandBuffer cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, m_ProfilingSampler))
        {
            m_Material.SetFloat("_Intensity", m_Intensity);
            Blitter.BlitCameraTexture(cmd, m_CameraColorTarget, m_CameraColorTarget, m_Material, 0);
        }
        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();

        CommandBufferPool.Release(cmd);
    }
}

[bo198214]

I see now that it has to do with the VR-Setup. If I really only use a basic Unity without VR, it works.
Actually I have this link from PC to my headset (Quest 3) - that actually renders on the PC but then transfers to the Headset. And always if I switch that link on, then this strange behavior occurs (that instead of the blur effect the screen is painted in one color gray). (Also when I directly compile for the Quest 3 (Android) headset.)
Does anyone have an idea, what it could be?

I was already adhering to these recommendations (which I though not yet fully understand):

Unity - Manual: Single-pass instanced rendering and custom shaders

But to be honest I didn’t know how to incorporate UNITY_SAMPLE_SCREENSPACE_TEXTURE in the existing example. If someone could assist here, this is the shader code:

Shader "my/Blur"
{
    HLSLINCLUDE
  
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        // The Blit.hlsl file provides the vertex shader (Vert),
        // the input structure (Attributes), and the output structure (Varyings)
        #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"

        float _VerticalBlur;
        float _HorizontalBlur;
  
        float4 _BlitTexture_TexelSize;
  
        float4 BlurVertical (Varyings input) : SV_Target
        {
            UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

            const float BLUR_SAMPLES = 64;
            const float BLUR_SAMPLES_RANGE = BLUR_SAMPLES / 2;
          
            float3 color = 0;
            float blurPixels = _VerticalBlur * _ScreenParams.y;
          
            for(float i = -BLUR_SAMPLES_RANGE; i <= BLUR_SAMPLES_RANGE; i++)
            {
                float2 sampleOffset =
                    float2 (0, (blurPixels / _BlitTexture_TexelSize.w) *
                        (i / BLUR_SAMPLES_RANGE));
                color +=
                    SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp,
                        input.texcoord + sampleOffset).rgb;
            }
          
            return float4(color.rgb / (BLUR_SAMPLES + 1), 1);
        }

        float4 BlurHorizontal (Varyings input) : SV_Target
        {
            UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

            const float BLUR_SAMPLES = 64;
            const float BLUR_SAMPLES_RANGE = BLUR_SAMPLES / 2;
          
            float3 color = 0;
            float blurPixels = _HorizontalBlur * _ScreenParams.x;
            for(float i = -BLUR_SAMPLES_RANGE; i <= BLUR_SAMPLES_RANGE; i++)
            {
                float2 sampleOffset =
                    float2 ((blurPixels / _BlitTexture_TexelSize.z) *
                        (i / BLUR_SAMPLES_RANGE), 0);
                color +=
                    SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp,
                        input.texcoord + sampleOffset).rgb;
            }
            return float4(color / (BLUR_SAMPLES + 1), 1);
        }
  
    ENDHLSL
  
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline" = "UniversalPipeline"}
        LOD 100
        ZWrite Off Cull Off
        Pass
        {
            Name "BlurPassVertical"

            HLSLPROGRAM
          
            #pragma vertex Vert
            #pragma fragment BlurVertical
          
            ENDHLSL
        }
      
        Pass
        {
            Name "BlurPassHorizontal"

            HLSLPROGRAM
          
            #pragma vertex Vert
            #pragma fragment BlurHorizontal
          
            ENDHLSL
        }
    }
}

[bo198214]

Hm, I didn’t really solve this problem, but my related problem could be solved with some inspiration from this thread SRP Full Screen Blit Help
Basically I took the source code of FullScreenPassRendererFeature and boiled it down to what I originally wanted.