IT WORKS! - Stopped render using the XR SDK:

Back to old hacks for bindFramebuffer and transparent background.
Added a hack to modify Unity's draw display shader.

Author: De-Panther

Packages/webxr-interactions/Runtime/Scripts/SpectatorCamera.cs

@@ -1,4 +1,5 @@
 using UnityEngine;
+using UnityEngine.Rendering;
 
 namespace WebXR.Interactions
 {
@@ -24,11 +25,21 @@ private void OnEnable()
       WebXRManager.OnXRChange += HandleOnXRChange;
       currentXRState = WebXRManager.Instance.XRState;
       TryUpdateCameraState();
+      RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
     }
 
     private void OnDisable()
     {
       WebXRManager.OnXRChange -= HandleOnXRChange;
+      RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
+    }
+
+    void OnBeginCameraRendering(ScriptableRenderContext context, Camera camera)
+    {
+      if (camera == _camera)
+      {
+        WebXRManager.Instance.PreRenderSpectatorCamera();
+      }
     }
 
     private void OnPreRender()

Packages/webxr/Runtime/Plugins/WebGL/WebXRDisplayProvider.cpp

@@ -108,7 +108,7 @@ UnitySubsystemErrorCode WebXRDisplayProvider::Start()
       s_PoseXPositionPerPass[1] = 0;
     }
     transparentBackground = *(m_ViewsDataArray + 55) > 0;
-    webXRFrameBuffer = WebXRInitDisplayRender();
+    /*webXRFrameBuffer = WebXRInitDisplayRender();
 
     webxrVertexShader = glCreateShader(GL_VERTEX_SHADER);
     const GLchar* vertexSource = R"(#version 300 es
@@ -155,7 +155,7 @@ UnitySubsystemErrorCode WebXRDisplayProvider::Start()
     glBufferData(GL_ARRAY_BUFFER, sizeof(uvData), uvData, GL_STATIC_DRAW);
 
     glEnableVertexAttribArray(webXRTextureCoordsAttributeLocation);
-    glVertexAttribPointer(webXRTextureCoordsAttributeLocation, 2, GL_FLOAT, GL_FALSE, 0, uvData);
+    glVertexAttribPointer(webXRTextureCoordsAttributeLocation, 2, GL_FLOAT, GL_FALSE, 0, uvData);*/
 
     return kUnitySubsystemErrorCodeSuccess;
 }
@@ -164,13 +164,13 @@ UnitySubsystemErrorCode WebXRDisplayProvider::GfxThread_Start(UnityXRRenderingCa
 {
     renderingCaps.noSinglePassRenderingSupport = true;
     renderingCaps.invalidateRenderStateAfterEachCallback = false;
-    renderingCaps.skipPresentToMainScreen = true;
+    renderingCaps.skipPresentToMainScreen = false;
     return kUnitySubsystemErrorCodeSuccess;
 }
 
 UnitySubsystemErrorCode WebXRDisplayProvider::GfxThread_SubmitCurrentFrame()
 {
-    glBindFramebuffer(GL_FRAMEBUFFER, webXRFrameBuffer);
+    /*glBindFramebuffer(GL_FRAMEBUFFER, webXRFrameBuffer);
     glViewport(0, 0, static_cast<int>(frameBufferWidth), static_cast<int>(frameBufferHeight));
     glClearColor(0, 0, 0, 0);
     glDepthMask(false); // solves bug in some android phones
@@ -200,8 +200,7 @@ UnitySubsystemErrorCode WebXRDisplayProvider::GfxThread_SubmitCurrentFrame()
     glBindTexture(GL_TEXTURE_2D, uDesc.color.referenceTextureId);
     glUniform1i(webXRTextureAttributeLocation, 0);
 
-    glDrawArrays(GL_TRIANGLES, 0, 6);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    glDrawArrays(GL_TRIANGLES, 0, 6);*/
 
     return kUnitySubsystemErrorCodeSuccess;
 }
@@ -362,12 +361,12 @@ UnitySubsystemErrorCode WebXRDisplayProvider::GfxThread_FinalBlitToGameViewBackB
 
 void WebXRDisplayProvider::Stop()
 {
-  WebXRDestructDisplayRender(webXRFrameBuffer);
+  /*WebXRDestructDisplayRender(webXRFrameBuffer);
   glDeleteProgram(webXRDisplayProgram);
   glDeleteShader(webxrVertexShader);
   glDeleteShader(webxrFragmentShader);
   glDeleteBuffers(1, &webXRPositionBuffer);
-  glDeleteBuffers(1, &webXRUVBuffer);
+  glDeleteBuffers(1, &webXRUVBuffer);*/
 }
 
 void WebXRDisplayProvider::Shutdown()

Packages/webxr/Runtime/Plugins/WebGL/transparent_bg.jslib

@@ -2,15 +2,15 @@
 // More details at https://support.unity.com/hc/en-us/articles/208892946-How-can-I-make-the-canvas-transparent-on-WebGL-
 var LibraryGLClear = {
   $colorMaskValue: [true, true, true, true],
-  glClear1: function (mask) { // disable hack while WIP
+  glClear: function (mask) {
     if (mask == 0x00004000 && GLctx.dontClearAlphaOnly) {
       if (!colorMaskValue[0] && !colorMaskValue[1] && !colorMaskValue[2] && colorMaskValue[3])
         // We are trying to clear alpha only -- skip.
         return;
     }
     GLctx.clear(mask);
   },
-  glColorMask1: function (red, green, blue, alpha) { // disable hack while WIP
+  glColorMask: function (red, green, blue, alpha) {
     colorMaskValue[0] = !!red;
     colorMaskValue[1] = !!green;
     colorMaskValue[2] = !!blue;

Packages/webxr/Runtime/Plugins/WebGL/webxr.jspre

@@ -18,6 +18,58 @@ setTimeout(function () {
 
             return GL.createContextOld(canvas, contextAttributes);
         }
+
+        const shaderBug = `#version 300 es
+
+#define HLSLCC_ENABLE_UNIFORM_BUFFERS 1
+#if HLSLCC_ENABLE_UNIFORM_BUFFERS
+#define UNITY_UNIFORM
+#else
+#define UNITY_UNIFORM uniform
+#endif
+#define UNITY_SUPPORTS_UNIFORM_LOCATION 0
+#if UNITY_SUPPORTS_UNIFORM_LOCATION
+#define UNITY_LOCATION(x) layout(location = x)
+#define UNITY_BINDING(x) layout(binding = x, std140)
+#else
+#define UNITY_LOCATION(x)
+#define UNITY_BINDING(x) layout(std140)
+#endif
+uniform 	vec4 _ScaleBias;
+uniform 	vec4 _ScaleBiasRt;
+out highp vec2 vs_TEXCOORD0;
+vec4 u_xlat0;
+int u_xlati0;
+uvec2 u_xlatu0;
+vec4 u_xlat1;
+int u_xlati4;
+void main()
+{
+    u_xlati0 = int(uint(uint(gl_VertexID) & 1u));
+    u_xlatu0.y = uint(uint(gl_VertexID) >> 1u);
+    u_xlati4 = (-u_xlati0) + (-int(u_xlatu0.y));
+    u_xlati0 = u_xlati0 + int(u_xlatu0.y);
+    u_xlatu0.x = uint(uint(u_xlati0) & 1u);
+    u_xlat1.xw = vec2(u_xlatu0.yx);
+    vs_TEXCOORD0.xy = u_xlat1.xw * _ScaleBias.xy + _ScaleBias.zw;
+    u_xlati0 = u_xlati4 + 1;
+    u_xlatu0.x = uint(uint(u_xlati0) & 1u);
+    u_xlat1.y = float(u_xlatu0.x);
+    u_xlat0.xy = u_xlat1.xy * _ScaleBiasRt.xy + _ScaleBiasRt.zw;
+    u_xlat0.z = float(-1.0);
+    u_xlat0.w = float(1.0);
+    gl_Position = u_xlat0 * vec4(2.0, -2.0, 1.0, 1.0) + vec4(-1.0, 1.0, 0.0, 0.0);
+    return;
+}`
+        GL.getSourceOld = GL.getSource;
+        GL.getSource = function (shader, count, string, length) {
+          var source = GL.getSourceOld(shader, count, string, length);
+          if (shaderBug == source) {
+            source = source.replace("vs_TEXCOORD0.xy = u_xlat1.xw * _ScaleBias.xy + _ScaleBias.zw;",
+              "vs_TEXCOORD0.xy = u_xlat1.xw * vec2(1.0, 1.0);");
+          }
+          return source
+        }
     }
 
 
@@ -626,7 +678,7 @@ setTimeout(function () {
           }
 
           // bindFramebuffer frameBufferObject null in XRSession should use XRWebGLLayer FBO instead
-          /*thisXRMananger.ctx.oldBindFramebuffer = thisXRMananger.ctx.bindFramebuffer;
+          thisXRMananger.ctx.oldBindFramebuffer = thisXRMananger.ctx.bindFramebuffer;
           thisXRMananger.ctx.bindFramebuffer = function (target, fbo) {
             if (!fbo && !Module.WebXR.isSpectatorCameraRendering) {
               if (thisXRMananger.xrSession && thisXRMananger.xrSession.isInSession) {
@@ -636,7 +688,7 @@ setTimeout(function () {
               }
             }
             return thisXRMananger.ctx.oldBindFramebuffer(target, fbo)
-          };*/
+          };
         }
       }
 
@@ -965,15 +1017,15 @@ setTimeout(function () {
         }
 
         Module.WebXR.isSpectatorCameraRendering = false;
-        /*this.ctx.bindFramebuffer(this.ctx.FRAMEBUFFER, glLayer.framebuffer);
+        this.ctx.bindFramebuffer(this.ctx.FRAMEBUFFER, glLayer.framebuffer);
         if (session.isAR) {
           // Workaround for Chromium depth bug https://bugs.chromium.org/p/chromium/issues/detail?id=1167450#c21
           this.ctx.depthMask(false);
           this.ctx.clear(this.ctx.DEPTH_BUFFER_BIT);
           this.ctx.depthMask(true);
         } else {
           this.ctx.clear(this.ctx.COLOR_BUFFER_BIT | this.ctx.DEPTH_BUFFER_BIT);
-        }*/
+        }
 
         var pose = frame.getViewerPose(session.refSpace);
         if (!pose) {