After a lot of trial and error, I isolated the issue causing graphics to look like a smudge in VR to WBOIT. I had never heard of it, so I had to Google it

WBOIT in OpenGL: transparency without sorting

The good thing is, I'm not really sure it matters to get working in VR. I think it's used for some type of post processing effect to make the screen look "Frosty", but in VR, without it looks just like the first Subnautica (and you still certainly get the feeling you're in arctic waters without it).

I'll need to test the visual difference of it on and off on the flatscreen version to compare. Here's the code that I disabled

using System;
using UnityEngine;
using UnityStandardAssets.ImageEffects;

[ExecuteInEditMode]
public class WBOIT : PostEffectsBase
{
	public override bool CheckResources()
	{
		return true;
	}

	private void Awake()
	{
		this.compositeMaterial = new Material(this.compositeShader);
		this.InitProperties();
	}

	private void OnDestroy()
	{
		this.DestroyRenderTargets();
	}

	public Texture GetTextureA()
	{
		return this.wboitTexture1;
	}

	public Texture GetTextureB()
	{
		return this.wboitTexture2;
	}

	private void CreateRenderTargets()
	{
		this.wboitTexture0 = new RenderTexture(Screen.width, Screen.height, 24, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
		this.wboitTexture0.name = "WBOIT Tex0";
		this.wboitTexture1 = new RenderTexture(Screen.width, Screen.height, 24, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
		this.wboitTexture1.name = "WBOIT TexA";
		this.wboitTexture2 = new RenderTexture(Screen.width, Screen.height, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
		this.wboitTexture2.name = "WBOIT TexB";
		this.compositeMaterial.SetTexture(this.texAPropertyID, this.wboitTexture1);
		this.compositeMaterial.SetTexture(this.texBPropertyID, this.wboitTexture2);
		this.colorBuffers = new RenderBuffer[]
		{
			this.wboitTexture0.colorBuffer,
			this.wboitTexture1.colorBuffer,
			this.wboitTexture2.colorBuffer
		};
	}

	private void DestroyRenderTargets()
	{
		if (this.camera)
		{
			this.camera.SetTargetBuffers(new RenderBuffer[1], default(RenderBuffer));
		}
		if (this.guiCamera)
		{
			this.guiCamera.SetTargetBuffers(new RenderBuffer[1], default(RenderBuffer));
		}
		this.colorBuffers = null;
		if (this.wboitTexture0 != null)
		{
			this.wboitTexture0.Release();
			this.wboitTexture0 = null;
		}
		if (this.wboitTexture1 != null)
		{
			this.wboitTexture1.Release();
			this.wboitTexture1 = null;
		}
		if (this.wboitTexture2 != null)
		{
			this.wboitTexture2.Release();
			this.wboitTexture2 = null;
		}
	}

	private void UpdateGlobalShaderParameters()
	{
		Shader.SetGlobalFloat(this.weightTogglePropertyID, this.useDepthWeighting ? 1f : 0f);
		Shader.SetGlobalFloat(this.weightSharpnessPropertyID, this.depthWeightingSharpness);
	}

	private void UpdateMaterialShaderParameters()
	{
		float value = (float)Screen.width / (float)Screen.height;
		this.compositeMaterial.SetFloat(ShaderPropertyID._AspectRatio, value);
		if (!this.debug && Time.time > this.nextTemperatureUpdate)
		{
			float temperature = this.GetTemperature();
			this.temperatureScalar = Mathf.Clamp01((temperature - 40f) / 30f);
			this.nextTemperatureUpdate = Time.time + UnityEngine.Random.value;
		}
		if (this.temperatureScalar > 0f && this.temperatureRefractTex != null)
		{
			if (!this.temperatureRefractEnabled)
			{
				this.compositeMaterial.EnableKeyword("FX_TEMPERATURE_REFRACT");
				this.temperatureRefractEnabled = true;
			}
			this.compositeMaterial.SetTexture(this.temperatureTexPropertyID, this.temperatureRefractTex);
			this.compositeMaterial.SetFloat(this.temperaturePropertyID, this.temperatureScalar);
		}
		else if (this.temperatureRefractEnabled)
		{
			this.compositeMaterial.DisableKeyword("FX_TEMPERATURE_REFRACT");
			this.temperatureRefractEnabled = false;
		}
		if (this.frostScalar > 0f)
		{
			if (!this.frostEnabled)
			{
				this.compositeMaterial.EnableKeyword("FX_FROST");
				this.frostEnabled = true;
			}
			this.compositeMaterial.SetTexture(this.frostNormalPropertyID, this.frostNormalTex);
			this.compositeMaterial.SetTexture(this.frostTexPropertyID, this.frostTex);
			this.compositeMaterial.SetFloat(this.frostScalarPropertyID, this.frostScalar);
			return;
		}
		if (this.frostEnabled)
		{
			this.compositeMaterial.DisableKeyword("FX_FROST");
			this.frostEnabled = false;
		}
	}

	private void InitProperties()
	{
		this.texAPropertyID = Shader.PropertyToID("_WBOIT_texA");
		this.texBPropertyID = Shader.PropertyToID("_WBOIT_texB");
		this.weightTogglePropertyID = Shader.PropertyToID("_WBOIT_WeightToggle");
		this.weightSharpnessPropertyID = Shader.PropertyToID("_WBOIT_WeightSharpness");
		this.temperatureTexPropertyID = Shader.PropertyToID("_TemperatureTex");
		this.temperaturePropertyID = Shader.PropertyToID("_TemperatureScalar");
		this.frostScalarPropertyID = Shader.PropertyToID("_FrostScalar");
		this.frostTexPropertyID = Shader.PropertyToID("_FrostTex");
		this.frostNormalPropertyID = Shader.PropertyToID("_FrostNormalTex");
	}

	private float GetTemperature()
	{
		WaterTemperatureSimulation main = WaterTemperatureSimulation.main;
		if (!(main != null))
		{
			return 0f;
		}
		return main.GetTemperature(Utils.GetLocalPlayerPos());
	}

	private void OnPreRender()
	{
		if (this.wboitTexture1 != null && (Screen.width != this.wboitTexture1.width || Screen.height != this.wboitTexture1.height))
		{
			this.DestroyRenderTargets();
		}
		if (this.wboitTexture1 == null || this.colorBuffers == null)
		{
			this.CreateRenderTargets();
		}
		RenderBuffer depthBuffer = this.wboitTexture1.depthBuffer;
		this.camera.SetTargetBuffers(this.colorBuffers, depthBuffer);
		this.guiCamera.SetTargetBuffers(this.colorBuffers, depthBuffer);
		Graphics.SetRenderTarget(this.wboitTexture1);
		GL.Clear(false, true, new Color(0f, 0f, 0f, 1f));
		Graphics.SetRenderTarget(this.wboitTexture2);
		GL.Clear(false, true, new Color(0f, 0f, 0f, 1f));
		this.UpdateGlobalShaderParameters();
		this.UpdateMaterialShaderParameters();
	}

	private void OnRenderImage(RenderTexture src, RenderTexture dst)
	{
		Graphics.Blit(src, dst, this.compositeMaterial);
	}

	[Header("WBOIT")]
	[AssertNotNull]
	[SerializeField]
	private Camera camera;

	[AssertNotNull]
	[SerializeField]
	private Camera guiCamera;

	private RenderBuffer[] colorBuffers;

	private RenderTexture wboitTexture0;

	private RenderTexture wboitTexture1;

	private RenderTexture wboitTexture2;

	public Shader compositeShader;

	private Material compositeMaterial;

	[Header("Hot temperature refraction")]
	public float temperatureScalar;

	public Texture2D temperatureRefractTex;

	private bool temperatureRefractEnabled;

	private int texAPropertyID = -1;

	private int texBPropertyID = -1;

	private int weightTogglePropertyID = -1;

	private int weightSharpnessPropertyID = -1;

	private int temperatureTexPropertyID = -1;

	private int temperaturePropertyID = -1;

	[Header("Frost screen effect")]
	[Range(0f, 1f)]
	public float frostScalar;

	public Texture2D frostTex;

	public Texture2D frostNormalTex;

	private bool frostEnabled;

	private int frostScalarPropertyID = -1;

	private int frostTexPropertyID = -1;

	private int frostNormalPropertyID = -1;

	public bool useDepthWeighting = true;

	public float depthWeightingSharpness = 0.1f;

	private float nextTemperatureUpdate;

	public bool debug;
}

The way that I went about disabling it is to simply disable the layer in the scenes. You could probably disable the shader too, but I didn't want it to try to run each time from the scene.

The main menu scene is called MenuEnvironment.unity

✅ The sky is still messed up for some reason (just in the menu). That shader might be used for something there, need to look into that.

Here in the scene, the shaders are in the category of "ParticleField"

Maybe it's floating chunks of ice or something?

The Main.unity scene is the one that contains the camera for the rest of the game. You can locate the camera here and disable WBOIT