diff --git a/OldschoolBeatSaber.sln b/OldschoolBeatSaber.sln
new file mode 100644
index 0000000..bfdf9e1
--- /dev/null
+++ b/OldschoolBeatSaber.sln
@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.2.32630.192
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OldschoolBeatSaber", "OldschoolBeatSaber\OldschoolBeatSaber.csproj", "{C24FA7EE-EBF3-4CBF-9237-20B7A5094797}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{C24FA7EE-EBF3-4CBF-9237-20B7A5094797}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C24FA7EE-EBF3-4CBF-9237-20B7A5094797}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C24FA7EE-EBF3-4CBF-9237-20B7A5094797}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C24FA7EE-EBF3-4CBF-9237-20B7A5094797}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {D8D59EE6-8906-44D4-9124-3C4DF56EC7FB}
+	EndGlobalSection
+EndGlobal
diff --git a/OldschoolBeatSaber/Behaviours/FlickeringSign.cs b/OldschoolBeatSaber/Behaviours/FlickeringSign.cs
new file mode 100644
index 0000000..5f904be
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/FlickeringSign.cs
@@ -0,0 +1,45 @@
+using System.Collections;
+using TMPro;
+using UnityEngine;
+
+namespace OldschoolBeatSaber.Behaviours
+{
+    public class FlickeringSign : MonoBehaviour
+    {
+        [SerializeField] private TextMeshPro _text;
+        [SerializeField] private TubeLight _light;
+        [SerializeField] private float _minOnDelay = .05f;
+        [SerializeField] private float _maxOnDelay = .4f;
+        [SerializeField] private float _minOffDelay = .05f;
+        [SerializeField] private float _maxOffDelay = .4f;
+        [SerializeField] private Color _onColor;
+        [SerializeField] private Color _offColor;
+        [SerializeField] private TMP_FontAsset _onFont;
+        [SerializeField] private TMP_FontAsset _offFont;
+
+        private void OnEnable()
+        {
+            StartCoroutine(FlickeringCoroutine());
+        }
+
+        private IEnumerator FlickeringCoroutine()
+        {
+            while (true)
+            {
+                yield return new WaitForSeconds(UnityEngine.Random.Range(_minOnDelay, _maxOnDelay));
+                SetOn(false);
+
+                yield return new WaitForSeconds(UnityEngine.Random.Range(_minOffDelay, _maxOffDelay));
+                SetOn(true);
+            }
+        }
+
+        private void SetOn(bool on)
+        {
+            var color = !on ? _offColor : _onColor;
+            _text.color = color;
+            _text.font = !on ? _offFont : _onFont;
+            _light.color = color;
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/MenuFogParams.cs b/OldschoolBeatSaber/Behaviours/MenuFogParams.cs
new file mode 100644
index 0000000..7d44950
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/MenuFogParams.cs
@@ -0,0 +1,62 @@
+using IPA.Utilities;
+using OldschoolBeatSaber.Interfaces;
+using System.Linq;
+using UnityEngine;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours
+{
+    public class MenuFogParams : MonoBehaviour, IOnActivate, IOnDeactivate
+    {
+        private static readonly FieldAccessor<BloomFogEnvironment, BloomFogEnvironmentParams>.Accessor _fogParamsAccessor
+            = FieldAccessor<BloomFogEnvironment, BloomFogEnvironmentParams>.GetAccessor("_fogParams");
+
+        [SerializeField] private float _attenuation = .1f;
+        [SerializeField] private float _offset;
+        [SerializeField] private float _heightFogStartY = -300f;
+        [SerializeField] private float _heightFogHeight = 10f;
+        [SerializeField]
+        [Min(0f)] private float _brightness = .1f;
+        [SerializeField]
+        [Range(0f, 1f)] private float _autoExposureIntensity = 1f;
+
+        private BloomFogEnvironmentParams _bloomFogEnvironmentParams;
+        private BloomFogEnvironmentParams _customBloomFogEnvironmentParams;
+        private BloomFogEnvironment _bloomFogEnvironment;
+
+        public void OnActivate(DiContainer container)
+        {
+            // not good but whatever.
+            if (_bloomFogEnvironment == null)
+            {
+                _bloomFogEnvironment = Resources.FindObjectsOfTypeAll<BloomFogEnvironment>()
+                    .Where(x => x.gameObject.scene.name == "MainMenu")
+                    .FirstOrDefault();
+            }
+
+            if (_customBloomFogEnvironmentParams == null)
+            {
+                _customBloomFogEnvironmentParams = ScriptableObject.CreateInstance<BloomFogEnvironmentParams>();
+                _customBloomFogEnvironmentParams.attenuation = _attenuation;
+                _customBloomFogEnvironmentParams.offset = _offset;
+                _customBloomFogEnvironmentParams.heightFogStartY = _heightFogStartY;
+                _customBloomFogEnvironmentParams.heightFogHeight = _heightFogHeight;
+                _customBloomFogEnvironmentParams.brightness = _brightness;
+                _customBloomFogEnvironmentParams.autoExposureIntensity = _autoExposureIntensity;
+            }
+
+            _bloomFogEnvironment.enabled = false;
+            _bloomFogEnvironmentParams = _fogParamsAccessor(ref _bloomFogEnvironment);
+            _fogParamsAccessor(ref _bloomFogEnvironment) = _customBloomFogEnvironmentParams;
+            _bloomFogEnvironment.enabled = true;
+        }
+
+        public void OnDeactivate()
+        {
+            _bloomFogEnvironment.enabled = false;
+            _fogParamsAccessor(ref _bloomFogEnvironment) = _bloomFogEnvironmentParams;
+            UnityEngine.Object.Destroy(_customBloomFogEnvironmentParams);
+            _bloomFogEnvironment.enabled = true;
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/MenuSceneSetup.cs b/OldschoolBeatSaber/Behaviours/MenuSceneSetup.cs
new file mode 100644
index 0000000..b97c722
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/MenuSceneSetup.cs
@@ -0,0 +1,17 @@
+using OldschoolBeatSaber.Behaviours.UI;
+using UnityEngine;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours
+{
+    public class MenuSceneSetup : MonoBehaviour
+    {
+        [SerializeField] private VRUIScreenSystem _screenSystem;
+        [SerializeField] private MenuMasterViewController _menuMasterViewController;
+
+        private void Start()
+        {
+            _screenSystem.mainScreen.SetRootViewController(_menuMasterViewController);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/TubeLight.cs b/OldschoolBeatSaber/Behaviours/TubeLight.cs
new file mode 100644
index 0000000..9966e78
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/TubeLight.cs
@@ -0,0 +1,124 @@
+using IPA.Utilities;
+using OldschoolBeatSaber.Interfaces;
+using OldschoolBeatSaber.Utilities;
+using System.Linq;
+using UnityEngine;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours
+{
+    public class TubeLight : MonoBehaviour, IOnActivate
+    {
+        private static readonly FieldAccessor<ParametricBoxController, MeshRenderer>.Accessor _meshRendererAccessor =
+            FieldAccessor<ParametricBoxController, MeshRenderer>.GetAccessor("_meshRenderer");
+
+        private static readonly FieldAccessor<BloomPrePassLight, BloomPrePassLightTypeSO>.Accessor _lightTypeAccessor
+            = FieldAccessor<BloomPrePassLight, BloomPrePassLightTypeSO>.GetAccessor("_lightType");
+
+        private static readonly FieldAccessor<TubeBloomPrePassLight, BoolSO>.Accessor _mainEffectPostProcessEnabledAccessor
+            = FieldAccessor<TubeBloomPrePassLight, BoolSO>.GetAccessor("_mainEffectPostProcessEnabled");
+        private static readonly FieldAccessor<TubeBloomPrePassLight, float>.Accessor _centerAccessor
+            = FieldAccessor<TubeBloomPrePassLight, float>.GetAccessor("_center");
+        private static readonly FieldAccessor<TubeBloomPrePassLight, float>.Accessor _colorAlphaMultiplierAccessor
+            = FieldAccessor<TubeBloomPrePassLight, float>.GetAccessor("_colorAlphaMultiplier");
+        private static readonly FieldAccessor<TubeBloomPrePassLight, ParametricBoxController>.Accessor _parametricBoxControllerAccessor
+            = FieldAccessor<TubeBloomPrePassLight, ParametricBoxController>.GetAccessor("_parametricBoxController");
+
+        public enum BoxLightType
+        {
+            None,
+            Opaque,
+            Transparent
+        }
+
+        [SerializeField] private float _width = .5f;
+        [SerializeField] private float _length = 1f;
+        [SerializeField]
+        [Range(0f, 1f)] private float _center = 1f;
+        [SerializeField] private Color _color = Color.cyan;
+        [SerializeField] private float _colorAlphaMultiplier = 1f;
+        [SerializeField] private float _bloomFogIntensityMultiplier = 1f;
+        [SerializeField] private BoxLightType _boxLightType;
+
+        private BoolSO _mainEffectPostProcessEnabled;
+        private TubeBloomPrePassLight _tubeBloomPrePassLight;
+
+        public Color color
+        {
+            get
+            {
+                if (_tubeBloomPrePassLight != null)
+                    return _tubeBloomPrePassLight.color;
+
+                return _color; // We'll fallback, just in-case.
+            }
+            set
+            {
+                _color = value;
+
+                if (_tubeBloomPrePassLight != null)
+                    _tubeBloomPrePassLight.color = _color;
+            }
+        }
+
+        [Inject]
+        public void Construct()
+        {
+            _mainEffectPostProcessEnabled = ScriptableObject.CreateInstance<BoolSO>();
+            _mainEffectPostProcessEnabled.value = true;
+        }
+
+        public void OnActivate(DiContainer container)
+        {
+            container.Inject(this);
+
+            if (_tubeBloomPrePassLight == null)
+            {
+                var activeSelf = gameObject.activeSelf;
+                gameObject.SetActive(false);
+
+                _tubeBloomPrePassLight = gameObject.AddComponent<TubeBloomPrePassLight>();
+
+                BloomPrePassLight bloomPrePassLight = _tubeBloomPrePassLight;
+                _lightTypeAccessor(ref bloomPrePassLight) = BloomPrePassLight.bloomLightsDict.Keys.First(x => x.name == "AddBloomPrePassLightType");
+
+                _mainEffectPostProcessEnabledAccessor(ref _tubeBloomPrePassLight) = _mainEffectPostProcessEnabled;
+                _centerAccessor(ref _tubeBloomPrePassLight) = _center;
+                _colorAlphaMultiplierAccessor(ref _tubeBloomPrePassLight) = _colorAlphaMultiplier;
+                _tubeBloomPrePassLight.width = _width * 2f;
+                _tubeBloomPrePassLight.length = _length;
+                _tubeBloomPrePassLight.color = _color;
+                _tubeBloomPrePassLight.bloomFogIntensityMultiplier = _bloomFogIntensityMultiplier;
+
+                if (_boxLightType != BoxLightType.None)
+                {
+                    var boxLightGameObject = new GameObject("BoxLight");
+                    boxLightGameObject.SetActive(false);
+                    boxLightGameObject.layer = 13; // NeonLight
+                    var boxLightTransform = boxLightGameObject.transform;
+                    boxLightTransform.SetParent(transform);
+                    boxLightTransform.localRotation = Quaternion.Euler(Vector3.zero);
+
+                    var boxLightMeshFilter = boxLightGameObject.AddComponent<MeshFilter>();
+                    boxLightMeshFilter.mesh = ResourceUtility.TubeMesh;
+                    var boxLightMeshRenderer = boxLightGameObject.AddComponent<MeshRenderer>();
+                    boxLightMeshRenderer.sharedMaterial = _boxLightType switch
+                    {
+                        BoxLightType.Opaque => ResourceUtility.EnvLightOpaqueMaterial,
+                        BoxLightType.Transparent => ResourceUtility.EnvLightMaterial,
+                        _ => null
+                    };
+
+                    var boxLightParametricBoxController = boxLightGameObject.AddComponent<ParametricBoxController>();
+                    _meshRendererAccessor(ref boxLightParametricBoxController) = boxLightMeshRenderer;
+
+                    boxLightGameObject.SetActive(true);
+
+                    _parametricBoxControllerAccessor(ref _tubeBloomPrePassLight) = boxLightParametricBoxController;
+                }
+
+                gameObject.SetActive(activeSelf);
+            }
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/ButtonClickSignal.cs b/OldschoolBeatSaber/Behaviours/UI/ButtonClickSignal.cs
new file mode 100644
index 0000000..b9d99f6
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/ButtonClickSignal.cs
@@ -0,0 +1,40 @@
+using IPA.Utilities;
+using OldschoolBeatSaber.Interfaces;
+using OldschoolBeatSaber.Utilities;
+using UnityEngine;
+using UnityEngine.UI;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class ButtonClickSignal : MonoBehaviour, IOnActivate
+    {
+        private static readonly FieldAccessor<SignalOnUIButtonClick, Signal>.Accessor _buttonClickedSignalAccessor =
+            FieldAccessor<SignalOnUIButtonClick, Signal>.GetAccessor("_buttonClickedSignal");
+        private static readonly FieldAccessor<SignalOnUIButtonClick, Button>.Accessor _buttonAccessor
+            = FieldAccessor<SignalOnUIButtonClick, Button>.GetAccessor("_button");
+
+        private Signal _uiButtonWasPressedSignal;
+        private SignalOnUIButtonClick _signalOnUIButtonClick;
+
+        public void OnActivate(DiContainer container)
+        {
+            container.Inject(this);
+
+            if (_uiButtonWasPressedSignal == null)
+                _uiButtonWasPressedSignal = ResourceUtility.Find<Signal>("UIButtonWasPressed");
+
+            if (_signalOnUIButtonClick == null)
+            {
+                var activeSelf = gameObject.activeSelf;
+                gameObject.SetActive(false);
+
+                _signalOnUIButtonClick = gameObject.AddComponent<SignalOnUIButtonClick>();
+                _buttonClickedSignalAccessor(ref _signalOnUIButtonClick) = _uiButtonWasPressedSignal;
+                _buttonAccessor(ref _signalOnUIButtonClick) = gameObject.GetComponent<Button>();
+
+                gameObject.SetActive(activeSelf);
+            }
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/DifficultyTableCell.cs b/OldschoolBeatSaber/Behaviours/UI/DifficultyTableCell.cs
new file mode 100644
index 0000000..be0c7ab
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/DifficultyTableCell.cs
@@ -0,0 +1,41 @@
+using HMUI;
+using TMPro;
+using UnityEngine;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+#pragma warning disable CS0436
+    public class DifficultyTableCell : TableCell
+#pragma warning restore CS0436
+    {
+        [SerializeField] private UnityEngine.UI.Image _bgImage;
+        [SerializeField] private UnityEngine.UI.Image _highlightImage;
+        [SerializeField] private TextMeshProUGUI _difficultyText;
+
+        public string DifficultyText
+        {
+            get => _difficultyText.text;
+            set => _difficultyText.text = value;
+        }
+
+        protected override void SelectionDidChange(TransitionType transitionType)
+        {
+            if (selected)
+            {
+                _highlightImage.enabled = false;
+                _bgImage.enabled = true;
+                _difficultyText.color = Color.black;
+            }
+            else
+            {
+                _bgImage.enabled = false;
+                _difficultyText.color = Color.white;
+            }
+        }
+
+        protected override void HighlightDidChange(TransitionType transitionType)
+        {
+            _highlightImage.enabled = !selected ? highlighted : false;
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/DifficultyTableView.cs b/OldschoolBeatSaber/Behaviours/UI/DifficultyTableView.cs
new file mode 100644
index 0000000..66eb613
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/DifficultyTableView.cs
@@ -0,0 +1,72 @@
+using HMUI;
+using System;
+using UnityEngine;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+#pragma warning disable CS0436
+    public class DifficultyTableView : MonoBehaviour, TableView.IDataSource
+#pragma warning restore CS0436
+    {
+        [SerializeField] private TableView _tableView;
+        [SerializeField] private DifficultyTableCell _cellPrefab;
+        [SerializeField] private float _cellHeight = 8f;
+
+		private IDifficultyBeatmap[] _difficultyLevels;
+
+		public event Action<DifficultyTableView, int> DifficultyTableViewDidSelectRow;
+
+		protected void Start()
+		{
+			_tableView.DidSelectRowEvent += HandleDidSelectRowEvent;
+		}
+
+		public float RowHeight()
+		{
+			return _cellHeight;
+		}
+
+		public int NumberOfRows()
+		{
+			if (_difficultyLevels == null)
+				return 0;
+
+			return _difficultyLevels.Length;
+		}
+
+		public TableCell CellForRow(int row)
+		{
+			var difficultyTableCell = _tableView.DequeueReusableCellForIdentifier("Cell") as DifficultyTableCell;
+			if (difficultyTableCell == null)
+			{
+				difficultyTableCell = UnityEngine.Object.Instantiate(_cellPrefab);
+				difficultyTableCell.reuseIdentifier = "Cell";
+			}
+			difficultyTableCell.DifficultyText = _difficultyLevels[row].difficulty.Name();
+			return difficultyTableCell;
+		}
+
+		private void HandleDidSelectRowEvent(TableView tableView, int row)
+		{
+			if (DifficultyTableViewDidSelectRow != null)
+				DifficultyTableViewDidSelectRow(this, row);
+		}
+
+		public void SetDifficultyLevels(IDifficultyBeatmap[] difficultyLevels)
+		{
+			_difficultyLevels = difficultyLevels;
+
+			_tableView.dataSource = this;
+		}
+
+		public void SelectRow(int row)
+		{
+			_tableView.SelectRow(row);
+		}
+
+		public void ClearSelection()
+		{
+			_tableView.ClearSelection();
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/DifficultyViewController.cs b/OldschoolBeatSaber/Behaviours/UI/DifficultyViewController.cs
new file mode 100644
index 0000000..68fc7ef
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/DifficultyViewController.cs
@@ -0,0 +1,117 @@
+using System;
+using UnityEngine;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class DifficultyViewController : VRUIViewController
+    {
+        [SerializeField] private DifficultyTableView _difficultyTableView;
+
+        private bool _firstTimeActivated = true;
+
+        private bool _difficultySelected;
+        private IDifficultyBeatmap[] _difficultyLevels;
+        private BeatmapDifficulty _preferredDifficulty = BeatmapDifficulty.Normal;
+
+        public BeatmapDifficulty Difficulty { get; private set; }
+
+        public Action<DifficultyViewController> DidSelectDifficultyEvent;
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            if (_firstTimeActivated)
+            {
+                _firstTimeActivated = false;
+
+                _difficultyTableView.DifficultyTableViewDidSelectRow += HandleDifficultyTableViewDidSelectRow;
+            }
+
+            if (movingToParentController)
+            {
+                _difficultySelected = false;
+                _difficultyTableView.SetDifficultyLevels(_difficultyLevels);
+                _difficultyTableView.ClearSelection();
+
+                RecenterTableView();
+            }
+        }
+
+        private int GetClosestDifficultyIndex(BeatmapDifficulty difficulty)
+        {
+            var result = -1;
+
+            foreach (var difficultyLevel in _difficultyLevels)
+            {
+                if (difficulty < difficultyLevel.difficulty)
+                    break;
+
+                result++;
+            }
+
+            if (result == -1)
+                result = 0;
+
+            return result;
+        }
+
+        private int GetDifficultyLevelIndex(BeatmapDifficulty difficulty)
+        {
+            for (var i = 0; i < _difficultyLevels.Length; i++)
+            {
+                if (_difficultyLevels[i].difficulty == difficulty)
+                    return i;
+            }
+
+            return -1;
+        }
+
+        private void RecenterTableView()
+        {
+            var difficultyTableRectTransform = _difficultyTableView.GetComponent<RectTransform>();
+            var y = (rectTransform.rect.height - _difficultyTableView.NumberOfRows() * _difficultyTableView.RowHeight()) * .5f;
+            difficultyTableRectTransform.offsetMin = new(difficultyTableRectTransform.offsetMin.x, y);
+            difficultyTableRectTransform.offsetMax = new(difficultyTableRectTransform.offsetMax.x, 0f - y);
+        }
+
+        private void HandleDifficultyTableViewDidSelectRow(DifficultyTableView tableView, int row)
+        {
+            Difficulty = (_preferredDifficulty = _difficultyLevels[row].difficulty);
+            _difficultySelected = true;
+
+            if (DidSelectDifficultyEvent != null)
+                DidSelectDifficultyEvent(this);
+        }
+
+        public void Init(IDifficultyBeatmap[] difficultyLevels)
+        {
+            _difficultyLevels = difficultyLevels;
+        }
+
+        public void SetDifficultyLevels(IDifficultyBeatmap[] difficultyLevels)
+        {
+            _difficultyLevels = difficultyLevels;
+            _difficultyTableView.SetDifficultyLevels(_difficultyLevels);
+
+            if (_difficultySelected)
+            {
+                var closestDifficultyIndex = GetClosestDifficultyIndex(_preferredDifficulty);
+                Difficulty = _difficultyLevels[closestDifficultyIndex].difficulty;
+                _difficultyTableView.SelectRow(closestDifficultyIndex);
+            }
+
+            RecenterTableView();
+        }
+
+        public void SelectDifficulty(BeatmapDifficulty difficulty)
+        {
+            Difficulty = _preferredDifficulty = difficulty;
+            _difficultySelected = true;
+
+            var difficultyLevelIndex = GetDifficultyLevelIndex(difficulty);
+            _difficultyTableView.SelectRow(difficultyLevelIndex);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/DismissableViewController.cs b/OldschoolBeatSaber/Behaviours/UI/DismissableViewController.cs
new file mode 100644
index 0000000..f7fd401
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/DismissableViewController.cs
@@ -0,0 +1,16 @@
+using System;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class DismissableViewController : VRUIViewController
+    {
+        public event Action<DismissableViewController> DidFinishEvent;
+
+        public void DismissButtonWasPressed()
+        {
+            if (DidFinishEvent != null)
+                DidFinishEvent(this);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/GameplayModeIndicator.cs b/OldschoolBeatSaber/Behaviours/UI/GameplayModeIndicator.cs
new file mode 100644
index 0000000..dafe493
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/GameplayModeIndicator.cs
@@ -0,0 +1,32 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class GameplayModeIndicator : MonoBehaviour
+    {
+        [SerializeField] private Image[] _icons;
+        [Space]
+        [SerializeField] private GameplayMode[] _gameplayModes;
+        [SerializeField] private Sprite[] _gameplayIcons;
+
+        public void SetupForGameplayMode(GameplayMode gameplayMode)
+        {
+            for (var i = 0; i < _icons.Length; i++)
+                _icons[i].gameObject.SetActive(false);
+
+            for (var i = 0; i < _gameplayModes.Length; i++)
+            {
+                if (_gameplayModes[i] == gameplayMode)
+                {
+                    for (var j = 0; j < _icons.Length; j++)
+                    {
+                        _icons[j].sprite = _gameplayIcons[(i * 2) + j];
+                        _icons[j].gameObject.SetActive(true);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/GameplayOptionsViewController.cs b/OldschoolBeatSaber/Behaviours/UI/GameplayOptionsViewController.cs
new file mode 100644
index 0000000..13243e0
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/GameplayOptionsViewController.cs
@@ -0,0 +1,65 @@
+using HMUI;
+using UnityEngine;
+using VRUI;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class GameplayOptionsViewController : VRUIViewController
+    {
+        [SerializeField] private Toggle _noEnergyToggle;
+        [SerializeField] private Toggle _mirrorToggle;
+
+        private PlayerDataModel _playerDataModel;
+        private bool _firstTimeActivated = true;
+
+        [Inject]
+        public void Construct(PlayerDataModel playerDataModel)
+        {
+            _playerDataModel = playerDataModel;
+        }
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            if (_firstTimeActivated)
+            {
+                _firstTimeActivated = false;
+
+                _noEnergyToggle.didSwitchEvent += HandleNoEnergyToggleDidSwitch;
+                _mirrorToggle.didSwitchEvent += HandleMirrorToggleDidSwitch;
+            }
+
+            if (beingPresented)
+                RefreshToggles();
+        }
+
+        private void HandleNoEnergyToggleDidSwitch(Toggle toggle, bool isOn)
+        {
+            _playerDataModel.playerData.SetGameplayModifiers(_playerDataModel.playerData.gameplayModifiers.CopyWith(noFailOn0Energy: isOn));
+            _playerDataModel.Save();
+        }
+
+        private void HandleMirrorToggleDidSwitch(Toggle toggle, bool isOn)
+        {
+            _playerDataModel.playerData.SetPlayerSpecificSettings(_playerDataModel.playerData.playerSpecificSettings.CopyWith(leftHanded: isOn));
+            _playerDataModel.Save();
+        }
+
+        private void RefreshToggles()
+        {
+            _noEnergyToggle.isOn = _playerDataModel.playerData.gameplayModifiers.noFailOn0Energy;
+            _mirrorToggle.isOn = _playerDataModel.playerData.playerSpecificSettings.leftHanded;
+        }
+
+        public void DefaultsButtonWasPressed()
+        {
+            _playerDataModel.playerData.SetGameplayModifiers(_playerDataModel.playerData.gameplayModifiers.CopyWith(noFailOn0Energy: false));
+            _playerDataModel.playerData.SetPlayerSpecificSettings(_playerDataModel.playerData.playerSpecificSettings.CopyWith(leftHanded: false));
+            _playerDataModel.Save();
+
+            RefreshToggles();
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/HowToPlayViewController.cs b/OldschoolBeatSaber/Behaviours/UI/HowToPlayViewController.cs
new file mode 100644
index 0000000..6a85325
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/HowToPlayViewController.cs
@@ -0,0 +1,25 @@
+using UnityEngine;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class HowToPlayViewController : VRUIViewController
+    {
+        private bool _firstTimeActivated = true;
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            if (_firstTimeActivated)
+            {
+                _firstTimeActivated = false;
+
+                rectTransform.anchorMin = Vector2.zero;
+                rectTransform.anchorMax = Vector2.one;
+                rectTransform.offsetMin = Vector2.zero;
+                rectTransform.offsetMax = Vector2.zero;
+            }
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/MainMenuViewController.cs b/OldschoolBeatSaber/Behaviours/UI/MainMenuViewController.cs
new file mode 100644
index 0000000..db57d41
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/MainMenuViewController.cs
@@ -0,0 +1,80 @@
+using OldschoolBeatSaber.Interfaces;
+using OldschoolBeatSaber.Managers;
+using System;
+using UnityEngine;
+using VRUI;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class MainMenuViewController : VRUIViewController, IOnActivate
+    {
+        [SerializeField] private HowToPlayViewController _howToPlayViewController;
+        [SerializeField] private VRUIViewController _releaseInfoViewController;
+
+        private PlayerDataModel _playerDataModel;
+        private CustomMenuManager _customMenuManager;
+        private MenuTransitionsHelper _menuTransitionsHelper;
+
+        public Action<MainMenuViewController> DidSelectSoloEvent;
+        public Action<MainMenuViewController> DidSelectPartyEvent;
+        public Action<MainMenuViewController> DidSelectAboutEvent;
+        public Action<MainMenuViewController> DidSelectSettingsEvent;
+
+        [Inject]
+        public void Construct(PlayerDataModel playerDataModel, CustomMenuManager customMenuManager,
+            MenuTransitionsHelper menuTransitionsHelper)
+        {
+            _playerDataModel = playerDataModel;
+            _customMenuManager = customMenuManager;
+            _menuTransitionsHelper = menuTransitionsHelper;
+        }
+
+        public void OnActivate(DiContainer container)
+        {
+            container.Inject(this);
+        }
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            screen.screenSystem.leftScreen.SetRootViewController(_howToPlayViewController);
+            screen.screenSystem.rightScreen.SetRootViewController(_releaseInfoViewController);
+        }
+
+        public void SoloButtonPressed()
+        {
+            if (DidSelectSoloEvent != null)
+                DidSelectSoloEvent(this);
+        }
+
+        public void PartyButtonPressed()
+        {
+            if (DidSelectPartyEvent != null)
+                DidSelectPartyEvent(this);
+        }
+
+        public void TutorialButtonPressed()
+        {
+            _menuTransitionsHelper.StartTutorial(_playerDataModel.playerData.playerSpecificSettings);
+        }
+
+        public void AboutButtonPressed()
+        {
+            if (DidSelectAboutEvent != null)
+                DidSelectAboutEvent(this);
+        }
+
+        public void SettingsButtonPressed()
+        {
+            if (DidSelectSettingsEvent != null)
+                DidSelectSettingsEvent(this);
+        }
+
+        public void QuitGameButtonPressed()
+        {
+            _customMenuManager.EnableCustomMenu(false);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/MenuMasterViewController.cs b/OldschoolBeatSaber/Behaviours/UI/MenuMasterViewController.cs
new file mode 100644
index 0000000..a961394
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/MenuMasterViewController.cs
@@ -0,0 +1,165 @@
+using OldschoolBeatSaber.Interfaces;
+using Polyglot;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using VRUI;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class MenuMasterViewController : VRUIViewController, IOnActivate
+    {
+        [SerializeField] private MainMenuViewController _mainMenuViewController;
+        [SerializeField] private SoloModeSelectionViewController _soloModeSelectionViewController;
+        [SerializeField] private SongSelectionMasterViewController _songSelectionMasterViewController;
+        [SerializeField] private DismissableViewController _comingSoonViewController;
+        [SerializeField] private DismissableViewController _aboutViewController;
+        [SerializeField] private ResultsViewController _resultsViewController;
+
+        private bool _firstTimeActivated = true;
+
+        private PlayerDataModel _playerDataModel;
+        private BeatmapLevelsModel _beatmapLevelsModel;
+        private MenuTransitionsHelper _menuTransitionsHelper;
+        private PlatformLeaderboardsModel _platformLeaderboardsModel;
+        private IDifficultyBeatmap _lastPlayedDifficultyLevel;
+
+        [Inject]
+        public void Construct(PlayerDataModel playerDataModel, BeatmapLevelsModel beatmapLevelsModel,
+            MenuTransitionsHelper menuTransitionsHelper, PlatformLeaderboardsModel platformLeaderboardsModel)
+        {
+            _playerDataModel = playerDataModel;
+            _beatmapLevelsModel = beatmapLevelsModel;
+            _menuTransitionsHelper = menuTransitionsHelper;
+            _platformLeaderboardsModel = platformLeaderboardsModel;
+        }
+
+        public void OnActivate(DiContainer container)
+        {
+            container.Inject(this);
+        }
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            if (!_firstTimeActivated)
+                return;
+
+            _firstTimeActivated = false;
+
+            _mainMenuViewController.DidSelectSoloEvent += HandleMainMenuViewControllerDidSelectSolo;
+            _mainMenuViewController.DidSelectPartyEvent += HandleMainMenuViewControllerDidSelectParty;
+            _mainMenuViewController.DidSelectAboutEvent += HandleMainMenuViewControllerDidSelectAbout;
+
+            _soloModeSelectionViewController.DidSelectModeEvent += HandleSoloModeSelectionViewControllerDidSelectMode;
+            _soloModeSelectionViewController.DidFinishEvent += HandleSoloModeSelectionViewControllerDidFinish;
+
+            _songSelectionMasterViewController.DidFinishEvent += HandleSongSelectionMasterViewControllerDidFinish;
+            _songSelectionMasterViewController.DidPressPlayButtonEvent += HandleSongSelectionMasterViewControllerDidPressPlayButton;
+
+            _comingSoonViewController.DidFinishEvent += HandleDismissableViewControllerDidFinish;
+            _aboutViewController.DidFinishEvent += HandleDismissableViewControllerDidFinish;
+
+            _resultsViewController.ResultsViewControllerDidPressRestartButtonEvent += HandleResultsViewControllerDidPressRestartButton;
+            _resultsViewController.ResultsViewControllerDidPressContinueButtonEvent += HandleResultsViewControllerDidPressContinueButton;
+
+            PresentModalViewController(_mainMenuViewController, null, true);
+        }
+
+        private IPreviewBeatmapLevel[] GetLevelsForGameplayMode(GameplayMode gameplayMode)
+        {
+            // Get all OSTs & Extras + custom levels, DLC is excluded due to a few issues.
+            var previewBeatmapLevels = new List<IPreviewBeatmapLevel>();
+            previewBeatmapLevels.AddRange(_beatmapLevelsModel.ostAndExtrasPackCollection.beatmapLevelPacks.SelectMany(x => x.beatmapLevelCollection.beatmapLevels));
+            previewBeatmapLevels.AddRange(_beatmapLevelsModel.customLevelPackCollection.beatmapLevelPacks[0].beatmapLevelCollection.beatmapLevels);
+
+            var beatmapCharacteristicName = gameplayMode switch
+            {
+                GameplayMode.SoloOneSaber => "OneSaber",
+                GameplayMode.SoloNoArrows => "NoArrows",
+                _ => "Standard"
+            };
+            return previewBeatmapLevels.Where(x => x.previewDifficultyBeatmapSets.Any(y => y.beatmapCharacteristic.serializedName == beatmapCharacteristicName)).ToArray();
+        }
+
+        private void HandleMainMenuViewControllerDidSelectSolo(MainMenuViewController viewController)
+        {
+            viewController.PresentModalViewController(_soloModeSelectionViewController, null);
+        }
+
+        private void HandleMainMenuViewControllerDidSelectParty(MainMenuViewController viewController)
+        {
+            viewController.PresentModalViewController(_comingSoonViewController, null);
+        }
+
+        private void HandleMainMenuViewControllerDidSelectAbout(MainMenuViewController viewController)
+        {
+            viewController.PresentModalViewController(_aboutViewController, null);
+        }
+
+        private void HandleSoloModeSelectionViewControllerDidSelectMode(SoloModeSelectionViewController viewController, GameplayMode gameplayMode)
+        {
+            _songSelectionMasterViewController.Init(null, BeatmapDifficulty.Normal, GetLevelsForGameplayMode(gameplayMode), true, gameplayMode);
+            viewController.PresentModalViewController(_songSelectionMasterViewController, null);
+        }
+
+        private void HandleSoloModeSelectionViewControllerDidFinish(SoloModeSelectionViewController viewController)
+        {
+            viewController.DismissModalViewController(null);
+        }
+
+        private void HandleSongSelectionMasterViewControllerDidFinish(SongSelectionMasterViewController viewController)
+        {
+            viewController.DismissModalViewController(null);
+        }
+
+        private void HandleSongSelectionMasterViewControllerDidPressPlayButton(SongSelectionMasterViewController viewController)
+        {
+            _lastPlayedDifficultyLevel = viewController.DifficultyLevels.Where(x => x.difficulty == viewController.Difficulty).FirstOrDefault();
+            _menuTransitionsHelper.StartStandardLevel("", _lastPlayedDifficultyLevel, _lastPlayedDifficultyLevel.level, _playerDataModel.playerData.overrideEnvironmentSettings, _playerDataModel.playerData.colorSchemesSettings.GetOverrideColorScheme(), _playerDataModel.playerData.gameplayModifiers, _playerDataModel.playerData.playerSpecificSettings, null, Localization.Get("BUTTON_MENU"), false, false, null, HandleStandardLevelDidFinish, null);
+        }
+
+        private void HandleDismissableViewControllerDidFinish(DismissableViewController viewController)
+        {
+            viewController.DismissModalViewController(null);
+        }
+
+        private void HandleResultsViewControllerDidPressRestartButton(ResultsViewController viewController)
+        {
+            _menuTransitionsHelper.StartStandardLevel("", _lastPlayedDifficultyLevel, _lastPlayedDifficultyLevel.level, _playerDataModel.playerData.overrideEnvironmentSettings, _playerDataModel.playerData.colorSchemesSettings.GetOverrideColorScheme(), _playerDataModel.playerData.gameplayModifiers, _playerDataModel.playerData.playerSpecificSettings, null, Localization.Get("BUTTON_MENU"), false, false, null, HandleStandardLevelDidFinish, null);
+        }
+
+        private void HandleResultsViewControllerDidPressContinueButton(ResultsViewController viewController)
+        {
+            viewController.DismissModalViewController(null);
+        }
+
+        private bool HandleBasicLevelCompletionResults(LevelCompletionResults levelCompletionResults)
+        {
+            return levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Failed && levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Cleared;
+        }
+
+        private void HandleStandardLevelDidFinish(StandardLevelScenesTransitionSetupDataSO standardLevelScenesTransitionSetupData, LevelCompletionResults levelCompletionResults)
+        {
+            var transformedBeatmapData = standardLevelScenesTransitionSetupData.transformedBeatmapData;
+            var difficultyLevel = standardLevelScenesTransitionSetupData.difficultyBeatmap;
+
+            _playerDataModel.playerData.playerAllOverallStatsData.UpdateSoloFreePlayOverallStatsData(levelCompletionResults, difficultyLevel);
+
+            if (HandleBasicLevelCompletionResults(levelCompletionResults))
+            {
+                _playerDataModel.Save();
+                return;
+            }
+
+            LevelCompletionResultsHelper.ProcessScore(_playerDataModel.playerData, _playerDataModel.playerData.GetPlayerLevelStatsData(difficultyLevel), levelCompletionResults, transformedBeatmapData, difficultyLevel, _platformLeaderboardsModel);
+
+            _resultsViewController.Init(levelCompletionResults, difficultyLevel);
+            _songSelectionMasterViewController.PresentModalViewController(_resultsViewController, null, true);
+
+            _playerDataModel.Save();
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/ResultsViewController.cs b/OldschoolBeatSaber/Behaviours/UI/ResultsViewController.cs
new file mode 100644
index 0000000..f522b24
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/ResultsViewController.cs
@@ -0,0 +1,85 @@
+using System;
+using TMPro;
+using UnityEngine;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class ResultsViewController : VRUIViewController
+    {
+        [SerializeField] private GameObject _failedPanel;
+        [SerializeField] private GameObject _clearedPanel;
+        [SerializeField] private TextMeshProUGUI _failedSongNameText;
+        [SerializeField] private TextMeshProUGUI _failedSongAuthorText;
+        [SerializeField] private TextMeshProUGUI _failedDifficultyText;
+        [SerializeField] private TextMeshProUGUI _clearedSongNameText;
+        [SerializeField] private TextMeshProUGUI _clearedSongAuthorText;
+        [SerializeField] private TextMeshProUGUI _clearedDifficultyText;
+        [SerializeField] private TextMeshProUGUI _scoreText;
+        [SerializeField] private TextMeshProUGUI _rankText;
+        [SerializeField] private TextMeshProUGUI _goodCutsPercentageText;
+        [SerializeField] private TextMeshProUGUI _fullComboText;
+        [SerializeField] private TextMeshProUGUI _scoreInfoText;
+
+        private LevelCompletionResults _levelCompletionResults;
+        private IDifficultyBeatmap _difficultyLevel;
+
+        public event Action<ResultsViewController> ResultsViewControllerDidPressContinueButtonEvent;
+        public event Action<ResultsViewController> ResultsViewControllerDidPressRestartButtonEvent;
+
+        public void Init(LevelCompletionResults levelCompletionResults, IDifficultyBeatmap difficultyLevel)
+        {
+            _levelCompletionResults = levelCompletionResults;
+            _difficultyLevel = difficultyLevel;
+        }
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            screen.screenSystem.leftScreen.SetRootViewController(null);
+            screen.screenSystem.rightScreen.SetRootViewController(null);
+
+            _failedPanel.SetActive(_levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Failed);
+            _clearedPanel.SetActive(_levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Cleared);
+
+            if (_levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Failed)
+            {
+                _failedSongNameText.text = _difficultyLevel.level.songName + " <size=80%>" + _difficultyLevel.level.songSubName;
+                _failedSongAuthorText.text = _difficultyLevel.level.songAuthorName;
+                _failedDifficultyText.text = "Difficulty - " + _difficultyLevel.difficulty.Name();
+            }
+            else if (_levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Cleared)
+            {
+                _clearedSongNameText.text = _difficultyLevel.level.songName + " <size=80%>" + _difficultyLevel.level.songSubName;
+                _clearedSongAuthorText.text = _difficultyLevel.level.songAuthorName;
+                _clearedDifficultyText.text = "Difficulty - " + _difficultyLevel.difficulty.Name();
+            }
+
+            _scoreText.text = ScoreFormatter.Format(_levelCompletionResults.modifiedScore);
+            _scoreInfoText.gameObject.SetActive(_levelCompletionResults.energy == 0f);
+
+            if (_levelCompletionResults.energy == 0f)
+                _scoreInfoText.text = "Played with <color=#FF175A>NO ENERGY</color> option.";
+
+            _rankText.text = RankModel.GetRankName(_levelCompletionResults.rank);
+
+            var notesCount = _levelCompletionResults.goodCutsCount + _levelCompletionResults.missedCount + _levelCompletionResults.badCutsCount;
+            _goodCutsPercentageText.text = _levelCompletionResults.goodCutsCount + "<size=50%> / " + notesCount + "</size>";
+
+            _fullComboText.gameObject.SetActive(_levelCompletionResults.fullCombo);
+        }
+
+        public void RestartButtonPressed()
+        {
+            if (ResultsViewControllerDidPressRestartButtonEvent != null)
+                ResultsViewControllerDidPressRestartButtonEvent(this);
+        }
+
+        public void ContinueButtonPressed()
+        {
+            if (ResultsViewControllerDidPressContinueButtonEvent != null)
+                ResultsViewControllerDidPressContinueButtonEvent(this);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/SoloModeSelectionViewController.cs b/OldschoolBeatSaber/Behaviours/UI/SoloModeSelectionViewController.cs
new file mode 100644
index 0000000..b53b7bf
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/SoloModeSelectionViewController.cs
@@ -0,0 +1,54 @@
+using System;
+using UnityEngine;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class SoloModeSelectionViewController : VRUIViewController
+    {
+        [SerializeField] private HowToPlayViewController _howToPlayViewController;
+
+        public Action<SoloModeSelectionViewController, GameplayMode> DidSelectModeEvent;
+        public Action<SoloModeSelectionViewController> DidFinishEvent;
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            screen.screenSystem.leftScreen.SetRootViewController(_howToPlayViewController);
+            screen.screenSystem.rightScreen.SetRootViewController(null);
+        }
+
+        public void FreePlayModeButtonWasPressed()
+        {
+            if (DidSelectModeEvent != null)
+            {
+                DidSelectModeEvent(this, GameplayMode.SoloStandard);
+            }
+        }
+
+        public void OneSaberModeButtonWasPressed()
+        {
+            if (DidSelectModeEvent != null)
+            {
+                DidSelectModeEvent(this, GameplayMode.SoloOneSaber);
+            }
+        }
+
+        public void NoArrowsModeButtonWasPressed()
+        {
+            if (DidSelectModeEvent != null)
+            {
+                DidSelectModeEvent(this, GameplayMode.SoloNoArrows);
+            }
+        }
+
+        public void DismissButtonWasPressed()
+        {
+            if (DidFinishEvent != null)
+            {
+                DidFinishEvent(this);
+            }
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/SongDetailViewController.cs b/OldschoolBeatSaber/Behaviours/UI/SongDetailViewController.cs
new file mode 100644
index 0000000..f7113f8
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/SongDetailViewController.cs
@@ -0,0 +1,34 @@
+using System;
+using TMPro;
+using UnityEngine;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class SongDetailViewController : VRUIViewController
+    {
+        [SerializeField] private TextMeshProUGUI _songNameText;
+        [SerializeField] private TextMeshProUGUI _durationText;
+        [SerializeField] private TextMeshProUGUI _bpmText;
+        [SerializeField] private TextMeshProUGUI _notesCountText;
+        [SerializeField] private TextMeshProUGUI _obstaclesCountText;
+
+        public event Action<SongDetailViewController> DidPressPlayButtonEvent;
+
+        public void PlayButtonPressed()
+        {
+            if (DidPressPlayButtonEvent != null)
+                DidPressPlayButtonEvent(this);
+        }
+
+        public async void SetLevelData(IPreviewBeatmapLevel previewBeatmapLevel, IDifficultyBeatmap difficultyLevel)
+        {
+            var beatmapDataBasicInfo = await difficultyLevel.GetBeatmapDataBasicInfoAsync();
+            _songNameText.text = string.Format("{0}\n<size=80%>{1}</size>", previewBeatmapLevel.songName, previewBeatmapLevel.songSubName);
+            _durationText.text = previewBeatmapLevel.songDuration.MinSecDurationText();
+            _bpmText.text = previewBeatmapLevel.beatsPerMinute.ToString();
+            _notesCountText.text = beatmapDataBasicInfo.cuttableNotesCount.ToString();
+            _obstaclesCountText.text = beatmapDataBasicInfo.obstaclesCount.ToString();
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/SongListTableCell.cs b/OldschoolBeatSaber/Behaviours/UI/SongListTableCell.cs
new file mode 100644
index 0000000..8151e1e
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/SongListTableCell.cs
@@ -0,0 +1,83 @@
+using HMUI;
+using System;
+using System.Threading;
+using TMPro;
+using UnityEngine;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+#pragma warning disable CS0436
+    public class SongListTableCell : TableCell
+#pragma warning restore CS0436
+    {
+        [SerializeField] private UnityEngine.UI.Image _bgImage;
+        [SerializeField] private UnityEngine.UI.Image _highlightImage;
+        [SerializeField] private UnityEngine.UI.Image _coverImage;
+
+        [SerializeField] private TextMeshProUGUI _songNameText;
+        [SerializeField] private TextMeshProUGUI _authorText;
+
+        private CancellationTokenSource _settingDataCancellationTokenSource;
+        private string _settingDataFromLevelId;
+
+        public virtual async void SetDataFromLevelAsync(IPreviewBeatmapLevel previewBeatmapLevel)
+        {
+            if (_settingDataFromLevelId != previewBeatmapLevel.levelID)
+            {
+                try
+                {
+                    _settingDataFromLevelId = previewBeatmapLevel.levelID;
+
+                    if (_settingDataCancellationTokenSource != null)
+                        _settingDataCancellationTokenSource.Cancel();
+
+                    _settingDataCancellationTokenSource = new CancellationTokenSource();
+
+                    _songNameText.text = string.Format("{0}\n<size=80%>{1}</size>", previewBeatmapLevel.songName, previewBeatmapLevel.songSubName).Replace("\n", " ");
+                    _authorText.text = previewBeatmapLevel.songAuthorName;
+
+                    _coverImage.sprite = null;
+                    _coverImage.color = Color.clear;
+
+                    var cancellationToken = _settingDataCancellationTokenSource.Token;
+                    var coverImage = await previewBeatmapLevel.GetCoverImageAsync(cancellationToken);
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    _coverImage.sprite = coverImage;
+                    _coverImage.color = Color.white;
+
+                    cancellationToken = default;
+                }
+                catch (OperationCanceledException)
+                { }
+                finally
+                {
+                    if (_settingDataFromLevelId == previewBeatmapLevel.levelID)
+                        _settingDataFromLevelId = null;
+                }
+            }
+        }
+
+        protected override void SelectionDidChange(TransitionType transitionType)
+        {
+            if (selected)
+            {
+                _highlightImage.enabled = false;
+                _bgImage.enabled = true;
+                _songNameText.color = Color.black;
+                _authorText.color = Color.black;
+            }
+            else
+            {
+                _bgImage.enabled = false;
+                _songNameText.color = Color.white;
+                _authorText.color = new(1f, 1f, 1f, .4f);
+            }
+        }
+
+        protected override void HighlightDidChange(TransitionType transitionType)
+        {
+            _highlightImage.enabled = !selected ? highlighted : false;
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/SongListTableView.cs b/OldschoolBeatSaber/Behaviours/UI/SongListTableView.cs
new file mode 100644
index 0000000..2e60323
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/SongListTableView.cs
@@ -0,0 +1,76 @@
+using HMUI;
+using System;
+using System.Threading;
+using UnityEngine;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+#pragma warning disable CS0436
+    public class SongListTableView : MonoBehaviour, TableView.IDataSource
+#pragma warning restore CS0436
+    {
+        [SerializeField] private TableView _tableView;
+        [SerializeField] private SongListTableCell _cellPrefab;
+        [SerializeField] private float _cellHeight = 12f;
+
+        private IPreviewBeatmapLevel[] _levels;
+
+        public event Action<SongListTableView, int> SongListTableViewDidSelectRow;
+
+        protected void Start()
+        {
+            _tableView.DidSelectRowEvent += HandleDidSelectRowEvent;
+        }
+
+        public float RowHeight()
+        {
+            return _cellHeight;
+        }
+
+        public int NumberOfRows()
+        {
+            if (_levels == null)
+                return 0;
+
+            return _levels.Length;
+        }
+
+        public TableCell CellForRow(int row)
+        {
+            var songListTableCell = _tableView.DequeueReusableCellForIdentifier("Cell") as SongListTableCell;
+            if (songListTableCell == null)
+            {
+                songListTableCell = UnityEngine.Object.Instantiate(_cellPrefab);
+                songListTableCell.reuseIdentifier = "Cell";
+            }
+            songListTableCell.SetDataFromLevelAsync(_levels[row]);
+            return songListTableCell;
+        }
+
+        private void HandleDidSelectRowEvent(TableView tableView, int row)
+        {
+            if (SongListTableViewDidSelectRow != null)
+                SongListTableViewDidSelectRow(this, row);
+        }
+
+        public void SetLevels(IPreviewBeatmapLevel[] levels)
+        {
+            _levels = levels;
+
+            _tableView.dataSource = this;
+            _tableView.ScrollToRow(0, false);
+        }
+
+        public void SelectRow(int row)
+        {
+            _tableView.SelectRow(row);
+            _tableView.ScrollToRow(row, false);
+        }
+
+        public void ClearSelection()
+        {
+            _tableView.ClearSelection();
+            _tableView.ScrollToRow(0, false);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/SongListViewController.cs b/OldschoolBeatSaber/Behaviours/UI/SongListViewController.cs
new file mode 100644
index 0000000..6cead7b
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/SongListViewController.cs
@@ -0,0 +1,66 @@
+using System;
+using UnityEngine;
+using VRUI;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class SongListViewController : VRUIViewController
+    {
+        [SerializeField] private SongListTableView _songListTableView;
+
+        private bool _firstTimeActivated = true;
+
+        private IPreviewBeatmapLevel[] _beatmapLevels;
+
+        public string LevelId { get; private set; }
+        public event Action<SongListViewController> DidSelectSongEvent;
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            if (_firstTimeActivated)
+            {
+                _firstTimeActivated = false;
+
+                _songListTableView.SongListTableViewDidSelectRow += HandleSongListTableViewDidSelectRow;
+            }
+
+            if (movingToParentController)
+            {
+                LevelId = null;
+
+                _songListTableView.SetLevels(_beatmapLevels);
+
+                var listTableParentRectTransform = _songListTableView.transform.parent.gameObject.GetComponent<RectTransform>();
+                var value = (listTableParentRectTransform.rect.height - _songListTableView.NumberOfRows() * _songListTableView.RowHeight()) * .5f;
+
+                var listTableRectTransform = _songListTableView.GetComponent<RectTransform>();
+                listTableRectTransform.offsetMin = new(listTableRectTransform.offsetMin.x, Mathf.Max(value, 0f));
+                listTableRectTransform.offsetMax = new(listTableRectTransform.offsetMax.x, Mathf.Min(0f - value, 0f));
+
+                _songListTableView.ClearSelection();
+            }
+        }
+
+        private void HandleSongListTableViewDidSelectRow(SongListTableView tableView, int row)
+        {
+            LevelId = _beatmapLevels[row].levelID;
+
+            if (DidSelectSongEvent != null)
+                DidSelectSongEvent(this);
+        }
+
+        public void Init(IPreviewBeatmapLevel[] levelsStaticData)
+        {
+            _beatmapLevels = levelsStaticData;
+        }
+
+        public void SelectSong(int songIndex)
+        {
+            LevelId = _beatmapLevels[songIndex].levelID;
+
+            _songListTableView.SelectRow(songIndex);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/SongSelectionMasterViewController.cs b/OldschoolBeatSaber/Behaviours/UI/SongSelectionMasterViewController.cs
new file mode 100644
index 0000000..65c020f
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/SongSelectionMasterViewController.cs
@@ -0,0 +1,216 @@
+using OldschoolBeatSaber.Interfaces;
+using System;
+using System.Linq;
+using System.Threading;
+using UnityEngine;
+using VRUI;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class SongSelectionMasterViewController : VRUINavigationController, IOnActivate
+    {
+        [SerializeField] private GameObject _dismissButton;
+        [SerializeField] private GameplayModeIndicator _gameplayModeIndicator;
+        [SerializeField] private SongListViewController _songListViewController;
+        [SerializeField] private DifficultyViewController _difficultyViewController;
+        [SerializeField] private SongDetailViewController _songDetailViewController;
+        [SerializeField] private GameplayOptionsViewController _gameplayOptionsViewController;
+        [SerializeField] private VRUIViewController _leaderboardsComingSoonViewController;
+
+        private bool _firstTimeActivated = true;
+
+        private SongPreviewPlayer _songPreviewPlayer;
+        private AudioClipAsyncLoader _audioClipAsyncLoader;
+        private PerceivedLoudnessPerLevelModel _perceivedLoudnessPerLevelModel;
+        private BeatmapLevelsModel _beatmapLevelsModel;
+
+        private string _levelId;
+        private bool _difficultySelected;
+        private IBeatmapLevel _beatmapLevel;
+        private BeatmapDifficulty _difficulty;
+        private IDifficultyBeatmap[] _difficultyLevels;
+        private IPreviewBeatmapLevel[] _beatmapLevels;
+
+        private GameplayMode _gameplayMode;
+
+        public BeatmapDifficulty Difficulty => _difficulty;
+        public IDifficultyBeatmap[] DifficultyLevels => _difficultyLevels;
+
+        public event Action<SongSelectionMasterViewController> DidFinishEvent;
+        public event Action<SongSelectionMasterViewController> DidPressPlayButtonEvent;
+
+        [Inject]
+        public void Construct(SongPreviewPlayer songPreviewPlayer, AudioClipAsyncLoader audioClipAsyncLoader,
+            PerceivedLoudnessPerLevelModel perceivedLoudnessPerLevelModel, BeatmapLevelsModel beatmapLevelsModel)
+        {
+            _songPreviewPlayer = songPreviewPlayer;
+            _audioClipAsyncLoader = audioClipAsyncLoader;
+            _perceivedLoudnessPerLevelModel = perceivedLoudnessPerLevelModel;
+            _beatmapLevelsModel = beatmapLevelsModel;
+        }
+
+        public void OnActivate(DiContainer container)
+        {
+            container.Inject(this);
+        }
+
+        protected override void DidActivate()
+        {
+            base.DidActivate();
+
+            if (_firstTimeActivated)
+            {
+                _firstTimeActivated = false;
+
+                _songListViewController.DidSelectSongEvent += HandleSongListDidSelectSong;
+                _difficultyViewController.DidSelectDifficultyEvent += HandleDifficultyViewControllerDidSelectDifficulty;
+                _songDetailViewController.DidPressPlayButtonEvent += HandleSongDetailViewControllerDidPressPlayButton;
+            }
+
+            if (beingPresented)
+            {
+                PushViewController(_songListViewController, true);
+
+                _gameplayModeIndicator.SetupForGameplayMode(_gameplayMode);
+
+                if (_levelId != null)
+                {
+                    _difficultySelected = true;
+
+                    _difficultyViewController.Init(_difficultyLevels);
+
+                    PushViewController(_difficultyViewController, true);
+                    PushViewController(_songDetailViewController, true);
+
+                    _songListViewController.SelectSong(GetSelectedSongIndex());
+                    _difficultyViewController.SelectDifficulty(_difficulty);
+
+                    RefreshSongDetail();
+                }
+            }
+
+            screen.screenSystem.leftScreen.SetRootViewController(_gameplayOptionsViewController);
+            screen.screenSystem.rightScreen.SetRootViewController(_leaderboardsComingSoonViewController);
+        }
+
+        protected override void DidDeactivate()
+        {
+            base.DidDeactivate();
+
+            if (beingDismissed)
+            {
+                _levelId = null;
+                _difficultySelected = false;
+                _songPreviewPlayer.CrossfadeToDefault();
+            }
+        }
+
+        public void DismissButtonWasPressed()
+        {
+            if (DidFinishEvent != null)
+                DidFinishEvent(this);
+        }
+
+        private int GetSelectedSongIndex()
+        {
+            for (var i = 0; i < _beatmapLevels.Length; i++)
+            {
+                if (_beatmapLevels[i].levelID == _levelId)
+                    return i;
+            }
+
+            return -1;
+        }
+
+        private IPreviewBeatmapLevel GetPreviewBeatmapLevelForSelectedSong()
+        {
+            var selectedSongIndex = GetSelectedSongIndex();
+            if (selectedSongIndex != -1)
+                return _beatmapLevels[selectedSongIndex];
+
+            return null;
+        }
+
+        private string GetBeatmapCharacteristicNameForGameplayMode()
+        {
+            return _gameplayMode switch
+            {
+                GameplayMode.SoloOneSaber => "OneSaber",
+                GameplayMode.SoloNoArrows => "NoArrows",
+                _ => "Standard"
+            };
+        }
+
+        private async void HandleSongListDidSelectSong(SongListViewController songListViewController)
+        {
+            var wasLevelIdNull = _levelId == null;
+            _levelId = songListViewController.LevelId;
+            var previewBeatmapLevel = GetPreviewBeatmapLevelForSelectedSong();
+
+            var audioClip = await _audioClipAsyncLoader.LoadPreview(previewBeatmapLevel);
+            var musicVolume = _perceivedLoudnessPerLevelModel.GetLoudnessCorrectionByLevelId(previewBeatmapLevel.levelID);
+            _songPreviewPlayer.CrossfadeTo(audioClip, musicVolume, previewBeatmapLevel.previewStartTime, previewBeatmapLevel.previewDuration, () =>
+            {
+                _audioClipAsyncLoader.UnloadPreview(previewBeatmapLevel);
+            });
+
+            // TODO: Cancellation tokens.
+            var beatmapLevelResult = await _beatmapLevelsModel.GetBeatmapLevelAsync(_levelId, CancellationToken.None);
+            _beatmapLevel = beatmapLevelResult.beatmapLevel;
+            var difficultyBeatmapSet = _beatmapLevel.beatmapLevelData.difficultyBeatmapSets
+                .Where(x => x.beatmapCharacteristic.serializedName == GetBeatmapCharacteristicNameForGameplayMode()).FirstOrDefault();
+            _difficultyLevels = difficultyBeatmapSet.difficultyBeatmaps.ToArray();
+            if (wasLevelIdNull)
+            {
+                _difficultyViewController.Init(_difficultyLevels);
+                PushViewController(_difficultyViewController);
+            }
+
+            _difficultyViewController.SetDifficultyLevels(_difficultyLevels);
+            if (_difficultySelected)
+                RefreshSongDetail();
+        }
+
+        private void HandleDifficultyViewControllerDidSelectDifficulty(DifficultyViewController difficultyViewController)
+        {
+            var wasDifficultySelected = !_difficultySelected;
+            _difficultySelected = true;
+            _difficulty = difficultyViewController.Difficulty;
+
+            if (wasDifficultySelected)
+                PushViewController(_songDetailViewController);
+
+            RefreshSongDetail();
+        }
+
+        private void HandleSongDetailViewControllerDidPressPlayButton(SongDetailViewController viewController)
+        {
+            if (DidPressPlayButtonEvent != null)
+                DidPressPlayButtonEvent(this);
+        }
+
+        public void Init(string levelId, BeatmapDifficulty difficulty, IPreviewBeatmapLevel[] beatmapLevels, bool showDismissButton, GameplayMode gameplayMode)
+        {
+            _levelId = levelId;
+            _difficulty = difficulty;
+            _beatmapLevels = beatmapLevels;
+
+            _gameplayMode = gameplayMode;
+
+            if (GetSelectedSongIndex() == -1)
+                _levelId = null;
+
+            _songListViewController.Init(_beatmapLevels);
+
+            _dismissButton.SetActive(showDismissButton);
+        }
+
+        public void RefreshSongDetail()
+        {
+            var previewBeatmapLevel = GetPreviewBeatmapLevelForSelectedSong();
+            var difficultyLevel = _difficultyLevels.Where(x => x.difficulty == _difficulty).FirstOrDefault();
+            _songDetailViewController.SetLevelData(previewBeatmapLevel, difficultyLevel);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/TMP_Modifier.cs b/OldschoolBeatSaber/Behaviours/UI/TMP_Modifier.cs
new file mode 100644
index 0000000..c9f5183
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/TMP_Modifier.cs
@@ -0,0 +1,25 @@
+using OldschoolBeatSaber.Interfaces;
+using TMPro;
+using UnityEngine;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    /// <summary>
+    /// Required due to a really dumb Unity serialization issue.
+    /// </summary>
+    public class TMP_Modifier : MonoBehaviour, IOnActivate
+    {
+        [SerializeField] private TextAlignmentOptions _alignment = TextAlignmentOptions.Center;
+
+        // This used to be run on Awake instead of OnActivate, but this is probably better for performance. 
+        public void OnActivate(DiContainer container)
+        {
+            var tmpText = GetComponent<TMP_Text>();
+            if (tmpText == null)
+                return;
+
+            tmpText.alignment = _alignment;
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Behaviours/UI/TMP_ZeroAlphaWrite.cs b/OldschoolBeatSaber/Behaviours/UI/TMP_ZeroAlphaWrite.cs
new file mode 100644
index 0000000..43abf0c
--- /dev/null
+++ b/OldschoolBeatSaber/Behaviours/UI/TMP_ZeroAlphaWrite.cs
@@ -0,0 +1,25 @@
+using OldschoolBeatSaber.Interfaces;
+using UnityEngine;
+using Zenject;
+
+namespace OldschoolBeatSaber.Behaviours.UI
+{
+    public class TMP_ZeroAlphaWrite : MonoBehaviour, IOnActivate
+    {
+        [SerializeField] private Material[] _materials;
+
+        private static Shader _zeroAlphaWriteShader;
+
+        // This also used to be run on Awake instead of OnActivate, but this is probably better for performance. 
+        public void OnActivate(DiContainer container)
+        {
+            if (_zeroAlphaWriteShader == null)
+                _zeroAlphaWriteShader = Shader.Find("TextMeshPro/Mobile/Distance Field Zero Alpha Write");
+
+            foreach (var material in _materials)
+            {
+                material.shader = _zeroAlphaWriteShader;
+            }
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Directory.Build.props b/OldschoolBeatSaber/Directory.Build.props
new file mode 100644
index 0000000..ce46b94
--- /dev/null
+++ b/OldschoolBeatSaber/Directory.Build.props
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- This file contains project properties used by the build. -->
+<Project>
+	<PropertyGroup>
+		<ImportBSMTTargets>True</ImportBSMTTargets>
+		<BSMTProjectType>BSIPA</BSMTProjectType>
+	</PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/OldschoolBeatSaber/Installers/MenuInstaller.cs b/OldschoolBeatSaber/Installers/MenuInstaller.cs
new file mode 100644
index 0000000..6d0a4ec
--- /dev/null
+++ b/OldschoolBeatSaber/Installers/MenuInstaller.cs
@@ -0,0 +1,15 @@
+using OldschoolBeatSaber.Managers;
+using Zenject;
+
+namespace OldschoolBeatSaber.Installers
+{
+    internal class MenuInstaller : Installer
+    {
+        public override void InstallBindings()
+        {
+            // Managers
+            Container.BindInterfacesAndSelfTo<CustomMenuManager>().AsSingle();
+            Container.BindInterfacesTo<MenuButtonManager>().AsSingle();
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Interfaces/IOnActivate.cs b/OldschoolBeatSaber/Interfaces/IOnActivate.cs
new file mode 100644
index 0000000..158a3d5
--- /dev/null
+++ b/OldschoolBeatSaber/Interfaces/IOnActivate.cs
@@ -0,0 +1,9 @@
+using Zenject;
+
+namespace OldschoolBeatSaber.Interfaces
+{
+    public interface IOnActivate
+    {
+        void OnActivate(DiContainer container);
+    }
+}
diff --git a/OldschoolBeatSaber/Interfaces/IOnDeactivate.cs b/OldschoolBeatSaber/Interfaces/IOnDeactivate.cs
new file mode 100644
index 0000000..ceab41c
--- /dev/null
+++ b/OldschoolBeatSaber/Interfaces/IOnDeactivate.cs
@@ -0,0 +1,7 @@
+namespace OldschoolBeatSaber.Interfaces
+{
+    public interface IOnDeactivate
+    {
+        void OnDeactivate();
+    }
+}
diff --git a/OldschoolBeatSaber/Managers/CustomMenuManager.cs b/OldschoolBeatSaber/Managers/CustomMenuManager.cs
new file mode 100644
index 0000000..b3471aa
--- /dev/null
+++ b/OldschoolBeatSaber/Managers/CustomMenuManager.cs
@@ -0,0 +1,116 @@
+using HMUI;
+using IPA.Utilities;
+using OldschoolBeatSaber.Interfaces;
+using OldschoolBeatSaber.Utilities;
+using UnityEngine;
+using Zenject;
+
+namespace OldschoolBeatSaber.Managers
+{
+    public class CustomMenuManager : IInitializable
+    {
+        private static readonly FieldAccessor<SongPreviewPlayer, AudioClip>.Accessor _defaultAudioClipAccessor =
+            FieldAccessor<SongPreviewPlayer, AudioClip>.GetAccessor("_defaultAudioClip");
+
+        private readonly DiContainer _container;
+        private readonly HierarchyManager _hierarchyManager;
+        private readonly MenuEnvironmentManager _menuEnvironmentManager;
+        private SongPreviewPlayer _songPreviewPlayer;
+
+        private bool _didInitialize;
+        private GameObject _menuCoreGameObject;
+        private GameObject _menuEnvironmentGameObject;
+        private AudioClip _originalMenuAudioClip;
+
+        public CustomMenuManager(DiContainer container, HierarchyManager hierarchyManager,
+            MenuEnvironmentManager menuEnvironmentManager, SongPreviewPlayer songPreviewPlayer)
+        {
+            _container = container;
+            _hierarchyManager = hierarchyManager;
+            _menuEnvironmentManager = menuEnvironmentManager;
+            _songPreviewPlayer = songPreviewPlayer;
+        }
+
+        public void Initialize()
+        {
+            Plugin.MenuCorePrefab.ReplaceMaterialsInChildren();
+            Plugin.MenuEnvironmentPrefab.ReplaceMaterialsInChildren();
+
+            _menuCoreGameObject = _container.InstantiatePrefab(Plugin.MenuCorePrefab);
+            _menuEnvironmentGameObject = _container.InstantiatePrefab(Plugin.MenuEnvironmentPrefab);
+
+            _originalMenuAudioClip = _defaultAudioClipAccessor(ref _songPreviewPlayer);
+
+            // We need to toggle the custom menu at least once.
+            EnableCustomMenu(true);
+            EnableCustomMenu(false);
+
+            _didInitialize = true;
+        }
+
+        public void EnableCustomMenu(bool enabled, bool onlyScreenSystem = false)
+        {
+            if (enabled)
+            {
+                if (_didInitialize)
+                    _hierarchyManager.gameObject.SetActive(false);
+
+                foreach (IOnActivate onActivate in _menuCoreGameObject.GetComponentsInChildren<IOnActivate>(true))
+                {
+                    onActivate.OnActivate(_container);
+                }
+
+                if (!onlyScreenSystem)
+                {
+                    if (_didInitialize)
+                        _menuEnvironmentManager.ShowEnvironmentType(MenuEnvironmentManager.MenuEnvironmentType.None);
+
+                    foreach (IOnActivate onActivate in _menuEnvironmentGameObject.GetComponentsInChildren<IOnActivate>(true))
+                    {
+                        onActivate.OnActivate(_container);
+                    }
+
+                    _menuEnvironmentGameObject.SetActive(true);
+                }
+
+                _menuCoreGameObject.SetActive(true);
+
+                SetDefaultAudioClip(Plugin.MenuAudioClip);
+            }
+            else
+            {
+                if (_didInitialize)
+                    _hierarchyManager.gameObject.SetActive(true);
+
+                foreach (IOnDeactivate onDeactivate in _menuCoreGameObject.GetComponentsInChildren<IOnDeactivate>(true))
+                {
+                    onDeactivate.OnDeactivate();
+                }
+
+                if (!onlyScreenSystem)
+                {
+                    if (_didInitialize)
+                        _menuEnvironmentManager.ShowEnvironmentType(MenuEnvironmentManager.MenuEnvironmentType.Default);
+
+                    foreach (IOnDeactivate onDeactivate in _menuEnvironmentGameObject.GetComponentsInChildren<IOnDeactivate>(true))
+                    {
+                        onDeactivate.OnDeactivate();
+                    }
+
+                    _menuEnvironmentGameObject.SetActive(false);
+                }
+
+                _menuCoreGameObject.SetActive(false);
+
+                SetDefaultAudioClip(_originalMenuAudioClip);
+            }
+        }
+
+        private void SetDefaultAudioClip(AudioClip audioClip)
+        {
+            _songPreviewPlayer.enabled = false;
+            _defaultAudioClipAccessor(ref _songPreviewPlayer) = audioClip;
+            _songPreviewPlayer.enabled = true;
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/Managers/MenuButtonManager.cs b/OldschoolBeatSaber/Managers/MenuButtonManager.cs
new file mode 100644
index 0000000..26437fe
--- /dev/null
+++ b/OldschoolBeatSaber/Managers/MenuButtonManager.cs
@@ -0,0 +1,42 @@
+using BeatSaberMarkupLanguage;
+using BeatSaberMarkupLanguage.MenuButtons;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Zenject;
+
+namespace OldschoolBeatSaber.Managers
+{
+    internal class MenuButtonManager : IInitializable, IDisposable
+    {
+        private const string BUTTONTEXT = "Oldschool Beat Saber";
+        private const string BUTTONHINT = "Go back in time.";
+
+        private readonly CustomMenuManager _customMenuManager;
+        private readonly MenuButton _menuButton;
+
+        public MenuButtonManager(CustomMenuManager customMenuManager)
+        {
+            _customMenuManager = customMenuManager;
+            _menuButton = new MenuButton(BUTTONTEXT, BUTTONHINT, OnMenuButtonClick);
+        }
+
+        public async void Initialize()
+        {
+            await Task.Run(() => Thread.Sleep(100));
+
+            MenuButtons.instance.RegisterButton(_menuButton);
+        }
+
+        public void Dispose()
+        {
+            if (BSMLParser.IsSingletonAvailable && MenuButtons.IsSingletonAvailable)
+                MenuButtons.instance.UnregisterButton(_menuButton);
+        }
+
+        private void OnMenuButtonClick()
+        {
+            _customMenuManager.EnableCustomMenu(true);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/OldschoolBeatSaber.csproj b/OldschoolBeatSaber/OldschoolBeatSaber.csproj
new file mode 100644
index 0000000..08e41f5
--- /dev/null
+++ b/OldschoolBeatSaber/OldschoolBeatSaber.csproj
@@ -0,0 +1,205 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{C24FA7EE-EBF3-4CBF-9237-20B7A5094797}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>OldschoolBeatSaber</RootNamespace>
+    <AssemblyName>OldschoolBeatSaber</AssemblyName>
+    <LangVersion>9.0</LangVersion>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>portable</DebugType>
+    <LocalRefsDir Condition="Exists('..\Refs')">..\Refs</LocalRefsDir>
+    <BeatSaberDir>$(LocalRefsDir)</BeatSaberDir>
+    <AppOutputBase>$(MSBuildProjectDirectory)\</AppOutputBase>
+    <!--<PathMap>$(AppOutputBase)=X:\$(AssemblyName)\</PathMap>-->
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="$(DefineConstants.Contains('CIBuild')) OR '$(NCrunch)' == '1'">
+    <DisableCopyToPlugins>True</DisableCopyToPlugins>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(NCrunch)' == '1'">
+    <DisableCopyToPlugins>True</DisableCopyToPlugins>
+    <DisableZipRelease>True</DisableZipRelease>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="BeatmapCore">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\BeatmapCore.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="BSML">
+      <HintPath>$(BeatSaberDir)\Plugins\BSML.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Colors">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Colors.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="GameplayCore">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\GameplayCore.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HMRendering">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\HMRendering.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Polyglot">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Polyglot.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="SiraUtil">
+      <HintPath>$(BeatSaberDir)\Plugins\SiraUtil.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="Main">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Main.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HMLib">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\HMLib.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HMUI">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\HMUI.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="IPA.Loader">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\IPA.Loader.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Unity.TextMeshPro">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Unity.TextMeshPro.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.AssetBundleModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.AssetBundleModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.AudioModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.AudioModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.CoreModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.CoreModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.TextRenderingModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.TextRenderingModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UI.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.UIElementsModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UIElementsModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.UIModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UIModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.UnityWebRequestAudioModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UnityWebRequestAudioModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="UnityEngine.UnityWebRequestModule">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UnityWebRequestModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Zenject">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Zenject.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Zenject-usage">
+      <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Zenject-usage.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Behaviours\FlickeringSign.cs" />
+    <Compile Include="Behaviours\MenuFogParams.cs" />
+    <Compile Include="Behaviours\MenuSceneSetup.cs" />
+    <Compile Include="Behaviours\UI\DifficultyTableCell.cs" />
+    <Compile Include="Behaviours\UI\DifficultyTableView.cs" />
+    <Compile Include="Behaviours\UI\DifficultyViewController.cs" />
+    <Compile Include="Behaviours\UI\DismissableViewController.cs" />
+    <Compile Include="Behaviours\UI\GameplayModeIndicator.cs" />
+    <Compile Include="Behaviours\UI\GameplayOptionsViewController.cs" />
+    <Compile Include="Behaviours\UI\HowToPlayViewController.cs" />
+    <Compile Include="Behaviours\UI\MainMenuViewController.cs" />
+    <Compile Include="Behaviours\UI\MenuMasterViewController.cs" />
+    <Compile Include="Behaviours\UI\ResultsViewController.cs" />
+    <Compile Include="Behaviours\UI\SoloModeSelectionViewController.cs" />
+    <Compile Include="Behaviours\UI\SongDetailViewController.cs" />
+    <Compile Include="Behaviours\UI\SongListTableCell.cs" />
+    <Compile Include="Behaviours\UI\SongListTableView.cs" />
+    <Compile Include="Behaviours\UI\SongListViewController.cs" />
+    <Compile Include="Behaviours\UI\SongSelectionMasterViewController.cs" />
+    <Compile Include="Behaviours\UI\TMP_Modifier.cs" />
+    <Compile Include="Behaviours\UI\TMP_ZeroAlphaWrite.cs" />
+    <Compile Include="Behaviours\UI\ButtonClickSignal.cs" />
+    <Compile Include="Installers\MenuInstaller.cs" />
+    <Compile Include="Interfaces\IOnDeactivate.cs" />
+    <Compile Include="Interfaces\IOnActivate.cs" />
+    <Compile Include="Managers\CustomMenuManager.cs" />
+    <Compile Include="Managers\MenuButtonManager.cs" />
+    <Compile Include="Scripts\GameplayMode.cs" />
+    <Compile Include="Scripts\HMUI\Image.cs" />
+    <Compile Include="Scripts\HMUI\SetPropertyUtility.cs" />
+    <Compile Include="Scripts\HMUI\TableCell.cs" />
+    <Compile Include="Scripts\HMUI\TableView.cs" />
+    <Compile Include="Scripts\HMUI\Toggle.cs" />
+    <Compile Include="Scripts\NullAllowed.cs" />
+    <Compile Include="Scripts\VRUI\VRUINavigationController.cs" />
+    <Compile Include="Scripts\VRUI\VRUIScreen.cs" />
+    <Compile Include="Scripts\VRUI\VRUIScreenSystem.cs" />
+    <Compile Include="Scripts\VRUI\VRUIViewController.cs" />
+    <Compile Include="Utilities\ResourceUtility.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Behaviours\TubeLight.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="manifest.json" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Directory.Build.props" Condition="Exists('Directory.Build.props')" />
+    <None Include="OldschoolBeatSaber.csproj.user" Condition="Exists('OldschoolBeatSaber.csproj.user')" />
+    <EmbeddedResource Include="Resources\Menu.ogg" />
+    <EmbeddedResource Include="Resources\content" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="BeatSaberModdingTools.Tasks">
+      <Version>2.0.0-beta1</Version>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/OldschoolBeatSaber/Plugin.cs b/OldschoolBeatSaber/Plugin.cs
new file mode 100644
index 0000000..04ddf0a
--- /dev/null
+++ b/OldschoolBeatSaber/Plugin.cs
@@ -0,0 +1,67 @@
+using IPA;
+using IPA.Loader;
+using IPA.Utilities;
+using OldschoolBeatSaber.Installers;
+using OldschoolBeatSaber.Utilities;
+using SiraUtil.Attributes;
+using SiraUtil.Zenject;
+using System.IO;
+using System.Reflection;
+using UnityEngine;
+using IPALogger = IPA.Logging.Logger;
+
+namespace OldschoolBeatSaber
+{
+    [Plugin(RuntimeOptions.DynamicInit), Slog]
+    public class Plugin
+    {
+        internal static string DataPath { get; private set; } = Path.Combine(UnityGame.UserDataPath, "OldschoolBeatSaber");
+        internal static string AudioPath { get; private set; } = Path.Combine(DataPath, "Audio");
+
+        internal static AssetBundle Content { get; private set; }
+
+        internal static GameObject MenuCorePrefab { get; private set; }
+        internal static GameObject MenuEnvironmentPrefab { get; private set; }
+
+        internal static AudioClip MenuAudioClip { get; private set; }
+
+        [Init]
+        public Plugin(IPALogger logger, PluginMetadata metadata, Zenjector zenjector)
+        {
+            // Create our paths.
+            Directory.CreateDirectory(DataPath);
+            Directory.CreateDirectory(AudioPath);
+
+            zenjector.UseLogger(logger);
+
+            zenjector.Install(Location.App, container =>
+            {
+                container.BindInstance(new UBinder<Plugin, PluginMetadata>(metadata));
+            });
+
+            zenjector.Install<MenuInstaller>(Location.Menu);
+        }
+
+        [OnEnable]
+        public void OnEnable()
+        {
+#if DEBUG
+            Content = AssetBundle.LoadFromFile(@"E:\GameDev\OldschoolBeatSaber.Unity\AssetBundles\content");
+#else
+            using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("OldschoolBeatSaber.Resources.content");
+            Content = AssetBundle.LoadFromStream(stream);
+#endif
+
+            MenuCorePrefab = Content.LoadAsset<GameObject>("assets/prefabs/oldschoolmenucore.prefab");
+            MenuEnvironmentPrefab = Content.LoadAsset<GameObject>("assets/prefabs/oldschoolmenuenvironment.prefab");
+
+            MenuAudioClip = ResourceUtility.GetEmbeddedResourceAudioClip("Menu.ogg");
+
+            Content.Unload(false);
+        }
+
+        [OnDisable]
+        public void OnDisable()
+        { }
+    }
+}
diff --git a/OldschoolBeatSaber/Properties/AssemblyInfo.cs b/OldschoolBeatSaber/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..62e9799
--- /dev/null
+++ b/OldschoolBeatSaber/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Oldschool Beat Saber")]
+[assembly: AssemblyDescription("Go back in time.")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Oldschool Beat Saber")]
+[assembly: AssemblyCopyright("Copyright © Kaitlyn 2022")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("64ff49db-1859-4444-abd0-2d9abab192b3")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0")]
+[assembly: AssemblyFileVersion("1.0.0")]
diff --git a/OldschoolBeatSaber/Resources/Menu.ogg b/OldschoolBeatSaber/Resources/Menu.ogg
new file mode 100644
index 0000000..8a8e978
Binary files /dev/null and b/OldschoolBeatSaber/Resources/Menu.ogg differ
diff --git a/OldschoolBeatSaber/Resources/content b/OldschoolBeatSaber/Resources/content
new file mode 100644
index 0000000..96adcf0
Binary files /dev/null and b/OldschoolBeatSaber/Resources/content differ
diff --git a/OldschoolBeatSaber/Scripts/GameplayMode.cs b/OldschoolBeatSaber/Scripts/GameplayMode.cs
new file mode 100644
index 0000000..6d3ac8f
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/GameplayMode.cs
@@ -0,0 +1,7 @@
+public enum GameplayMode
+{
+	SoloStandard = 0,
+	SoloOneSaber = 1,
+	SoloNoArrows = 2,
+	PartyStandard = 3
+}
diff --git a/OldschoolBeatSaber/Scripts/HMUI/Image.cs b/OldschoolBeatSaber/Scripts/HMUI/Image.cs
new file mode 100644
index 0000000..3e42bfe
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/HMUI/Image.cs
@@ -0,0 +1,1054 @@
+using System;
+using UnityEngine;
+using UnityEngine.Serialization;
+using UnityEngine.Sprites;
+using UnityEngine.UI;
+
+namespace HMUI
+{
+	public class Image : MaskableGraphic, ISerializationCallbackReceiver, ILayoutElement, ICanvasRaycastFilter
+	{
+		public enum Type
+		{
+			Simple = 0,
+			Sliced = 1,
+			Tiled = 2,
+			Filled = 3
+		}
+
+		public enum FillMethod
+		{
+			Horizontal = 0,
+			Vertical = 1,
+			Radial90 = 2,
+			Radial180 = 3,
+			Radial360 = 4
+		}
+
+		public enum OriginHorizontal
+		{
+			Left = 0,
+			Right = 1
+		}
+
+		public enum OriginVertical
+		{
+			Bottom = 0,
+			Top = 1
+		}
+
+		public enum Origin90
+		{
+			BottomLeft = 0,
+			TopLeft = 1,
+			TopRight = 2,
+			BottomRight = 3
+		}
+
+		public enum Origin180
+		{
+			Bottom = 0,
+			Left = 1,
+			Top = 2,
+			Right = 3
+		}
+
+		public enum Origin360
+		{
+			Bottom = 0,
+			Right = 1,
+			Top = 2,
+			Left = 3
+		}
+
+		[FormerlySerializedAs("m_Frame")]
+		[SerializeField]
+		private Sprite m_Sprite;
+
+		[NonSerialized]
+		private Sprite m_OverrideSprite;
+
+		[SerializeField]
+		private Type m_Type;
+
+		[SerializeField]
+		private bool m_PreserveAspect;
+
+		[SerializeField]
+		private bool m_FillCenter = true;
+
+		[SerializeField]
+		private FillMethod m_FillMethod = FillMethod.Radial360;
+
+		[Range(0f, 1f)]
+		[SerializeField]
+		private float m_FillAmount = 1f;
+
+		[SerializeField]
+		private bool m_FillClockwise = true;
+
+		[SerializeField]
+		private int m_FillOrigin;
+
+		private float m_EventAlphaThreshold = 1f;
+
+		private static readonly Vector2[] s_VertScratch = new Vector2[4];
+
+		private static readonly Vector2[] s_UVScratch = new Vector2[4];
+
+		private static readonly Vector2[] s_UV2Scratch = new Vector2[4];
+
+		private static readonly Vector3[] s_Xy = new Vector3[4];
+
+		private static readonly Vector3[] s_Uv = new Vector3[4];
+
+		public Sprite sprite
+		{
+			get
+			{
+				return m_Sprite;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetClass(ref m_Sprite, value))
+				{
+					SetAllDirty();
+				}
+			}
+		}
+
+		public Sprite overrideSprite
+		{
+			get
+			{
+				return (!(m_OverrideSprite == null)) ? m_OverrideSprite : sprite;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetClass(ref m_OverrideSprite, value))
+				{
+					SetAllDirty();
+				}
+			}
+		}
+
+		public Type type
+		{
+			get
+			{
+				return m_Type;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetStruct(ref m_Type, value))
+				{
+					SetVerticesDirty();
+				}
+			}
+		}
+
+		public bool preserveAspect
+		{
+			get
+			{
+				return m_PreserveAspect;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetStruct(ref m_PreserveAspect, value))
+				{
+					SetVerticesDirty();
+				}
+			}
+		}
+
+		public bool fillCenter
+		{
+			get
+			{
+				return m_FillCenter;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetStruct(ref m_FillCenter, value))
+				{
+					SetVerticesDirty();
+				}
+			}
+		}
+
+		public FillMethod fillMethod
+		{
+			get
+			{
+				return m_FillMethod;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetStruct(ref m_FillMethod, value))
+				{
+					SetVerticesDirty();
+					m_FillOrigin = 0;
+				}
+			}
+		}
+
+		public float fillAmount
+		{
+			get
+			{
+				return m_FillAmount;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetStruct(ref m_FillAmount, Mathf.Clamp01(value)))
+				{
+					SetVerticesDirty();
+				}
+			}
+		}
+
+		public bool fillClockwise
+		{
+			get
+			{
+				return m_FillClockwise;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetStruct(ref m_FillClockwise, value))
+				{
+					SetVerticesDirty();
+				}
+			}
+		}
+
+		public int fillOrigin
+		{
+			get
+			{
+				return m_FillOrigin;
+			}
+			set
+			{
+				if (SetPropertyUtility.SetStruct(ref m_FillOrigin, value))
+				{
+					SetVerticesDirty();
+				}
+			}
+		}
+
+		public float eventAlphaThreshold
+		{
+			get
+			{
+				return m_EventAlphaThreshold;
+			}
+			set
+			{
+				m_EventAlphaThreshold = value;
+			}
+		}
+
+		public override Texture mainTexture
+		{
+			get
+			{
+				if (overrideSprite == null)
+				{
+					if (material != null && material.mainTexture != null)
+					{
+						return material.mainTexture;
+					}
+					return Graphic.s_WhiteTexture;
+				}
+				return overrideSprite.texture;
+			}
+		}
+
+		public bool hasBorder
+		{
+			get
+			{
+				if (overrideSprite != null)
+				{
+					return overrideSprite.border.sqrMagnitude > 0f;
+				}
+				return false;
+			}
+		}
+
+		public float pixelsPerUnit
+		{
+			get
+			{
+				float num = 100f;
+				if ((bool)sprite)
+				{
+					num = sprite.pixelsPerUnit;
+				}
+				float num2 = 100f;
+				if ((bool)base.canvas)
+				{
+					num2 = base.canvas.referencePixelsPerUnit;
+				}
+				return num / num2;
+			}
+		}
+
+		public virtual float minWidth
+		{
+			get
+			{
+				return 0f;
+			}
+		}
+
+		public virtual float preferredWidth
+		{
+			get
+			{
+				if (overrideSprite == null)
+				{
+					return 0f;
+				}
+				if (type == Type.Sliced || type == Type.Tiled)
+				{
+					return DataUtility.GetMinSize(overrideSprite).x / pixelsPerUnit;
+				}
+				return overrideSprite.rect.size.x / pixelsPerUnit;
+			}
+		}
+
+		public virtual float flexibleWidth
+		{
+			get
+			{
+				return -1f;
+			}
+		}
+
+		public virtual float minHeight
+		{
+			get
+			{
+				return 0f;
+			}
+		}
+
+		public virtual float preferredHeight
+		{
+			get
+			{
+				if (overrideSprite == null)
+				{
+					return 0f;
+				}
+				if (type == Type.Sliced || type == Type.Tiled)
+				{
+					return DataUtility.GetMinSize(overrideSprite).y / pixelsPerUnit;
+				}
+				return overrideSprite.rect.size.y / pixelsPerUnit;
+			}
+		}
+
+		public virtual float flexibleHeight
+		{
+			get
+			{
+				return -1f;
+			}
+		}
+
+		public virtual int layoutPriority
+		{
+			get
+			{
+				return 0;
+			}
+		}
+
+		protected Image()
+		{
+			base.useLegacyMeshGeneration = false;
+		}
+
+		public virtual void OnBeforeSerialize()
+		{
+		}
+
+		public virtual void OnAfterDeserialize()
+		{
+			if (m_FillOrigin < 0)
+			{
+				m_FillOrigin = 0;
+			}
+			else if (m_FillMethod == FillMethod.Horizontal && m_FillOrigin > 1)
+			{
+				m_FillOrigin = 0;
+			}
+			else if (m_FillMethod == FillMethod.Vertical && m_FillOrigin > 1)
+			{
+				m_FillOrigin = 0;
+			}
+			else if (m_FillOrigin > 3)
+			{
+				m_FillOrigin = 0;
+			}
+			m_FillAmount = Mathf.Clamp(m_FillAmount, 0f, 1f);
+		}
+
+		private Vector4 GetDrawingDimensions(bool shouldPreserveAspect)
+		{
+			Vector4 vector = ((!(overrideSprite == null)) ? DataUtility.GetPadding(overrideSprite) : Vector4.zero);
+			Vector2 vector2 = ((!(overrideSprite == null)) ? new Vector2(overrideSprite.rect.width, overrideSprite.rect.height) : Vector2.zero);
+			Rect pixelAdjustedRect = GetPixelAdjustedRect();
+			int num = Mathf.RoundToInt(vector2.x);
+			int num2 = Mathf.RoundToInt(vector2.y);
+			Vector4 vector3 = new Vector4(vector.x / (float)num, vector.y / (float)num2, ((float)num - vector.z) / (float)num, ((float)num2 - vector.w) / (float)num2);
+			if (shouldPreserveAspect && vector2.sqrMagnitude > 0f)
+			{
+				float num3 = vector2.x / vector2.y;
+				float num4 = pixelAdjustedRect.width / pixelAdjustedRect.height;
+				if (num3 > num4)
+				{
+					float height = pixelAdjustedRect.height;
+					pixelAdjustedRect.height = pixelAdjustedRect.width * (1f / num3);
+					pixelAdjustedRect.y += (height - pixelAdjustedRect.height) * base.rectTransform.pivot.y;
+				}
+				else
+				{
+					float width = pixelAdjustedRect.width;
+					pixelAdjustedRect.width = pixelAdjustedRect.height * num3;
+					pixelAdjustedRect.x += (width - pixelAdjustedRect.width) * base.rectTransform.pivot.x;
+				}
+			}
+			return new Vector4(pixelAdjustedRect.x + pixelAdjustedRect.width * vector3.x, pixelAdjustedRect.y + pixelAdjustedRect.height * vector3.y, pixelAdjustedRect.x + pixelAdjustedRect.width * vector3.z, pixelAdjustedRect.y + pixelAdjustedRect.height * vector3.w);
+		}
+
+		public override void SetNativeSize()
+		{
+			if (overrideSprite != null)
+			{
+				float x = overrideSprite.rect.width / pixelsPerUnit;
+				float y = overrideSprite.rect.height / pixelsPerUnit;
+				base.rectTransform.anchorMax = base.rectTransform.anchorMin;
+				base.rectTransform.sizeDelta = new Vector2(x, y);
+				SetAllDirty();
+			}
+		}
+
+		protected override void OnPopulateMesh(VertexHelper toFill)
+		{
+			if (overrideSprite == null)
+			{
+				base.OnPopulateMesh(toFill);
+				return;
+			}
+			switch (type)
+			{
+			case Type.Simple:
+				GenerateSimpleSprite(toFill, m_PreserveAspect);
+				break;
+			case Type.Sliced:
+				GenerateSlicedSprite(toFill);
+				break;
+			case Type.Tiled:
+				GenerateTiledSprite(toFill);
+				break;
+			case Type.Filled:
+				GenerateFilledSprite(toFill, m_PreserveAspect);
+				break;
+			}
+		}
+
+		private void GenerateSimpleSprite(VertexHelper vh, bool lPreserveAspect)
+		{
+			Vector4 drawingDimensions = GetDrawingDimensions(lPreserveAspect);
+			Vector4 vector = ((!(overrideSprite != null)) ? Vector4.zero : DataUtility.GetOuterUV(overrideSprite));
+			Color color = this.color;
+			vh.Clear();
+			vh.AddVert(new Vector3(drawingDimensions.x, drawingDimensions.y), color, new Vector2(vector.x, vector.y));
+			vh.AddVert(new Vector3(drawingDimensions.x, drawingDimensions.w), color, new Vector2(vector.x, vector.w));
+			vh.AddVert(new Vector3(drawingDimensions.z, drawingDimensions.w), color, new Vector2(vector.z, vector.w));
+			vh.AddVert(new Vector3(drawingDimensions.z, drawingDimensions.y), color, new Vector2(vector.z, vector.y));
+			vh.AddTriangle(0, 1, 2);
+			vh.AddTriangle(2, 3, 0);
+		}
+
+		private void GenerateSlicedSprite(VertexHelper toFill)
+		{
+			if (!hasBorder)
+			{
+				GenerateSimpleSprite(toFill, false);
+				return;
+			}
+			Vector4 vector;
+			Vector4 vector2;
+			Vector4 vector3;
+			Vector4 vector4;
+			if (overrideSprite != null)
+			{
+				vector = DataUtility.GetOuterUV(overrideSprite);
+				vector2 = DataUtility.GetInnerUV(overrideSprite);
+				vector3 = DataUtility.GetPadding(overrideSprite);
+				vector4 = overrideSprite.border;
+			}
+			else
+			{
+				vector = Vector4.zero;
+				vector2 = Vector4.zero;
+				vector3 = Vector4.zero;
+				vector4 = Vector4.zero;
+			}
+			Rect pixelAdjustedRect = GetPixelAdjustedRect();
+			vector4 = GetAdjustedBorders(vector4 / pixelsPerUnit, pixelAdjustedRect);
+			vector3 /= pixelsPerUnit;
+			s_VertScratch[0] = new Vector2(vector3.x, vector3.y);
+			s_VertScratch[3] = new Vector2(pixelAdjustedRect.width - vector3.z, pixelAdjustedRect.height - vector3.w);
+			s_VertScratch[1].x = vector4.x;
+			s_VertScratch[1].y = vector4.y;
+			s_VertScratch[2].x = pixelAdjustedRect.width - vector4.z;
+			s_VertScratch[2].y = pixelAdjustedRect.height - vector4.w;
+			Vector2 scale = new Vector2(1f / pixelAdjustedRect.width, 1f / pixelAdjustedRect.height);
+			for (int i = 0; i < 4; i++)
+			{
+				s_UV2Scratch[i] = s_VertScratch[i];
+				s_UV2Scratch[i].Scale(scale);
+			}
+			for (int j = 0; j < 4; j++)
+			{
+				s_VertScratch[j].x += pixelAdjustedRect.x;
+				s_VertScratch[j].y += pixelAdjustedRect.y;
+			}
+			s_UVScratch[0] = new Vector2(vector.x, vector.y);
+			s_UVScratch[1] = new Vector2(vector2.x, vector2.y);
+			s_UVScratch[2] = new Vector2(vector2.z, vector2.w);
+			s_UVScratch[3] = new Vector2(vector.z, vector.w);
+			toFill.Clear();
+			for (int k = 0; k < 3; k++)
+			{
+				int num = k + 1;
+				for (int l = 0; l < 3; l++)
+				{
+					if (m_FillCenter || k != 1 || l != 1)
+					{
+						int num2 = l + 1;
+						AddQuad(toFill, new Vector2(s_VertScratch[k].x, s_VertScratch[l].y), new Vector2(s_VertScratch[num].x, s_VertScratch[num2].y), color, new Vector2(s_UVScratch[k].x, s_UVScratch[l].y), new Vector2(s_UVScratch[num].x, s_UVScratch[num2].y), new Vector2(s_UV2Scratch[k].x, s_UV2Scratch[l].y), new Vector2(s_UV2Scratch[num].x, s_UV2Scratch[num2].y));
+					}
+				}
+			}
+		}
+
+		private void GenerateTiledSprite(VertexHelper toFill)
+		{
+			Vector4 vector;
+			Vector4 vector2;
+			Vector2 vector4;
+			Vector4 vector3;
+			if (overrideSprite != null)
+			{
+				vector = DataUtility.GetOuterUV(overrideSprite);
+				vector2 = DataUtility.GetInnerUV(overrideSprite);
+				vector3 = overrideSprite.border;
+				vector4 = overrideSprite.rect.size;
+			}
+			else
+			{
+				vector = Vector4.zero;
+				vector2 = Vector4.zero;
+				vector3 = Vector4.zero;
+				vector4 = Vector2.one * 100f;
+			}
+			Rect pixelAdjustedRect = GetPixelAdjustedRect();
+			float num = (vector4.x - vector3.x - vector3.z) / pixelsPerUnit;
+			float num2 = (vector4.y - vector3.y - vector3.w) / pixelsPerUnit;
+			vector3 = GetAdjustedBorders(vector3 / pixelsPerUnit, pixelAdjustedRect);
+			Vector2 uvMin = new Vector2(vector2.x, vector2.y);
+			Vector2 vector5 = new Vector2(vector2.z, vector2.w);
+			UIVertex simpleVert = UIVertex.simpleVert;
+			simpleVert.color = color;
+			float x = vector3.x;
+			float num3 = pixelAdjustedRect.width - vector3.z;
+			float y = vector3.y;
+			float num4 = pixelAdjustedRect.height - vector3.w;
+			toFill.Clear();
+			Vector2 uvMax = vector5;
+			if (num == 0f)
+			{
+				num = num3 - x;
+			}
+			if (num2 == 0f)
+			{
+				num2 = num4 - y;
+			}
+			if (m_FillCenter)
+			{
+				for (float num5 = y; num5 < num4; num5 += num2)
+				{
+					float num6 = num5 + num2;
+					if (num6 > num4)
+					{
+						uvMax.y = uvMin.y + (vector5.y - uvMin.y) * (num4 - num5) / (num6 - num5);
+						num6 = num4;
+					}
+					uvMax.x = vector5.x;
+					for (float num7 = x; num7 < num3; num7 += num)
+					{
+						float num8 = num7 + num;
+						if (num8 > num3)
+						{
+							uvMax.x = uvMin.x + (vector5.x - uvMin.x) * (num3 - num7) / (num8 - num7);
+							num8 = num3;
+						}
+						AddQuad(toFill, new Vector2(num7, num5) + pixelAdjustedRect.position, new Vector2(num8, num6) + pixelAdjustedRect.position, color, uvMin, uvMax);
+					}
+				}
+			}
+			if (!hasBorder)
+			{
+				return;
+			}
+			uvMax = vector5;
+			for (float num9 = y; num9 < num4; num9 += num2)
+			{
+				float num10 = num9 + num2;
+				if (num10 > num4)
+				{
+					uvMax.y = uvMin.y + (vector5.y - uvMin.y) * (num4 - num9) / (num10 - num9);
+					num10 = num4;
+				}
+				AddQuad(toFill, new Vector2(0f, num9) + pixelAdjustedRect.position, new Vector2(x, num10) + pixelAdjustedRect.position, color, new Vector2(vector.x, uvMin.y), new Vector2(uvMin.x, uvMax.y));
+				AddQuad(toFill, new Vector2(num3, num9) + pixelAdjustedRect.position, new Vector2(pixelAdjustedRect.width, num10) + pixelAdjustedRect.position, color, new Vector2(vector5.x, uvMin.y), new Vector2(vector.z, uvMax.y));
+			}
+			uvMax = vector5;
+			for (float num11 = x; num11 < num3; num11 += num)
+			{
+				float num12 = num11 + num;
+				if (num12 > num3)
+				{
+					uvMax.x = uvMin.x + (vector5.x - uvMin.x) * (num3 - num11) / (num12 - num11);
+					num12 = num3;
+				}
+				AddQuad(toFill, new Vector2(num11, 0f) + pixelAdjustedRect.position, new Vector2(num12, y) + pixelAdjustedRect.position, color, new Vector2(uvMin.x, vector.y), new Vector2(uvMax.x, uvMin.y));
+				AddQuad(toFill, new Vector2(num11, num4) + pixelAdjustedRect.position, new Vector2(num12, pixelAdjustedRect.height) + pixelAdjustedRect.position, color, new Vector2(uvMin.x, vector5.y), new Vector2(uvMax.x, vector.w));
+			}
+			AddQuad(toFill, new Vector2(0f, 0f) + pixelAdjustedRect.position, new Vector2(x, y) + pixelAdjustedRect.position, color, new Vector2(vector.x, vector.y), new Vector2(uvMin.x, uvMin.y));
+			AddQuad(toFill, new Vector2(num3, 0f) + pixelAdjustedRect.position, new Vector2(pixelAdjustedRect.width, y) + pixelAdjustedRect.position, color, new Vector2(vector5.x, vector.y), new Vector2(vector.z, uvMin.y));
+			AddQuad(toFill, new Vector2(0f, num4) + pixelAdjustedRect.position, new Vector2(x, pixelAdjustedRect.height) + pixelAdjustedRect.position, color, new Vector2(vector.x, vector5.y), new Vector2(uvMin.x, vector.w));
+			AddQuad(toFill, new Vector2(num3, num4) + pixelAdjustedRect.position, new Vector2(pixelAdjustedRect.width, pixelAdjustedRect.height) + pixelAdjustedRect.position, color, new Vector2(vector5.x, vector5.y), new Vector2(vector.z, vector.w));
+		}
+
+		private static void AddQuad(VertexHelper vertexHelper, Vector3[] quadPositions, Color32 color, Vector3[] quadUVs)
+		{
+			int currentVertCount = vertexHelper.currentVertCount;
+			for (int i = 0; i < 4; i++)
+			{
+				vertexHelper.AddVert(quadPositions[i], color, quadUVs[i]);
+			}
+			vertexHelper.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
+			vertexHelper.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
+		}
+
+		private static void AddQuad(VertexHelper vertexHelper, Vector2 posMin, Vector2 posMax, Color32 color, Vector2 uvMin, Vector2 uvMax)
+		{
+			int currentVertCount = vertexHelper.currentVertCount;
+			vertexHelper.AddVert(new Vector3(posMin.x, posMin.y, 0f), color, new Vector2(uvMin.x, uvMin.y));
+			vertexHelper.AddVert(new Vector3(posMin.x, posMax.y, 0f), color, new Vector2(uvMin.x, uvMax.y));
+			vertexHelper.AddVert(new Vector3(posMax.x, posMax.y, 0f), color, new Vector2(uvMax.x, uvMax.y));
+			vertexHelper.AddVert(new Vector3(posMax.x, posMin.y, 0f), color, new Vector2(uvMax.x, uvMin.y));
+			vertexHelper.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
+			vertexHelper.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
+		}
+
+		private static void AddQuad(VertexHelper vertexHelper, Vector2 posMin, Vector2 posMax, Color32 color, Vector2 uvMin, Vector2 uvMax, Vector2 uv2Min, Vector2 uv2Max)
+		{
+			int currentVertCount = vertexHelper.currentVertCount;
+			vertexHelper.AddVert(new Vector3(posMin.x, posMin.y, 0f), color, new Vector2(uvMin.x, uvMin.y), new Vector2(uv2Min.x, uv2Min.y), Vector3.zero, Vector4.zero);
+			vertexHelper.AddVert(new Vector3(posMin.x, posMax.y, 0f), color, new Vector2(uvMin.x, uvMax.y), new Vector2(uv2Min.x, uv2Max.y), Vector3.zero, Vector4.zero);
+			vertexHelper.AddVert(new Vector3(posMax.x, posMax.y, 0f), color, new Vector2(uvMax.x, uvMax.y), new Vector2(uv2Max.x, uv2Max.y), Vector3.zero, Vector4.zero);
+			vertexHelper.AddVert(new Vector3(posMax.x, posMin.y, 0f), color, new Vector2(uvMax.x, uvMin.y), new Vector2(uv2Max.x, uv2Min.y), Vector3.zero, Vector4.zero);
+			vertexHelper.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
+			vertexHelper.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
+		}
+
+		private Vector4 GetAdjustedBorders(Vector4 border, Rect rect)
+		{
+			for (int i = 0; i <= 1; i++)
+			{
+				float num = border[i] + border[i + 2];
+				if (rect.size[i] < num && num != 0f)
+				{
+					float num2 = rect.size[i] / num;
+					border[i] *= num2;
+					border[i + 2] *= num2;
+				}
+			}
+			return border;
+		}
+
+		private void GenerateFilledSprite(VertexHelper toFill, bool preserveAspect)
+		{
+			toFill.Clear();
+			if (m_FillAmount < 0.001f)
+			{
+				return;
+			}
+			Vector4 drawingDimensions = GetDrawingDimensions(preserveAspect);
+			Vector4 vector = ((!(overrideSprite != null)) ? Vector4.zero : DataUtility.GetOuterUV(overrideSprite));
+			UIVertex simpleVert = UIVertex.simpleVert;
+			simpleVert.color = color;
+			float num = vector.x;
+			float num2 = vector.y;
+			float num3 = vector.z;
+			float num4 = vector.w;
+			if (m_FillMethod == FillMethod.Horizontal || m_FillMethod == FillMethod.Vertical)
+			{
+				if (fillMethod == FillMethod.Horizontal)
+				{
+					float num5 = (num3 - num) * m_FillAmount;
+					if (m_FillOrigin == 1)
+					{
+						drawingDimensions.x = drawingDimensions.z - (drawingDimensions.z - drawingDimensions.x) * m_FillAmount;
+						num = num3 - num5;
+					}
+					else
+					{
+						drawingDimensions.z = drawingDimensions.x + (drawingDimensions.z - drawingDimensions.x) * m_FillAmount;
+						num3 = num + num5;
+					}
+				}
+				else if (fillMethod == FillMethod.Vertical)
+				{
+					float num6 = (num4 - num2) * m_FillAmount;
+					if (m_FillOrigin == 1)
+					{
+						drawingDimensions.y = drawingDimensions.w - (drawingDimensions.w - drawingDimensions.y) * m_FillAmount;
+						num2 = num4 - num6;
+					}
+					else
+					{
+						drawingDimensions.w = drawingDimensions.y + (drawingDimensions.w - drawingDimensions.y) * m_FillAmount;
+						num4 = num2 + num6;
+					}
+				}
+			}
+			s_Xy[0] = new Vector2(drawingDimensions.x, drawingDimensions.y);
+			s_Xy[1] = new Vector2(drawingDimensions.x, drawingDimensions.w);
+			s_Xy[2] = new Vector2(drawingDimensions.z, drawingDimensions.w);
+			s_Xy[3] = new Vector2(drawingDimensions.z, drawingDimensions.y);
+			s_Uv[0] = new Vector2(num, num2);
+			s_Uv[1] = new Vector2(num, num4);
+			s_Uv[2] = new Vector2(num3, num4);
+			s_Uv[3] = new Vector2(num3, num2);
+			if (m_FillAmount < 1f && m_FillMethod != 0 && m_FillMethod != FillMethod.Vertical)
+			{
+				if (fillMethod == FillMethod.Radial90)
+				{
+					if (RadialCut(s_Xy, s_Uv, m_FillAmount, m_FillClockwise, m_FillOrigin))
+					{
+						AddQuad(toFill, s_Xy, color, s_Uv);
+					}
+				}
+				else if (fillMethod == FillMethod.Radial180)
+				{
+					for (int i = 0; i < 2; i++)
+					{
+						int num7 = ((m_FillOrigin > 1) ? 1 : 0);
+						float t;
+						float t2;
+						float t3;
+						float t4;
+						if (m_FillOrigin == 0 || m_FillOrigin == 2)
+						{
+							t = 0f;
+							t2 = 1f;
+							if (i == num7)
+							{
+								t3 = 0f;
+								t4 = 0.5f;
+							}
+							else
+							{
+								t3 = 0.5f;
+								t4 = 1f;
+							}
+						}
+						else
+						{
+							t3 = 0f;
+							t4 = 1f;
+							if (i == num7)
+							{
+								t = 0.5f;
+								t2 = 1f;
+							}
+							else
+							{
+								t = 0f;
+								t2 = 0.5f;
+							}
+						}
+						s_Xy[0].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, t3);
+						s_Xy[1].x = s_Xy[0].x;
+						s_Xy[2].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, t4);
+						s_Xy[3].x = s_Xy[2].x;
+						s_Xy[0].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, t);
+						s_Xy[1].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, t2);
+						s_Xy[2].y = s_Xy[1].y;
+						s_Xy[3].y = s_Xy[0].y;
+						s_Uv[0].x = Mathf.Lerp(num, num3, t3);
+						s_Uv[1].x = s_Uv[0].x;
+						s_Uv[2].x = Mathf.Lerp(num, num3, t4);
+						s_Uv[3].x = s_Uv[2].x;
+						s_Uv[0].y = Mathf.Lerp(num2, num4, t);
+						s_Uv[1].y = Mathf.Lerp(num2, num4, t2);
+						s_Uv[2].y = s_Uv[1].y;
+						s_Uv[3].y = s_Uv[0].y;
+						float value = ((!m_FillClockwise) ? (m_FillAmount * 2f - (float)(1 - i)) : (fillAmount * 2f - (float)i));
+						if (RadialCut(s_Xy, s_Uv, Mathf.Clamp01(value), m_FillClockwise, (i + m_FillOrigin + 3) % 4))
+						{
+							AddQuad(toFill, s_Xy, color, s_Uv);
+						}
+					}
+				}
+				else
+				{
+					if (fillMethod != FillMethod.Radial360)
+					{
+						return;
+					}
+					for (int j = 0; j < 4; j++)
+					{
+						float t5;
+						float t6;
+						if (j < 2)
+						{
+							t5 = 0f;
+							t6 = 0.5f;
+						}
+						else
+						{
+							t5 = 0.5f;
+							t6 = 1f;
+						}
+						float t7;
+						float t8;
+						if (j == 0 || j == 3)
+						{
+							t7 = 0f;
+							t8 = 0.5f;
+						}
+						else
+						{
+							t7 = 0.5f;
+							t8 = 1f;
+						}
+						s_Xy[0].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, t5);
+						s_Xy[1].x = s_Xy[0].x;
+						s_Xy[2].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, t6);
+						s_Xy[3].x = s_Xy[2].x;
+						s_Xy[0].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, t7);
+						s_Xy[1].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, t8);
+						s_Xy[2].y = s_Xy[1].y;
+						s_Xy[3].y = s_Xy[0].y;
+						s_Uv[0].x = Mathf.Lerp(num, num3, t5);
+						s_Uv[1].x = s_Uv[0].x;
+						s_Uv[2].x = Mathf.Lerp(num, num3, t6);
+						s_Uv[3].x = s_Uv[2].x;
+						s_Uv[0].y = Mathf.Lerp(num2, num4, t7);
+						s_Uv[1].y = Mathf.Lerp(num2, num4, t8);
+						s_Uv[2].y = s_Uv[1].y;
+						s_Uv[3].y = s_Uv[0].y;
+						float value2 = ((!m_FillClockwise) ? (m_FillAmount * 4f - (float)(3 - (j + m_FillOrigin) % 4)) : (m_FillAmount * 4f - (float)((j + m_FillOrigin) % 4)));
+						if (RadialCut(s_Xy, s_Uv, Mathf.Clamp01(value2), m_FillClockwise, (j + 2) % 4))
+						{
+							AddQuad(toFill, s_Xy, color, s_Uv);
+						}
+					}
+				}
+			}
+			else
+			{
+				AddQuad(toFill, s_Xy, color, s_Uv);
+			}
+		}
+
+		private static bool RadialCut(Vector3[] xy, Vector3[] uv, float fill, bool invert, int corner)
+		{
+			if (fill < 0.001f)
+			{
+				return false;
+			}
+			if ((corner & 1) == 1)
+			{
+				invert = !invert;
+			}
+			if (!invert && fill > 0.999f)
+			{
+				return true;
+			}
+			float num = Mathf.Clamp01(fill);
+			if (invert)
+			{
+				num = 1f - num;
+			}
+			num *= (float)Math.PI / 2f;
+			float cos = Mathf.Cos(num);
+			float sin = Mathf.Sin(num);
+			RadialCut(xy, cos, sin, invert, corner);
+			RadialCut(uv, cos, sin, invert, corner);
+			return true;
+		}
+
+		private static void RadialCut(Vector3[] xy, float cos, float sin, bool invert, int corner)
+		{
+			int num = (corner + 1) % 4;
+			int num2 = (corner + 2) % 4;
+			int num3 = (corner + 3) % 4;
+			if ((corner & 1) == 1)
+			{
+				if (sin > cos)
+				{
+					cos /= sin;
+					sin = 1f;
+					if (invert)
+					{
+						xy[num].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
+						xy[num2].x = xy[num].x;
+					}
+				}
+				else if (cos > sin)
+				{
+					sin /= cos;
+					cos = 1f;
+					if (!invert)
+					{
+						xy[num2].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
+						xy[num3].y = xy[num2].y;
+					}
+				}
+				else
+				{
+					cos = 1f;
+					sin = 1f;
+				}
+				if (!invert)
+				{
+					xy[num3].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
+				}
+				else
+				{
+					xy[num].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
+				}
+				return;
+			}
+			if (cos > sin)
+			{
+				sin /= cos;
+				cos = 1f;
+				if (!invert)
+				{
+					xy[num].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
+					xy[num2].y = xy[num].y;
+				}
+			}
+			else if (sin > cos)
+			{
+				cos /= sin;
+				sin = 1f;
+				if (invert)
+				{
+					xy[num2].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
+					xy[num3].x = xy[num2].x;
+				}
+			}
+			else
+			{
+				cos = 1f;
+				sin = 1f;
+			}
+			if (invert)
+			{
+				xy[num3].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
+			}
+			else
+			{
+				xy[num].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
+			}
+		}
+
+		public virtual void CalculateLayoutInputHorizontal()
+		{
+		}
+
+		public virtual void CalculateLayoutInputVertical()
+		{
+		}
+
+		public virtual bool IsRaycastLocationValid(Vector2 screenPoint, Camera eventCamera)
+		{
+			if (m_EventAlphaThreshold >= 1f)
+			{
+				return true;
+			}
+			Sprite sprite = overrideSprite;
+			if (sprite == null)
+			{
+				return true;
+			}
+			Vector2 localPoint;
+			RectTransformUtility.ScreenPointToLocalPointInRectangle(base.rectTransform, screenPoint, eventCamera, out localPoint);
+			Rect pixelAdjustedRect = GetPixelAdjustedRect();
+			localPoint.x += base.rectTransform.pivot.x * pixelAdjustedRect.width;
+			localPoint.y += base.rectTransform.pivot.y * pixelAdjustedRect.height;
+			localPoint = MapCoordinate(localPoint, pixelAdjustedRect);
+			Rect textureRect = sprite.textureRect;
+			Vector2 vector = new Vector2(localPoint.x / textureRect.width, localPoint.y / textureRect.height);
+			float u = Mathf.Lerp(textureRect.x, textureRect.xMax, vector.x) / (float)sprite.texture.width;
+			float v = Mathf.Lerp(textureRect.y, textureRect.yMax, vector.y) / (float)sprite.texture.height;
+			try
+			{
+				return sprite.texture.GetPixelBilinear(u, v).a >= m_EventAlphaThreshold;
+			}
+			catch (UnityException ex)
+			{
+				Debug.LogError("Using clickAlphaThreshold lower than 1 on Image whose sprite texture cannot be read. " + ex.Message + " Also make sure to disable sprite packing for this sprite.", this);
+				return true;
+			}
+		}
+
+		private Vector2 MapCoordinate(Vector2 local, Rect rect)
+		{
+			Rect rect2 = sprite.rect;
+			if (type == Type.Simple || type == Type.Filled)
+			{
+				return new Vector2(local.x * rect2.width / rect.width, local.y * rect2.height / rect.height);
+			}
+			Vector4 border = sprite.border;
+			Vector4 adjustedBorders = GetAdjustedBorders(border / pixelsPerUnit, rect);
+			for (int i = 0; i < 2; i++)
+			{
+				if (!(local[i] <= adjustedBorders[i]))
+				{
+					if (rect.size[i] - local[i] <= adjustedBorders[i + 2])
+					{
+						local[i] -= rect.size[i] - rect2.size[i];
+					}
+					else if (type == Type.Sliced)
+					{
+						float t = Mathf.InverseLerp(adjustedBorders[i], rect.size[i] - adjustedBorders[i + 2], local[i]);
+						local[i] = Mathf.Lerp(border[i], rect2.size[i] - border[i + 2], t);
+					}
+					else
+					{
+						local[i] -= adjustedBorders[i];
+						local[i] = Mathf.Repeat(local[i], rect2.size[i] - border[i] - border[i + 2]);
+						local[i] += border[i];
+					}
+				}
+			}
+			return local;
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/HMUI/SetPropertyUtility.cs b/OldschoolBeatSaber/Scripts/HMUI/SetPropertyUtility.cs
new file mode 100644
index 0000000..8787727
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/HMUI/SetPropertyUtility.cs
@@ -0,0 +1,37 @@
+using UnityEngine;
+
+namespace HMUI
+{
+	internal static class SetPropertyUtility
+	{
+		public static bool SetColor(ref Color currentValue, Color newValue)
+		{
+			if (currentValue.r == newValue.r && currentValue.g == newValue.g && currentValue.b == newValue.b && currentValue.a == newValue.a)
+			{
+				return false;
+			}
+			currentValue = newValue;
+			return true;
+		}
+
+		public static bool SetStruct<T>(ref T currentValue, T newValue) where T : struct
+		{
+			if (currentValue.Equals(newValue))
+			{
+				return false;
+			}
+			currentValue = newValue;
+			return true;
+		}
+
+		public static bool SetClass<T>(ref T currentValue, T newValue) where T : class
+		{
+			if ((currentValue == null && newValue == null) || (currentValue != null && currentValue.Equals(newValue)))
+			{
+				return false;
+			}
+			currentValue = newValue;
+			return true;
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/HMUI/TableCell.cs b/OldschoolBeatSaber/Scripts/HMUI/TableCell.cs
new file mode 100644
index 0000000..8bb927e
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/HMUI/TableCell.cs
@@ -0,0 +1,159 @@
+using OldschoolBeatSaber.Utilities;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace HMUI
+{
+	[RequireComponent(typeof(RectTransform))]
+	public class TableCell : UIBehaviour, IPointerClickHandler, ISubmitHandler, IPointerEnterHandler, IPointerExitHandler, IEventSystemHandler
+	{
+		public enum TransitionType
+		{
+			Instant = 0,
+			Animated = 1
+		}
+
+		private Signal _tableCellWasPressedSignal;
+
+		private string _reuseIdentifier;
+
+		private int _row;
+
+		private TableView _tableView;
+
+		private bool _selected;
+
+		private bool _highlighted;
+
+		public string reuseIdentifier
+		{
+			get
+			{
+				return _reuseIdentifier;
+			}
+			set
+			{
+				_reuseIdentifier = value;
+			}
+		}
+
+		public int row
+		{
+			get
+			{
+				return _row;
+			}
+		}
+
+		public bool selected
+		{
+			get
+			{
+				return _selected;
+			}
+			set
+			{
+				ChangeSelection(value, TransitionType.Animated, true, false);
+			}
+		}
+
+		public bool highlighted
+		{
+			get
+			{
+				return _highlighted;
+			}
+		}
+
+		protected override void Start()
+		{
+			base.Start();
+			if (_tableCellWasPressedSignal == null)
+				_tableCellWasPressedSignal = ResourceUtility.Find<Signal>("TableCellWasPressed");
+			SelectionDidChange(TransitionType.Instant);
+			HighlightDidChange(TransitionType.Instant);
+		}
+
+		public void TableViewSetup(TableView tableView, int row)
+		{
+			_tableView = tableView;
+			_row = row;
+		}
+
+		public void ChangeSelection(bool value, TransitionType transitionType, bool callbackTable, bool ignoreCurrentValue)
+		{
+			if (ignoreCurrentValue || _selected != value)
+			{
+				_selected = value;
+				SelectionDidChange(transitionType);
+				if (callbackTable)
+				{
+					_tableView.CellSelectionStateDidChange(this);
+				}
+			}
+		}
+
+		public void ChangeHighlight(bool value, TransitionType transitionType, bool ignoreCurrentValue)
+		{
+			if (ignoreCurrentValue || _highlighted != value)
+			{
+				_highlighted = value;
+				HighlightDidChange(transitionType);
+			}
+		}
+
+		private void InternalToggle()
+		{
+			if (IsActive() && _tableView.selectionType != 0)
+			{
+				if (selected && _tableView.selectionType == TableView.SelectionType.Multiple)
+				{
+					selected = !selected;
+				}
+				else if (!selected)
+				{
+					selected = true;
+				}
+			}
+		}
+
+		protected virtual void SelectionDidChange(TransitionType transitionType)
+		{
+		}
+
+		protected virtual void HighlightDidChange(TransitionType transitionType)
+		{
+		}
+
+		public virtual void OnPointerClick(PointerEventData eventData)
+		{
+			if (eventData.button == PointerEventData.InputButton.Left)
+			{
+				InternalToggle();
+				if (_tableCellWasPressedSignal != null)
+				{
+					_tableCellWasPressedSignal.Raise();
+				}
+			}
+		}
+
+		public virtual void OnSubmit(BaseEventData eventData)
+		{
+			InternalToggle();
+			if (_tableCellWasPressedSignal != null)
+			{
+				_tableCellWasPressedSignal.Raise();
+			}
+		}
+
+		public virtual void OnPointerEnter(PointerEventData eventData)
+		{
+			ChangeHighlight(true, TransitionType.Animated, false);
+		}
+
+		public virtual void OnPointerExit(PointerEventData eventData)
+		{
+			ChangeHighlight(false, TransitionType.Animated, false);
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/HMUI/TableView.cs b/OldschoolBeatSaber/Scripts/HMUI/TableView.cs
new file mode 100644
index 0000000..7e2e199
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/HMUI/TableView.cs
@@ -0,0 +1,430 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace HMUI
+{
+	[RequireComponent(typeof(ScrollRect))]
+	public class TableView : MonoBehaviour
+	{
+		public enum SelectionType
+		{
+			None = 0,
+			Single = 1,
+			Multiple = 2
+		}
+
+		public interface IDataSource
+		{
+			float RowHeight();
+
+			int NumberOfRows();
+
+			TableCell CellForRow(int row);
+		}
+
+		[SerializeField]
+		[NullAllowed]
+		private Button _pageUpButton;
+
+		[SerializeField]
+		[NullAllowed]
+		private Button _pageDownButton;
+
+		[SerializeField]
+		private SelectionType _selectionType = SelectionType.Single;
+
+		private ScrollRect _scrollRect;
+
+		private RectTransform _scrollRectTransform;
+
+		private RectTransform _contentTransform;
+
+		private IDataSource _dataSource;
+
+		private int _numberOfRows;
+
+		private float _rowHeight;
+
+		private List<TableCell> _visibleCells;
+
+		private Dictionary<string, List<TableCell>> _reusableCells;
+
+		private HashSet<int> _selectedRows;
+
+		private int _prevMinRow = -1;
+
+		private int _prevMaxRow = -1;
+
+		private float _targetVerticalNormalizedPosition;
+
+		public SelectionType selectionType
+		{
+			get
+			{
+				return _selectionType;
+			}
+			set
+			{
+				_selectionType = value;
+			}
+		}
+
+		public IDataSource dataSource
+		{
+			get
+			{
+				return _dataSource;
+			}
+			set
+			{
+				_dataSource = value;
+				ReloadData();
+			}
+		}
+
+		public event Action<TableView, int> DidSelectRowEvent;
+
+		private void Awake()
+		{
+			if ((bool)_pageUpButton)
+			{
+				_pageUpButton.onClick.AddListener(PageScrollUp);
+			}
+			if ((bool)_pageDownButton)
+			{
+				_pageDownButton.onClick.AddListener(PageScrollDown);
+			}
+			_visibleCells = new List<TableCell>();
+			_reusableCells = new Dictionary<string, List<TableCell>>();
+			_selectedRows = new HashSet<int>();
+			_scrollRect = GetComponent<ScrollRect>();
+			_contentTransform = _scrollRect.content;
+			if (!_contentTransform)
+			{
+				GameObject gameObject = new GameObject("Content", typeof(RectTransform));
+				if (_scrollRect.viewport == null)
+				{
+					gameObject.transform.SetParent(base.transform, false);
+				}
+				else
+				{
+					gameObject.transform.SetParent(_scrollRect.viewport, false);
+				}
+				_contentTransform = gameObject.transform as RectTransform;
+				_scrollRect.content = _contentTransform;
+			}
+			_scrollRect.horizontal = false;
+			_scrollRect.onValueChanged.AddListener(ScrollRectOnValueChanged);
+			_scrollRectTransform = _scrollRect.transform as RectTransform;
+			_contentTransform.anchorMax = new Vector2(1f, 1f);
+			_contentTransform.anchorMin = new Vector2(0f, 1f);
+			_contentTransform.sizeDelta = new Vector2(0f, 0f);
+			_contentTransform.pivot = new Vector2(0.5f, 1f);
+			_contentTransform.anchoredPosition = new Vector2(0f, 0f);
+			_targetVerticalNormalizedPosition = _scrollRect.verticalNormalizedPosition;
+		}
+
+		private void OnDestroy()
+		{
+			if ((bool)_pageUpButton)
+			{
+				_pageUpButton.onClick.RemoveListener(PageScrollUp);
+			}
+			if ((bool)_pageDownButton)
+			{
+				_pageDownButton.onClick.RemoveListener(PageScrollDown);
+			}
+		}
+
+		private void RefreshScrollButtons()
+		{
+			float height = _scrollRectTransform.rect.height;
+			float num = (float)_numberOfRows * _rowHeight - height;
+			if ((bool)_pageDownButton)
+			{
+				_pageDownButton.interactable = !Mathf.Approximately(_targetVerticalNormalizedPosition, 0f);
+				if (num < 0.01f)
+				{
+					_pageDownButton.gameObject.SetActive(false);
+				}
+				else
+				{
+					_pageDownButton.gameObject.SetActive(true);
+				}
+			}
+			if ((bool)_pageUpButton)
+			{
+				_pageUpButton.interactable = !Mathf.Approximately(_targetVerticalNormalizedPosition, 1f);
+				if (num < 0.01f)
+				{
+					_pageUpButton.gameObject.SetActive(false);
+				}
+				else
+				{
+					_pageUpButton.gameObject.SetActive(true);
+				}
+			}
+		}
+
+		private void RefreshContentSize()
+		{
+			_contentTransform.sizeDelta = new Vector2(0f, (float)_numberOfRows * _rowHeight);
+		}
+
+		private void RefreshCells(bool forced)
+		{
+			float height = _scrollRectTransform.rect.height;
+			float num = (float)_numberOfRows * _rowHeight - height;
+			if (num < 0f)
+			{
+				num = 0f;
+			}
+			float num2 = (1f - _scrollRect.verticalNormalizedPosition) * num;
+			int num3 = Mathf.FloorToInt(num2 / _rowHeight);
+			if (num3 < 0)
+			{
+				num3 = 0;
+			}
+			int num4 = Mathf.FloorToInt((num2 + height) / _rowHeight);
+			if (num4 > _numberOfRows - 1)
+			{
+				num4 = _numberOfRows - 1;
+			}
+			if (num3 == _prevMinRow && num4 == _prevMaxRow && !forced)
+			{
+				return;
+			}
+			for (int num5 = _visibleCells.Count - 1; num5 >= 0; num5--)
+			{
+				TableCell tableCell = _visibleCells[num5];
+				if (tableCell.row < num3 || tableCell.row > num4)
+				{
+					tableCell.gameObject.SetActive(false);
+					_visibleCells.RemoveAt(num5);
+					AddCellToReusableCells(tableCell);
+				}
+			}
+			for (int i = num3; i <= num4; i++)
+			{
+				TableCell tableCell2 = null;
+				for (int j = 0; j < _visibleCells.Count; j++)
+				{
+					if (_visibleCells[j].row == i)
+					{
+						tableCell2 = _visibleCells[j];
+						break;
+					}
+				}
+				if (!(tableCell2 != null) || forced)
+				{
+					if (tableCell2 == null)
+					{
+						tableCell2 = _dataSource.CellForRow(i);
+						_visibleCells.Add(tableCell2);
+					}
+					tableCell2.gameObject.SetActive(true);
+					tableCell2.TableViewSetup(this, i);
+					tableCell2.ChangeSelection(_selectedRows.Contains(i), TableCell.TransitionType.Instant, false, true);
+					tableCell2.ChangeHighlight(false, TableCell.TransitionType.Instant, true);
+					if (tableCell2.transform.parent != _contentTransform)
+					{
+						tableCell2.transform.SetParent(_contentTransform, false);
+					}
+					LayoutCellForRow(tableCell2, i);
+					if (_visibleCells.Count == num4 - num3 + 1 && !forced)
+					{
+						break;
+					}
+				}
+			}
+			_prevMinRow = num3;
+			_prevMaxRow = num4;
+		}
+
+		private void LayoutCellForRow(TableCell cell, int row)
+		{
+			RectTransform rectTransform = cell.transform as RectTransform;
+			rectTransform.anchorMax = new Vector2(1f, 1f);
+			rectTransform.anchorMin = new Vector2(0f, 1f);
+			rectTransform.pivot = new Vector2(0.5f, 1f);
+			rectTransform.sizeDelta = new Vector2(0f, _rowHeight);
+			rectTransform.anchoredPosition = new Vector2(0f, (float)(-row) * _rowHeight);
+		}
+
+		private void AddCellToReusableCells(TableCell cell)
+		{
+			List<TableCell> value = null;
+			if (!_reusableCells.TryGetValue(cell.reuseIdentifier, out value))
+			{
+				value = new List<TableCell>();
+				_reusableCells.Add(cell.reuseIdentifier, value);
+			}
+			value.Add(cell);
+		}
+
+		private void ScrollRectOnValueChanged(Vector2 pos)
+		{
+			RefreshCells(false);
+		}
+
+		public void CellSelectionStateDidChange(TableCell changedCell)
+		{
+			if (selectionType == SelectionType.None)
+			{
+				return;
+			}
+			if (selectionType != SelectionType.Multiple)
+			{
+				foreach (TableCell visibleCell in _visibleCells)
+				{
+					if (!(changedCell == visibleCell))
+					{
+						visibleCell.ChangeSelection(false, TableCell.TransitionType.Instant, false, false);
+					}
+				}
+			}
+			if (changedCell.selected)
+			{
+				if (selectionType != SelectionType.Multiple)
+				{
+					_selectedRows.Clear();
+				}
+				_selectedRows.Add(changedCell.row);
+				if (this.DidSelectRowEvent != null)
+				{
+					this.DidSelectRowEvent(this, changedCell.row);
+				}
+			}
+			else
+			{
+				_selectedRows.Remove(changedCell.row);
+			}
+		}
+
+		public void ReloadData()
+		{
+			foreach (TableCell visibleCell in _visibleCells)
+			{
+				UnityEngine.Object.Destroy(visibleCell.gameObject);
+			}
+			foreach (KeyValuePair<string, List<TableCell>> reusableCell in _reusableCells)
+			{
+				List<TableCell> value = reusableCell.Value;
+				foreach (TableCell item in value)
+				{
+					UnityEngine.Object.Destroy(item.gameObject);
+				}
+			}
+			_visibleCells.Clear();
+			_reusableCells.Clear();
+			_selectedRows.Clear();
+			_numberOfRows = _dataSource.NumberOfRows();
+			_rowHeight = _dataSource.RowHeight();
+			RefreshContentSize();
+			RefreshCells(true);
+			RefreshScrollButtons();
+		}
+
+		public TableCell DequeueReusableCellForIdentifier(string identifier)
+		{
+			TableCell result = null;
+			List<TableCell> value = null;
+			if (_reusableCells.TryGetValue(identifier, out value) && value.Count > 0)
+			{
+				result = value[0];
+				value.RemoveAt(0);
+			}
+			return result;
+		}
+
+		public void SelectRow(int row)
+		{
+			foreach (TableCell visibleCell in _visibleCells)
+			{
+				visibleCell.ChangeSelection(false, TableCell.TransitionType.Instant, false, false);
+			}
+			_selectedRows.Clear();
+			_selectedRows.Add(row);
+			RefreshCells(true);
+		}
+
+		public void ClearSelection()
+		{
+			foreach (TableCell visibleCell in _visibleCells)
+			{
+				visibleCell.ChangeSelection(false, TableCell.TransitionType.Instant, false, false);
+			}
+			_selectedRows.Clear();
+			RefreshCells(true);
+		}
+
+		public void ScrollToRow(int row, bool animated)
+		{
+			float height = _scrollRectTransform.rect.height;
+			float num = (float)_numberOfRows * _rowHeight - height;
+			int num2 = Mathf.FloorToInt(height / _rowHeight);
+			float num3 = (float)(row + 1 + num2 / 2) * _rowHeight;
+			float num4 = (_targetVerticalNormalizedPosition = Mathf.Max(0f, 1f - Mathf.Max(0f, num3 - height) / num));
+			if (!animated)
+			{
+				_scrollRect.verticalNormalizedPosition = _targetVerticalNormalizedPosition;
+			}
+			RefreshScrollButtons();
+		}
+
+		private void Update()
+		{
+			float height = _scrollRectTransform.rect.height;
+			float b = (float)_numberOfRows * _rowHeight - height;
+			if (Mathf.Abs(_targetVerticalNormalizedPosition - _scrollRect.verticalNormalizedPosition) < 0.1f / Mathf.Max(1f, b))
+			{
+				if (_targetVerticalNormalizedPosition != _scrollRect.verticalNormalizedPosition)
+				{
+					_scrollRect.verticalNormalizedPosition = _targetVerticalNormalizedPosition;
+				}
+			}
+			else
+			{
+				_scrollRect.verticalNormalizedPosition = Mathf.Lerp(_scrollRect.verticalNormalizedPosition, _targetVerticalNormalizedPosition, Time.deltaTime * 8f);
+			}
+		}
+
+		private float GetScrollStep()
+		{
+			float height = _scrollRectTransform.rect.height;
+			float num = (float)_numberOfRows * _rowHeight - height;
+			int num2 = Mathf.CeilToInt(num / _rowHeight);
+			return 1f / (float)num2;
+		}
+
+		private float GetNumberOfVisibleRows()
+		{
+			float height = _scrollRectTransform.rect.height;
+			return Mathf.CeilToInt(height / _rowHeight);
+		}
+
+		public void PageScrollUp()
+		{
+			float scrollStep = GetScrollStep();
+			_targetVerticalNormalizedPosition = (float)Mathf.RoundToInt(_targetVerticalNormalizedPosition / scrollStep + Mathf.Max(1f, GetNumberOfVisibleRows() - 1f)) * scrollStep;
+			if (_targetVerticalNormalizedPosition > 1f)
+			{
+				_targetVerticalNormalizedPosition = 1f;
+			}
+			RefreshScrollButtons();
+		}
+
+		public void PageScrollDown()
+		{
+			float scrollStep = GetScrollStep();
+			_targetVerticalNormalizedPosition = (float)Mathf.RoundToInt(_targetVerticalNormalizedPosition / scrollStep - Mathf.Max(1f, GetNumberOfVisibleRows() - 1f)) * scrollStep;
+			if (_targetVerticalNormalizedPosition < 0f)
+			{
+				_targetVerticalNormalizedPosition = 0f;
+			}
+			RefreshScrollButtons();
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/HMUI/Toggle.cs b/OldschoolBeatSaber/Scripts/HMUI/Toggle.cs
new file mode 100644
index 0000000..9039d53
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/HMUI/Toggle.cs
@@ -0,0 +1,124 @@
+using OldschoolBeatSaber.Utilities;
+using System;
+using TMPro;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace HMUI
+{
+	public class Toggle : UIBehaviour, IPointerClickHandler, ISubmitHandler, IPointerEnterHandler, IPointerExitHandler, IEventSystemHandler
+	{
+		[SerializeField]
+		private string _onText;
+
+		[SerializeField]
+		private string _offText;
+
+		[SerializeField]
+		private Color _onTextColor = Color.black;
+
+		[SerializeField]
+		private Color _offTextColor = Color.white;
+
+		[SerializeField]
+		private Color _highlightColor = Color.gray;
+
+		[SerializeField]
+		private Color _selectedColor = Color.white;
+
+		[Space]
+		[SerializeField]
+		private UnityEngine.UI.Image _offImage;
+
+		[SerializeField]
+		private UnityEngine.UI.Image _onImage;
+
+		[SerializeField]
+		private TextMeshProUGUI _offTextUI;
+
+		[SerializeField]
+		private TextMeshProUGUI _onTextUI;
+
+        private Signal _uiButtonWasPressedSignal;
+
+        private bool _isOn;
+
+		private bool _isHighlighted;
+
+		public bool isOn
+		{
+			get
+			{
+				return _isOn;
+			}
+			set
+			{
+				_isOn = value;
+				RefreshColors();
+			}
+		}
+
+		public event Action<Toggle, bool> didSwitchEvent;
+
+		protected override void Start()
+		{
+			base.Start();
+            if (_uiButtonWasPressedSignal == null)
+                _uiButtonWasPressedSignal = ResourceUtility.Find<Signal>("UIButtonWasPressed");
+            _offTextUI.text = _offText;
+			_onTextUI.text = _onText;
+			RefreshColors();
+		}
+
+		private void InternalToggle()
+		{
+			if (IsActive())
+			{
+				_isOn = !_isOn;
+				RefreshColors();
+				if (this.didSwitchEvent != null)
+				{
+					this.didSwitchEvent(this, _isOn);
+				}
+			}
+		}
+
+		private void RefreshColors()
+		{
+			_offTextUI.color = (_isOn ? _offTextColor : _onTextColor);
+			_onTextUI.color = ((!_isOn) ? _offTextColor : _onTextColor);
+			_onImage.color = (_isOn ? _selectedColor : ((!_isHighlighted) ? Color.clear : _highlightColor));
+			_offImage.color = ((!_isOn) ? _selectedColor : ((!_isHighlighted) ? Color.clear : _highlightColor));
+		}
+
+		public virtual void OnPointerClick(PointerEventData eventData)
+		{
+			if (eventData.button == PointerEventData.InputButton.Left)
+			{
+				InternalToggle();
+				if (_uiButtonWasPressedSignal != null)
+                    _uiButtonWasPressedSignal.Raise();
+			}
+		}
+
+		public virtual void OnSubmit(BaseEventData eventData)
+		{
+			InternalToggle();
+			if (_uiButtonWasPressedSignal != null)
+                _uiButtonWasPressedSignal.Raise();
+		}
+
+		public virtual void OnPointerEnter(PointerEventData eventData)
+		{
+			_isHighlighted = true;
+			RefreshColors();
+		}
+
+		public virtual void OnPointerExit(PointerEventData eventData)
+		{
+			_isHighlighted = false;
+			RefreshColors();
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/NullAllowed.cs b/OldschoolBeatSaber/Scripts/NullAllowed.cs
new file mode 100644
index 0000000..22539df
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/NullAllowed.cs
@@ -0,0 +1,5 @@
+using UnityEngine;
+
+public class NullAllowed : PropertyAttribute
+{
+}
diff --git a/OldschoolBeatSaber/Scripts/VRUI/VRUINavigationController.cs b/OldschoolBeatSaber/Scripts/VRUI/VRUINavigationController.cs
new file mode 100644
index 0000000..74148cf
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/VRUI/VRUINavigationController.cs
@@ -0,0 +1,190 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace VRUI
+{
+	public class VRUINavigationController : VRUIViewController
+	{
+		protected List<VRUIViewController> _viewControllers = new List<VRUIViewController>();
+
+		public static VRUINavigationController CreateNavigationController(VRUIViewController rootViewController)
+		{
+			GameObject gameObject = new GameObject("VRUINavigationController", typeof(RectTransform));
+			gameObject.SetActive(false);
+			VRUINavigationController vRUINavigationController = gameObject.AddComponent<VRUINavigationController>();
+			rootViewController.Init(vRUINavigationController.screen, null, vRUINavigationController);
+			vRUINavigationController._viewControllers.Add(rootViewController);
+			return vRUINavigationController;
+		}
+
+		public void InitWithRootViewController(VRUIViewController rootViewController)
+		{
+			rootViewController.Init(base.screen, null, this);
+			_viewControllers.Add(rootViewController);
+		}
+
+		internal override void SetUserInteraction(bool enabled)
+		{
+			base.SetUserInteraction(enabled);
+			int count = _viewControllers.Count;
+			for (int i = 0; i < count; i++)
+			{
+				_viewControllers[i].SetUserInteraction(enabled);
+			}
+		}
+
+		protected override void DidActivate()
+		{
+			base.DidActivate();
+			LayoutViewControllers(_viewControllers);
+		}
+
+		protected override void DidDeactivate()
+		{
+			base.DidDeactivate();
+		}
+
+		internal override void Init(VRUIScreen screen, VRUIViewController parentViewController, VRUINavigationController navigationController)
+		{
+			base.Init(screen, parentViewController, navigationController);
+			int count = _viewControllers.Count;
+			for (int i = 0; i < count; i++)
+			{
+				_viewControllers[i].Init(screen, parentViewController, this);
+			}
+		}
+
+		internal override void ResetViewController()
+		{
+			base.ResetViewController();
+			int count = _viewControllers.Count;
+			for (int i = 0; i < count; i++)
+			{
+				_viewControllers[i].ResetViewController();
+			}
+			_viewControllers.Clear();
+		}
+
+		internal override void Activate(bool beingPresented, bool movingToParentController)
+		{
+			base.Activate(beingPresented, movingToParentController);
+			int count = _viewControllers.Count;
+			for (int i = 0; i < count; i++)
+			{
+				_viewControllers[i].Activate(beingPresented, movingToParentController);
+			}
+		}
+
+		internal override void Deactivate(bool beingDismissed, bool movingFromParentController, bool deactivateGameObject)
+		{
+			base.Deactivate(beingDismissed, movingFromParentController, deactivateGameObject);
+			int count = _viewControllers.Count;
+			for (int i = 0; i < count; i++)
+			{
+				_viewControllers[i].Deactivate(beingDismissed, movingFromParentController, deactivateGameObject);
+			}
+		}
+
+		internal override void DeactivateGameObject()
+		{
+			base.DeactivateGameObject();
+			int count = _viewControllers.Count;
+			for (int i = 0; i < count; i++)
+			{
+				if (_viewControllers[i].gameObject.activeSelf)
+				{
+					_viewControllers[i].gameObject.SetActive(false);
+				}
+			}
+		}
+
+		public virtual void PushViewController(VRUIViewController viewController, bool immediately = false)
+		{
+			if (viewController.GetType().IsSubclassOf(typeof(VRUINavigationController)))
+			{
+				throw new InvalidOperationException("Can not push navigation controller into navigation controller hierarchy.");
+			}
+			if (_viewControllers.IndexOf(viewController) >= 0)
+			{
+				throw new InvalidOperationException("Can not push the same view controller into navigation controller hierarchy more than once.");
+			}
+			StopAllCoroutines();
+			StartCoroutine(PushViewControllerCoroutine(viewController, immediately));
+		}
+
+		private IEnumerator PushViewControllerCoroutine(VRUIViewController viewController, bool immediately)
+		{
+			viewController.SetUserInteraction(false);
+			_viewControllers.Add(viewController);
+			viewController.Init(base.screen, base.parentViewController, this);
+			float moveOffset = 4f / base.transform.lossyScale.x;
+			viewController.transform.localPosition = new Vector3(moveOffset, 0f, 0f);
+			viewController.Activate(false, true);
+			float[] positions = GetNewXPositionsForViewControllers(_viewControllers);
+			int numberOfViewControllers = _viewControllers.Count;
+			if (!immediately)
+			{
+				float transitionDuration = 0.4f;
+				float elapsedTime = 0f;
+				float[] startXPositions = new float[numberOfViewControllers];
+				for (int i = 0; i < numberOfViewControllers; i++)
+				{
+					startXPositions[i] = _viewControllers[i].transform.localPosition.x;
+				}
+				while (elapsedTime < transitionDuration)
+				{
+					float t = elapsedTime / transitionDuration;
+					for (int j = 0; j < numberOfViewControllers; j++)
+					{
+						float x = Mathf.Lerp(startXPositions[j], positions[j], 1f - Mathf.Pow(1f - t, 3f));
+						_viewControllers[j].transform.localPosition = new Vector3(x, 0f, 0f);
+					}
+					elapsedTime += Time.deltaTime;
+					yield return null;
+				}
+			}
+			for (int k = 0; k < numberOfViewControllers; k++)
+			{
+				_viewControllers[k].transform.localPosition = new Vector3(positions[k], 0f, 0f);
+			}
+			viewController.SetUserInteraction(true);
+		}
+
+		public virtual void PopViewController(bool immediately)
+		{
+		}
+
+		private void LayoutViewControllers(List<VRUIViewController> viewControllers)
+		{
+			float[] newXPositionsForViewControllers = GetNewXPositionsForViewControllers(viewControllers);
+			int count = viewControllers.Count;
+			for (int i = 0; i < count; i++)
+			{
+				viewControllers[i].transform.localPosition = new Vector3(newXPositionsForViewControllers[i], 0f, 0f);
+			}
+		}
+
+		private float[] GetNewXPositionsForViewControllers(List<VRUIViewController> viewControllers)
+		{
+			int count = viewControllers.Count;
+			float[] array = new float[count];
+			float num = 0f;
+			for (int i = 0; i < count; i++)
+			{
+				RectTransform component = viewControllers[i].GetComponent<RectTransform>();
+				num += component.rect.width * component.localScale.x;
+			}
+			float num2 = 0.05f;
+			float num3 = (0f - (num + num2 * (float)(count - 1))) * 0.5f;
+			for (int j = 0; j < count; j++)
+			{
+				RectTransform component2 = viewControllers[j].GetComponent<RectTransform>();
+				array[j] = num3 + component2.rect.width * component2.localScale.x * 0.5f;
+				num3 += component2.rect.width * component2.localScale.x + num2;
+			}
+			return array;
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/VRUI/VRUIScreen.cs b/OldschoolBeatSaber/Scripts/VRUI/VRUIScreen.cs
new file mode 100644
index 0000000..698a5e5
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/VRUI/VRUIScreen.cs
@@ -0,0 +1,52 @@
+using UnityEngine;
+
+namespace VRUI
+{
+	[RequireComponent(typeof(RectTransform))]
+	public class VRUIScreen : MonoBehaviour
+	{
+		private VRUIViewController _rootViewController;
+
+		public VRUIScreenSystem screenSystem { get; set; }
+
+		public VRUIViewController rootViewController
+		{
+			get
+			{
+				return _rootViewController;
+			}
+		}
+
+		public void SetRootViewController(VRUIViewController rootViewController)
+		{
+			if (rootViewController == _rootViewController)
+			{
+				return;
+			}
+			if (_rootViewController != null)
+			{
+				_rootViewController.Deactivate(true, false, true);
+				_rootViewController.ResetViewController();
+			}
+			_rootViewController = rootViewController;
+			if (_rootViewController != null)
+			{
+				Vector3 localScale = _rootViewController.transform.localScale;
+				if (_rootViewController.transform.parent != base.transform)
+				{
+					_rootViewController.transform.SetParent(base.transform, false);
+				}
+				_rootViewController.transform.localScale = localScale;
+				_rootViewController.transform.localPosition = Vector3.zero;
+				Vector3 position = base.transform.position;
+				_rootViewController.transform.rotation = Quaternion.LookRotation(base.transform.forward, Vector3.up);
+				if (!_rootViewController.gameObject.activeSelf)
+				{
+					_rootViewController.gameObject.SetActive(true);
+				}
+				_rootViewController.Init(this, null, null);
+				_rootViewController.Activate(true, false);
+			}
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/VRUI/VRUIScreenSystem.cs b/OldschoolBeatSaber/Scripts/VRUI/VRUIScreenSystem.cs
new file mode 100644
index 0000000..e4e50de
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/VRUI/VRUIScreenSystem.cs
@@ -0,0 +1,47 @@
+using UnityEngine;
+
+namespace VRUI
+{
+	public class VRUIScreenSystem : MonoBehaviour
+	{
+		[SerializeField]
+		private VRUIScreen _mainScreen;
+
+		[SerializeField]
+		private VRUIScreen _leftScreen;
+
+		[SerializeField]
+		private VRUIScreen _rightScreen;
+
+		public VRUIScreen mainScreen
+		{
+			get
+			{
+				return _mainScreen;
+			}
+		}
+
+		public VRUIScreen leftScreen
+		{
+			get
+			{
+				return _leftScreen;
+			}
+		}
+
+		public VRUIScreen rightScreen
+		{
+			get
+			{
+				return _rightScreen;
+			}
+		}
+
+		private void Awake()
+		{
+			_mainScreen.screenSystem = this;
+			_leftScreen.screenSystem = this;
+			_rightScreen.screenSystem = this;
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Scripts/VRUI/VRUIViewController.cs b/OldschoolBeatSaber/Scripts/VRUI/VRUIViewController.cs
new file mode 100644
index 0000000..0d81fc7
--- /dev/null
+++ b/OldschoolBeatSaber/Scripts/VRUI/VRUIViewController.cs
@@ -0,0 +1,243 @@
+using System;
+using System.Collections;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace VRUI
+{
+	[RequireComponent(typeof(RectTransform))]
+	public class VRUIViewController : MonoBehaviour
+	{
+		private VRUINavigationController _navigationController;
+
+		private VRUIViewController _parentViewController;
+
+		private VRUIViewController _childViewController;
+
+		private VRUIScreen _screen;
+
+		private BaseRaycaster _raycaster;
+
+		private RectTransform _rectTransform;
+
+		public VRUINavigationController navigationController
+		{
+			get
+			{
+				return _navigationController;
+			}
+		}
+
+		public VRUIScreen screen
+		{
+			get
+			{
+				return _screen;
+			}
+		}
+
+		public VRUIViewController parentViewController
+		{
+			get
+			{
+				return _parentViewController;
+			}
+		}
+
+		public VRUIViewController childViewController
+		{
+			get
+			{
+				return _childViewController;
+			}
+		}
+
+		public RectTransform rectTransform
+		{
+			get
+			{
+				return _rectTransform;
+			}
+		}
+
+		public bool controllerActive { get; private set; }
+
+		public bool beingPresented { get; private set; }
+
+		public bool beingDismissed { get; private set; }
+
+		public bool movingToParentController { get; private set; }
+
+		public bool movingFromParentController { get; private set; }
+
+		protected virtual void Awake()
+		{
+			_rectTransform = GetComponent<RectTransform>();
+			_raycaster = GetComponent<BaseRaycaster>();
+		}
+
+		internal virtual void SetUserInteraction(bool enabled)
+		{
+			if (_raycaster != null)
+			{
+				_raycaster.enabled = enabled;
+			}
+		}
+
+		protected virtual void DidActivate()
+		{
+		}
+
+		protected virtual void DidDeactivate()
+		{
+		}
+
+		internal virtual void Init(VRUIScreen screen, VRUIViewController parentViewController, VRUINavigationController navigationController)
+		{
+			_screen = screen;
+			_parentViewController = parentViewController;
+			_navigationController = navigationController;
+			if (_navigationController != null)
+			{
+				base.transform.SetParent(navigationController.transform, false);
+				base.transform.SetSiblingIndex(0);
+			}
+			else
+			{
+				base.transform.SetParent(screen.transform, false);
+			}
+		}
+
+		internal virtual void ResetViewController()
+		{
+			base.transform.SetParent(_screen.transform, false);
+			_screen = null;
+			_parentViewController = null;
+			_navigationController = null;
+			_childViewController = null;
+		}
+
+		public void PresentModalViewController(VRUIViewController viewController, Action finishedCallback, bool immediately = false)
+		{
+			if (_childViewController != null)
+			{
+				throw new InvalidOperationException("Can not present new view controller. This view controller is already presenting one.");
+			}
+			StartCoroutine(PresentModalViewControllerCoroutine(viewController, finishedCallback, immediately));
+		}
+
+		private IEnumerator PresentModalViewControllerCoroutine(VRUIViewController viewController, Action finishedCallback, bool immediately)
+		{
+			EventSystem eventSystem = EventSystem.current;
+			eventSystem.SetSelectedGameObject(null);
+			SetUserInteraction(false);
+			float transitionDuration = 0.4f;
+			float elapsedTime = 0f;
+			Deactivate(false, false, false);
+			if (!viewController.gameObject.activeSelf)
+			{
+				viewController.gameObject.SetActive(true);
+			}
+			viewController.Init(_screen, this, null);
+			viewController.Activate(true, false);
+			viewController.SetUserInteraction(false);
+			_childViewController = viewController;
+			float moveOffset = 20f / base.transform.lossyScale.x;
+			if (!immediately)
+			{
+				while (elapsedTime < transitionDuration)
+				{
+					float t = elapsedTime / transitionDuration;
+					viewController.transform.localPosition = Vector3.Lerp(new Vector3(moveOffset, 0f, 0f), Vector3.zero, 1f - Mathf.Pow(1f - t, 3f));
+					base.transform.localPosition = Vector3.Lerp(Vector3.zero, new Vector3(0f - moveOffset, 0f, 0f), Mathf.Pow(t, 3f));
+					elapsedTime += Time.deltaTime;
+					yield return null;
+				}
+			}
+			viewController.transform.localPosition = Vector3.zero;
+			base.transform.localPosition = new Vector3(0f - moveOffset, 0f, 0f);
+			base.gameObject.SetActive(false);
+			viewController.SetUserInteraction(true);
+			if (finishedCallback != null)
+			{
+				finishedCallback();
+			}
+		}
+
+		public void DismissModalViewController(Action finishedCallback, bool immediately = false)
+		{
+			if (_parentViewController == null)
+			{
+				throw new InvalidOperationException("This view controller can not be dismissed, because it does not have any parent.");
+			}
+			StartCoroutine(DismissModalViewControllerCoroutine(finishedCallback, immediately));
+		}
+
+		private IEnumerator DismissModalViewControllerCoroutine(Action finishedCallback, bool immediately)
+		{
+			EventSystem.current.SetSelectedGameObject(null);
+			VRUIViewController movingInViewController = _parentViewController;
+			Transform movingOutObjectTransform = base.transform;
+			SetUserInteraction(false);
+			Deactivate(true, false, false);
+			movingInViewController._childViewController = null;
+			movingInViewController.Activate(false, false);
+			Transform movingInObjectTransform = movingInViewController.transform;
+			float moveOffset = 20f / base.transform.lossyScale.x;
+			if (!immediately)
+			{
+				float transitionDuration = 0.4f;
+				float elapsedTime = 0f;
+				while (elapsedTime < transitionDuration)
+				{
+					float t = elapsedTime / transitionDuration;
+					movingInObjectTransform.localPosition = Vector3.Lerp(new Vector3(0f - moveOffset, 0f, 0f), Vector3.zero, 1f - Mathf.Pow(1f - t, 3f));
+					movingOutObjectTransform.localPosition = Vector3.Lerp(Vector3.zero, new Vector3(moveOffset, 0f, 0f), Mathf.Pow(t, 3f));
+					elapsedTime += Time.deltaTime;
+					yield return null;
+				}
+			}
+			movingInObjectTransform.localPosition = Vector3.zero;
+			movingOutObjectTransform.localPosition = new Vector3(moveOffset, 0f, 0f);
+			DeactivateGameObject();
+			ResetViewController();
+			movingInViewController.SetUserInteraction(true);
+			if (finishedCallback != null)
+			{
+				finishedCallback();
+			}
+		}
+
+		internal virtual void Activate(bool beingPresented, bool movingToParentController)
+		{
+			if (!base.gameObject.activeSelf)
+			{
+				base.gameObject.SetActive(true);
+			}
+			controllerActive = true;
+			this.beingPresented = beingPresented;
+			this.movingToParentController = movingToParentController;
+			DidActivate();
+		}
+
+		internal virtual void Deactivate(bool beingDismissed, bool movingFromParentController, bool deactivateGameObject)
+		{
+			if (base.gameObject.activeSelf && deactivateGameObject)
+			{
+				base.gameObject.SetActive(false);
+			}
+			controllerActive = false;
+			this.beingDismissed = beingDismissed;
+			this.movingFromParentController = movingFromParentController;
+			DidDeactivate();
+		}
+
+		internal virtual void DeactivateGameObject()
+		{
+			if (base.gameObject.activeSelf)
+			{
+				base.gameObject.SetActive(false);
+			}
+		}
+	}
+}
diff --git a/OldschoolBeatSaber/Utilities/ResourceUtility.cs b/OldschoolBeatSaber/Utilities/ResourceUtility.cs
new file mode 100644
index 0000000..eb04ff2
--- /dev/null
+++ b/OldschoolBeatSaber/Utilities/ResourceUtility.cs
@@ -0,0 +1,211 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.Networking;
+using UnityEngine.UI;
+
+namespace OldschoolBeatSaber.Utilities
+{
+    internal static class ResourceUtility
+    {
+        private static Dictionary<string, UnityEngine.Object> _cachedObjs = new();
+
+        private static Mesh _tubeMesh;
+        public static Mesh TubeMesh => _tubeMesh ??= new Mesh
+        {
+            name = "Tube",
+            vertices = new Vector3[]
+            {
+                new(1, -1, -1),
+                new(1, -1, 1),
+                new(1, 1, -1),
+                new(1, 1, 1),
+                new(-1, -1, -1),
+                new(-1, -1, 1),
+                new(-1, 1, -1),
+                new(-1, 1, 1),
+                new(1, 1, -1),
+                new(1, 1, 1),
+                new(-1, 1, -1),
+                new(-1, 1, 1),
+                new(-1, -1, -1),
+                new(1, -1, -1),
+                new(1, -1, 1),
+                new(-1, -1, 1),
+                new(1, 1, -1),
+                new(1, -1, -1),
+                new(-1, -1, -1),
+                new(-1, 1, -1),
+                new(-1, 1, 1),
+                new(-1, -1, 1),
+                new(1, -1, 1),
+                new(1, 1, 1)
+            },
+            triangles = new[]
+            {
+                0, 2, 3,
+                0, 3, 1,
+                8, 6, 7,
+                8, 7, 9,
+                10, 4, 5,
+                10, 5, 11,
+                12, 13, 14,
+                12, 14, 15,
+                16, 17, 18,
+                16, 18, 19,
+                20, 21, 22,
+                20, 22, 23
+            }
+        };
+
+        private static Material _bigSmokeParticleMaterial;
+        public static Material BigSmokeParticleMaterial => _bigSmokeParticleMaterial ??= FindMaterial("BigSmokeParticle");
+
+        private static Material _darkEnvironmentMaterial;
+        public static Material DarkEnvironmentMaterial => _darkEnvironmentMaterial ??= FindMaterial("DarkEnvironmentSimple");
+
+        private static Material _envLightMaterial;
+        public static Material EnvLightMaterial => _envLightMaterial ??= FindMaterial("EnvLight", "ENABLE_HEIGHT_FOG");
+
+        private static Material _envLightOpaqueMaterial;
+        public static Material EnvLightOpaqueMaterial => _envLightOpaqueMaterial ??= FindMaterial("EnvLightOpaque", "ENABLE_HEIGHT_FOG");
+
+        private static Material _sparkleMaterial;
+        public static Material SparkleMaterial => _sparkleMaterial ??= FindMaterial("Sparkle");
+
+        private static Material _uiNoGlowMaterial;
+        public static Material UINoGlowMaterial => _uiNoGlowMaterial ??= FindMaterial("UINoGlow");
+
+        private static Material _uiFogBGMaterial;
+        public static Material UIFogBGMaterial => _uiFogBGMaterial ??= FindMaterial("UIFogBG");
+
+        public static T Find<T>(string name) where T : UnityEngine.Object
+        {
+            var cachedKey = $"{typeof(T).Name}_{name}";
+            if (_cachedObjs.TryGetValue(cachedKey, out var cachedObj))
+                return (T)cachedObj;
+
+            var obj = Resources.FindObjectsOfTypeAll<T>()
+                .Where(x => x != null)
+                .FirstOrDefault(x => x.name == name);
+            _cachedObjs[cachedKey] = obj;
+
+            return obj;
+        }
+
+        public static Material FindMaterial(string name, params string[] disabledKeywords)
+        {
+            var material = Find<Material>(name);
+            if (material != null && disabledKeywords != null && disabledKeywords.Length > 0)
+            {
+                material = UnityEngine.Object.Instantiate(material);
+                foreach (var disabledKeyword in disabledKeywords)
+                {
+                    material.DisableKeyword(disabledKeyword);
+                }
+            }
+            return material;
+        }
+
+        public static void ReplaceMaterialsInChildren(this GameObject gameObject)
+        {
+            foreach (var renderer in gameObject.GetComponentsInChildren<Renderer>(true))
+            {
+                ReplaceRendererMaterials(renderer);
+            }
+
+            foreach (var image in gameObject.GetComponentsInChildren<Image>(true))
+            {
+                ReplaceImageMaterial(image);
+            }
+        }
+
+        // UIFogBG
+
+        private static void ReplaceRendererMaterials(Renderer renderer)
+        {
+            var materials = renderer.materials;
+            var materialsUpdated = false;
+            for (var i = 0; i < materials.Length; i++)
+            {
+                switch (materials[i].name)
+                {
+                    case "_Replace_DarkEnvironment (Instance)":
+                        materials[i] = DarkEnvironmentMaterial;
+                        materialsUpdated = true;
+                        break;
+
+                    case "_Replace_EnvLightOpaque (Instance)":
+                        materials[i] = EnvLightOpaqueMaterial;
+                        materialsUpdated = true;
+                        break;
+
+                    case "_Replace_EnvLight (Instance)":
+                        materials[i] = EnvLightMaterial;
+                        materialsUpdated = true;
+                        break;
+
+                    case "_Replace_Sparkle (Instance)":
+                        materials[i] = SparkleMaterial;
+                        materialsUpdated = true;
+                        break;
+                }
+            }
+
+            if (materialsUpdated)
+                renderer.sharedMaterials = materials;
+        }
+
+        private static void ReplaceImageMaterial(Image image)
+        {
+            switch (image.material.name)
+            {
+                case "_Replace_UINoGlow":
+                    image.material = UINoGlowMaterial;
+                    break;
+
+                case "_Replace_UIFogBG":
+                    image.material = UIFogBGMaterial;
+                    break;
+            }
+        }
+
+        public static AudioClip GetAudioClip(string filePath)
+        {
+            using (var www = UnityWebRequestMultimedia.GetAudioClip(FileHelpers.GetEscapedURLForFilePath(filePath), AudioType.UNKNOWN))
+            {
+                var request = www.SendWebRequest();
+                while (!request.isDone)
+                { }
+
+                if (!www.isNetworkError)
+                {
+                    var audioClip = DownloadHandlerAudioClip.GetContent(www);
+                    if (audioClip != null && audioClip.loadState == AudioDataLoadState.Loaded)
+                        return audioClip;
+                }
+            }
+
+            return null;
+        }
+
+        public static AudioClip GetEmbeddedResourceAudioClip(string fileName)
+        {
+            var audioPath = Path.Combine(Plugin.AudioPath, fileName);
+
+            using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream($"OldschoolBeatSaber.Resources.{fileName}"))
+            {
+                File.Delete(audioPath);
+
+                using (var fileStream = new FileStream(audioPath, FileMode.CreateNew))
+                {
+                    stream.CopyTo(fileStream);
+                }
+            }
+
+            return GetAudioClip(audioPath);
+        }
+    }
+}
diff --git a/OldschoolBeatSaber/manifest.json b/OldschoolBeatSaber/manifest.json
new file mode 100644
index 0000000..4055b0e
--- /dev/null
+++ b/OldschoolBeatSaber/manifest.json
@@ -0,0 +1,12 @@
+{
+  "$schema": "https://raw.githubusercontent.com/bsmg/BSIPA-MetadataFileSchema/master/Schema.json",
+  "id": "OldschoolBeatSaber",
+  "name": "Oldschool Beat Saber",
+  "author": "Kaitlyn",
+  "version": "1.0.0",
+  "description": "Go back in time.",
+  "gameVersion": "1.26.0",
+  "dependsOn": {
+    "BSIPA": "^4.2.2"
+  }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index b03f79a..61c40b1 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,2 @@
-# OldschoolBeatSaber
-Go back in time.
+# Oldschool Beat Saber
+Go back in time. This plugin lets you re-experience the glory days of Beat Saber from 2018, allowing you to use the 2018 menu environment and UI on latest Beat Saber!