using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppLiv.Lck;
using Il2CppLiv.Lck.UI;
using Il2CppRUMBLE.Interactions.InteractionBase.Extensions;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Recording.LCK;
using Il2CppRUMBLE.Recording.LCK.Extensions;
using Il2CppRUMBLE.Utilities;
using Il2CppTMPro;
using MelonLoader;
using Rock_Cam_Essentials;
using UnityEngine;
using UnityEngine.Rendering.Universal;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Main), "RockCamEssentials", "2.0.1", "Deterraleon", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 200, 0, 200)]
[assembly: MelonAuthorColor(255, 255, 119, 255)]
[assembly: VerifyLoaderVersion(0, 6, 6, true)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Rock Cam Essentials")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a0cfa25ffab32d7a03414ccfdf608640c85e9e51")]
[assembly: AssemblyProduct("Rock Cam Essentials")]
[assembly: AssemblyTitle("Rock Cam Essentials")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Rock_Cam_Essentials;

public class FirstPerson
{
	public LCKCameraController _CameraController;

	public UniversalAdditionalCameraData _CameraSettings;

	public LckCamera _Camera;

	public LCKSettingsButtonsController _POVController;

	public Rock_Cam _rockcam;

	public float PositionalSmoothing
	{
		get
		{
			return _CameraController._firstPersonStabilizer.PositionalSmoothing;
		}
		set
		{
			SetPositionalSmooting(value);
		}
	}

	public float RotationalSmoothing
	{
		get
		{
			return _CameraController._firstPersonStabilizer.RotationalSmoothing;
		}
		set
		{
			SetRotationalSmooting(value);
		}
	}

	public FirstPerson(Rock_Cam rockcam)
	{
		_rockcam = rockcam;
		_CameraController = rockcam._CameraController;
		_Camera = rockcam._Tablet.firstPersonCamera;
		_CameraSettings = ((Component)rockcam._Tablet.firstPersonCamera).gameObject.GetComponent<UniversalAdditionalCameraData>();
		_POVController = rockcam._POVController;
	}

	public bool SetPOV()
	{
		try
		{
			_POVController.SwitchToFPMode();
			_rockcam.pov = "FP";
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetPositionalSmooting(float smooth)
	{
		if (smooth >= 1f && smooth != 99f)
		{
			MelonLogger.Warning("Smoothing of 1 or greater will result in no movement at all, you can set smoothing to 99 to avoid this message");
		}
		try
		{
			_CameraController._firstPersonStabilizer.PositionalSmoothing = smooth;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetRotationalSmooting(float smooth)
	{
		if (smooth >= 1f && smooth != 99f)
		{
			MelonLogger.Warning("Smoothing of 1 or greater will result in no movement at all, you can set smoothing to 99 to avoid this message");
		}
		try
		{
			_CameraController._firstPersonStabilizer.RotationalSmoothing = smooth;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	public bool DoPostProcessing(bool value)
	{
		try
		{
			_CameraSettings.renderPostProcessing = value;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}
}
public class Handheld
{
	public LCKCameraController _CameraController;

	public UniversalAdditionalCameraData _CameraSettings;

	public LckCamera _Camera;

	public LCKSettingsButtonsController _POVController;

	public Rock_Cam _rockcam;

	public float PositionalSmoothing
	{
		get
		{
			return _CameraController._selfieStabilizer.PositionalSmoothing;
		}
		set
		{
			SetPositionalSmooting(value);
		}
	}

	public float RotationalSmoothing
	{
		get
		{
			return _CameraController._selfieStabilizer.RotationalSmoothing;
		}
		set
		{
			SetRotationalSmooting(value);
		}
	}

	public bool IsFlipped
	{
		get
		{
			return _CameraController.IsSelfieFront;
		}
		set
		{
			FlipCamera(value);
		}
	}

	public Handheld(Rock_Cam rockcam)
	{
		_rockcam = rockcam;
		_CameraController = rockcam._CameraController;
		_Camera = rockcam._Tablet.selfieCamera;
		_CameraSettings = ((Component)rockcam._Tablet.selfieCamera).gameObject.GetComponent<UniversalAdditionalCameraData>();
		_POVController = rockcam._POVController;
	}

	public bool SetPOV()
	{
		try
		{
			_POVController.SwitchToSelfieMode();
			_rockcam.pov = "HH";
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetPositionalSmooting(float smooth)
	{
		if (smooth >= 1f && smooth != 99f)
		{
			MelonLogger.Warning("Smoothing of 1 or greater will result in no movement at all, you can set smoothing to 99 to avoid this message");
		}
		try
		{
			_CameraController._selfieStabilizer.PositionalSmoothing = smooth;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetRotationalSmooting(float smooth)
	{
		if (smooth >= 1f && smooth != 99f)
		{
			MelonLogger.Warning("Smoothing of 1 or greater will result in no movement at all, you can set smoothing to 99 to avoid this message");
		}
		try
		{
			_CameraController._selfieStabilizer.RotationalSmoothing = smooth;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool FlipCamera(bool flip)
	{
		if (IsFlipped == flip)
		{
			MelonLogger.Msg("HH camera already flipped the right way");
			return true;
		}
		try
		{
			_CameraController.ProcessSelfieFlip();
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetRelativeCameraPosition(Vector3 position, Vector3 rotation)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			_CameraController.SetSelfieCameraOrientation(position, rotation);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetGlobalCameraPosition(Vector3 position, Quaternion rotation)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Vector3 val = _rockcam.RockCamTransform.InverseTransformPoint(position);
			Quaternion val2 = Quaternion.Inverse(_rockcam.RockCamTransform.rotation) * rotation;
			_CameraController.SetSelfieCameraOrientation(val, ((Quaternion)(ref val2)).eulerAngles);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool DoPostProcessing(bool value)
	{
		try
		{
			_CameraSettings.renderPostProcessing = value;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}
}
public class HandleBars
{
	public InteractionHoldableGroup _Handles;

	public int isHeld = 0;

	public int isDoubleHeld = 0;

	public HandleBars(Rock_Cam rockcam)
	{
		_Handles = rockcam._Tablet.InteractionHoldableGroup;
	}

	public int isHeldUpdate()
	{
		try
		{
			if (_Handles.GroupIsBeingHeld() != (isHeld % 2 == 1))
			{
				isHeld = 2;
			}
			else
			{
				isHeld = 0;
			}
			if (_Handles.GroupIsBeingHeld())
			{
				isHeld++;
			}
			return isHeld;
		}
		catch (Exception ex)
		{
			MelonLogger.Msg("Hai");
			MelonLogger.Error((object)ex);
			return isHeld;
		}
	}

	public int isDoubleHeldUpdate()
	{
		try
		{
			if (_Handles.DualHoldingObject != (isDoubleHeld % 2 == 1))
			{
				isDoubleHeld = 2;
			}
			else
			{
				isDoubleHeld = 0;
			}
			if (_Handles.DualHoldingObject)
			{
				isDoubleHeld++;
			}
			return isDoubleHeld;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return isDoubleHeld;
		}
	}
}
public static class BuildInfo
{
	public const string ModName = "RockCamEssentials";

	public const string ModVersion = "2.0.1";

	public const string Author = "Deterraleon";
}
public class Main : MelonMod
{
	private string currentScene = "Loader";

	private bool enabled = true;

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		currentScene = sceneName;
	}

	public override void OnLateInitializeMelon()
	{
	}
}
public class Rock_Cam
{
	public struct POVNames
	{
		public string ThirdPerson;

		public string FirstPerson;

		public string Handheld;
	}

	public struct RecordingSettings
	{
		public uint width;

		public uint height;

		public uint audioBitrate;

		public uint Bitrate;

		public uint framerate;

		public static bool operator ==(RecordingSettings a, RecordingSettings b)
		{
			return a.width == b.width && a.height == b.height && a.audioBitrate == b.audioBitrate && a.Bitrate == b.Bitrate && a.framerate == b.framerate;
		}

		public static bool operator !=(RecordingSettings a, RecordingSettings b)
		{
			return !(a == b);
		}
	}

	[CompilerGenerated]
	private sealed class <innertester>d__0 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Rock_Cam <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <innertester>d__0(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Expected O, but got Unknown
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Expected O, but got Unknown
			//IL_0883: Unknown result type (might be due to invalid IL or missing references)
			//IL_088d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0892: Unknown result type (might be due to invalid IL or missing references)
			//IL_0974: Unknown result type (might be due to invalid IL or missing references)
			//IL_0979: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Expected O, but got Unknown
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Expected O, but got Unknown
			//IL_06d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Expected O, but got Unknown
			//IL_0821: Unknown result type (might be due to invalid IL or missing references)
			//IL_082b: Expected O, but got Unknown
			//IL_0927: Unknown result type (might be due to invalid IL or missing references)
			//IL_0931: Expected O, but got Unknown
			//IL_0a0e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a18: Expected O, but got Unknown
			//IL_0b06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b10: Expected O, but got Unknown
			//IL_0c13: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c1d: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.TabletSpawnDelay = 5f;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Commensing part one of the general RCE test, firstly check that the tablet takes 5 seconds to appear after getting despawned");
				goto IL_014d;
			case 1:
				<>1__state = -1;
				goto IL_014d;
			case 2:
				<>1__state = -1;
				goto IL_0188;
			case 3:
				<>1__state = -1;
				goto IL_0287;
			case 4:
				<>1__state = -1;
				goto IL_02d5;
			case 5:
				<>1__state = -1;
				<>4__this.IsRecording = false;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the recording has ended after 2 seconds");
				<>4__this.MaxDespawnDistance = 10000;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the tablet takes despawns instead of teleporting to you if you are far away");
				<>4__this.IsShownUpdate();
				goto IL_0384;
			case 6:
				<>1__state = -1;
				goto IL_0384;
			case 7:
				<>1__state = -1;
				goto IL_03e7;
			case 8:
				<>1__state = -1;
				<>4__this.HideTablet();
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 9;
				return true;
			case 9:
				<>1__state = -1;
				<>4__this.ShowTablet();
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the tablet was shown, then hidden, then shown again in 2 second intervals");
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 10;
				return true;
			case 10:
				<>1__state = -1;
				<>4__this.SetGlobalPositionalSmoothing(1f);
				<>4__this.SetGlobalRotationalSmoothing(0.9f);
				<>4__this.handheld.SetPOV();
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera is in handheld, while not following your hand movements and turning very slowly, the next step will begin when you switch the pov");
				goto IL_052a;
			case 11:
				<>1__state = -1;
				goto IL_052a;
			case 12:
				<>1__state = -1;
				goto IL_05fc;
			case 13:
				<>1__state = -1;
				goto IL_06a6;
			case 14:
				<>1__state = -1;
				<>4__this.firstPerson.SetPOV();
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera switched to first person after 1.5 seconds");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("This concludes first person testing");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Switch to handheld pov to go to the next step");
				<>4__this.POVUpdate();
				goto IL_0771;
			case 15:
				<>1__state = -1;
				goto IL_0771;
			case 16:
				<>1__state = -1;
				goto IL_07f5;
			case 17:
				<>1__state = -1;
				<>4__this.handheld.SetPOV();
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera switched to first person after 1.5 seconds");
				<>4__this.handheld.PositionalSmoothing = 0f;
				<>4__this.handheld.SetRelativeCameraPosition(Vector3.one * 5f, Vector3.zero);
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera moves normally and is also offset from the tablet");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("To go to the next step switch to any other pov");
				<>4__this.POVUpdate();
				goto IL_08fb;
			case 18:
				<>1__state = -1;
				goto IL_08fb;
			case 19:
				<>1__state = -1;
				<>4__this.handheld.SetPOV();
				<>4__this.handheld.PositionalSmoothing = 1f;
				<>4__this.handheld.SetGlobalCameraPosition(Vector3.zero, Quaternion.identity);
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera is at 0,0,0");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("To go to the next step switch to any other pov");
				<>4__this.POVUpdate();
				goto IL_09e2;
			case 20:
				<>1__state = -1;
				goto IL_09e2;
			case 21:
				<>1__state = -1;
				<>4__this.handheld.SetPOV();
				<>4__this.handheld.SetRelativeCameraPosition(Vector3.zero, Vector3.zero);
				<>4__this.handheld.IsFlipped = true;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera is flipped");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("This concludes the handheld tests");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("To go to the next step switch to any other pov");
				<>4__this.POVUpdate();
				goto IL_0ada;
			case 22:
				<>1__state = -1;
				goto IL_0ada;
			case 23:
				<>1__state = -1;
				<>4__this.thirdPerson.SetPOV();
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera is in third person and isn't moving and very slowly turns");
				<>4__this.thirdPerson.Distance = 5f;
				<>4__this.thirdPerson.Angle = 50f;
				<>4__this.thirdPerson.DistanceMultipier = 5f;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera is kinda far, at a steep angle and changing the distance setting greately affects the camera distance");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("To go to the next step switch to any other pov");
				<>4__this.POVUpdate();
				goto IL_0be7;
			case 24:
				<>1__state = -1;
				goto IL_0be7;
			case 25:
				{
					<>1__state = -1;
					<>4__this.thirdPerson.SetPOV();
					<>4__this.thirdPerson.IsFlipped = true;
					((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera is flipped");
					((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("This concludes the third person tests");
					return false;
				}
				IL_0be7:
				if (<>4__this.pov == <>4__this.POVs.ThirdPerson)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 24;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 25;
				return true;
				IL_014d:
				if (<>4__this.isShown % 2 == 1)
				{
					<>4__this.IsShownUpdate();
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_0188;
				IL_0ada:
				if (<>4__this.pov == <>4__this.POVs.Handheld)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 22;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(1.5f);
				<>1__state = 23;
				return true;
				IL_02d5:
				if (!<>4__this.IsRecording)
				{
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 5;
				return true;
				IL_09e2:
				if (<>4__this.pov == <>4__this.POVs.Handheld)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 20;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 21;
				return true;
				IL_08fb:
				if (<>4__this.pov == <>4__this.POVs.Handheld)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 18;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 19;
				return true;
				IL_0771:
				if (<>4__this.pov != <>4__this.POVs.Handheld)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 15;
					return true;
				}
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera doesn't move and rotates slowly");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("To go to the next step switch to any other pov");
				<>4__this.POVUpdate();
				goto IL_07f5;
				IL_0384:
				if (<>4__this.isShown % 2 == 1)
				{
					<>4__this.IsShownUpdate();
					<>2__current = null;
					<>1__state = 6;
					return true;
				}
				<>4__this.SpawnYOffset = 10f;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera spawns rly high");
				goto IL_03e7;
				IL_07f5:
				if (<>4__this.pov == <>4__this.POVs.Handheld)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 16;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(1.5f);
				<>1__state = 17;
				return true;
				IL_03e7:
				if (<>4__this.isShown % 2 == 0)
				{
					<>4__this.IsShownUpdate();
					<>2__current = null;
					<>1__state = 7;
					return true;
				}
				<>4__this.SpawnYOffset = 0f;
				<>4__this.TabletSpawnDelay = 0f;
				<>4__this.ShowTablet();
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 8;
				return true;
				IL_0287:
				if (!<>4__this.detachedPreviewChanged)
				{
					<>4__this.UpdateDetachedPreview();
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				<>4__this.TakePhoto();
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the photo has been taken, start a recording to go to the next step");
				goto IL_02d5;
				IL_0188:
				if (<>4__this.isShown % 2 == 0)
				{
					<>4__this.IsShownUpdate();
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("check that FOV is at 10, increasing the FOV makes it go to 110 and you can't increase it further, decreasing the fov makes it go to 10, then to 5");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Check that photo timer is at 15, pressing it makes it go to 18, then to 0");
				<>4__this.MaxFOV = 110;
				<>4__this.FOVStep = 100;
				<>4__this.MinFOV = 5;
				<>4__this.FOV = 10;
				<>4__this.PhotoTimerMaxValue = 19;
				<>4__this.PhotoTimerIncrement = 3;
				<>4__this.PhotoTimer = 15;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Check that detached preview is at the latest one, press the detached preview button to go to the next step");
				<>4__this.DetachedPreview = 5;
				<>4__this.UpdateDetachedPreview();
				<>4__this.UpdateDetachedPreview();
				goto IL_0287;
				IL_052a:
				if (<>4__this.pov == "HH")
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 11;
					return true;
				}
				if (!<>4__this.povChanged)
				{
					((MelonBase)Melon<Main>.Instance).LoggerInstance.Warning("povChanged is false, should be true");
				}
				<>4__this.ResetCameraPosition();
				<>4__this.handheld.SetPOV();
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera has snapped to the tablet");
				<>4__this.MaximumRenderDistance = 0f;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the image on rockcam has stopped updating, switch to first person to go to first person testing");
				<>4__this.POVUpdate();
				goto IL_05fc;
				IL_05fc:
				if (<>4__this.pov != <>4__this.POVs.FirstPerson)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 12;
					return true;
				}
				<>4__this.MaximumRenderDistance = 10f;
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("This concludes the general RCE test.");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("Assert that the camera doesn't move and rotates slowly");
				((MelonBase)Melon<Main>.Instance).LoggerInstance.Msg("To go to the next step switch to any other pov");
				<>4__this.POVUpdate();
				goto IL_06a6;
				IL_06a6:
				if (<>4__this.pov == <>4__this.POVs.FirstPerson)
				{
					<>4__this.POVUpdate();
					<>2__current = null;
					<>1__state = 13;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(1.5f);
				<>1__state = 14;
				return true;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public ThirdPerson thirdPerson;

	public FirstPerson firstPerson;

	public Handheld handheld;

	public HandleBars handleBars;

	public LckDoubleButton _FOVSetter;

	public bool detachedPreviewChanged = false;

	public int _oldDetachedPreview = 0;

	public PlayerLIV _Camera;

	public LCKTabletUtility _Tablet;

	public LCKCameraController _CameraController;

	public LCKSettingsButtonsController _POVController;

	public Il2CppReferenceArray<Transform> DetachedMonitors;

	public Transform RockCamTransform;

	public ILckService _LckService;

	public int isShown = 1;

	public string pov = "HH";

	public bool povChanged = false;

	public LCKTabletDetachedPreview _DetachedPreviewManager;

	public TMP_Text Nameplate;

	public LckQualitySelector _QualitySelector;

	public POVNames POVs;

	public int FOV
	{
		get
		{
			return (int)_CameraController.GetCurrentModeFOV();
		}
		set
		{
			SetFOV(value);
		}
	}

	public int PhotoTimer
	{
		get
		{
			return _Tablet.photoTimerCurrentValue;
		}
		set
		{
			SetPhotoTimerValue(value);
		}
	}

	public int PhotoTimerIncrement
	{
		get
		{
			return _Tablet.photoTimerIncrementValue;
		}
		set
		{
			_Tablet.photoTimerIncrementValue = value;
		}
	}

	public int PhotoTimerMaxValue
	{
		get
		{
			return _Tablet.photoTimerMaxValue;
		}
		set
		{
			_Tablet.photoTimerMaxValue = value;
		}
	}

	public bool IsRecording
	{
		get
		{
			return _GetRecordingStatus();
		}
		set
		{
			SetRecordingStatus(value);
		}
	}

	public int DetachedPreview
	{
		get
		{
			return _DetachedPreviewManager.ActivePreviewNo;
		}
		set
		{
			_Tablet.lckDetachedPreview.SwitchPreview(value);
		}
	}

	public int MaxDespawnDistance
	{
		get
		{
			return _Camera.maxDespawnDistance;
		}
		set
		{
			_Camera.maxDespawnDistance = value;
		}
	}

	public float SpawnYOffset
	{
		get
		{
			return _Camera.spawnYOffset;
		}
		set
		{
			_Camera.spawnYOffset = value;
		}
	}

	public float TabletSpawnDelay
	{
		get
		{
			return _Camera.tabletSpawnDelay;
		}
		set
		{
			_Camera.tabletSpawnDelay = value;
		}
	}

	public float MaximumRenderDistance
	{
		get
		{
			return _Tablet.maximumRenderDistance;
		}
		set
		{
			_Tablet.maximumRenderDistance = value;
		}
	}

	public int MaxFOV
	{
		get
		{
			return _FOVSetter._maxValue;
		}
		set
		{
			_FOVSetter._maxValue = value;
		}
	}

	public int MinFOV
	{
		get
		{
			return _FOVSetter._minValue;
		}
		set
		{
			_FOVSetter._minValue = value;
		}
	}

	public int FOVStep
	{
		get
		{
			return _FOVSetter._increment;
		}
		set
		{
			_FOVSetter._increment = value;
		}
	}

	[IteratorStateMachine(typeof(<innertester>d__0))]
	private IEnumerator innertester()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <innertester>d__0(0)
		{
			<>4__this = this
		};
	}

	public Rock_Cam()
	{
		POVs.ThirdPerson = "TP";
		POVs.FirstPerson = "FP";
		POVs.Handheld = "HH";
		Fix();
	}

	public void GeneralTest()
	{
		MelonCoroutines.Start(innertester());
	}

	public bool Fix()
	{
		try
		{
			_Camera = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).GetComponentInChildren<PlayerLIV>();
			_Tablet = _Camera.LckTablet;
			MaximumRenderDistance = _Tablet.maximumRenderDistance;
			_CameraController = _Tablet.LckCameraController;
			_FOVSetter = _CameraController.ThirdPersonFOVDoubleButton;
			_POVController = _CameraController._settingsButtonsController;
			thirdPerson = new ThirdPerson(this);
			firstPerson = new FirstPerson(this);
			handheld = new Handheld(this);
			handleBars = new HandleBars(this);
			DetachedMonitors = _CameraController._monitorTransforms;
			PhotoTimer = _Tablet.photoTimerCurrentValue;
			PhotoTimerIncrement = _Tablet.photoTimerIncrementValue;
			PhotoTimerMaxValue = _Tablet.photoTimerMaxValue;
			RockCamTransform = ((Component)_Tablet).transform;
			if (_Camera.TabletVisualsAreActive)
			{
				isShown = 1;
			}
			else
			{
				isShown = 0;
			}
			POVUpdate();
			povChanged = false;
			_LckService = _CameraController._lckService;
			_DetachedPreviewManager = _Tablet.lckDetachedPreview;
			Nameplate = ((Component)_Tablet).gameObject.GetComponent<LCKTabletNameplate>().nameplateTextComponent.textObject;
			_QualitySelector = _CameraController._qualitySelector;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetFOVSettingsSettings(int maxFOV, int minFOV, int step)
	{
		try
		{
			MaxFOV = maxFOV;
			MinFOV = minFOV;
			FOVStep = step;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetFOV(int fov)
	{
		try
		{
			int maxFOV = MaxFOV;
			int fOVStep = FOVStep;
			_FOVSetter._maxValue = 999999;
			_FOVSetter._increment = fov - FOV;
			_FOVSetter.OnPressDownIncrease();
			_FOVSetter.OnPressUpIncrease();
			_FOVSetter._maxValue = maxFOV;
			_FOVSetter._increment = fOVStep;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool TakePhoto()
	{
		try
		{
			_Tablet.TakePhoto();
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	public bool HideTablet()
	{
		try
		{
			_Camera.HideTablet();
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	public bool ShowTablet()
	{
		try
		{
			_Camera.ShowTablet();
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable direclty")]
	public bool StartRecording()
	{
		if (!IsRecording)
		{
			try
			{
				_Tablet.ToggleRecordingAndUpdateRecordStatus();
			}
			catch (Exception ex)
			{
				MelonLogger.Error((object)ex);
				return false;
			}
			return true;
		}
		MelonLogger.Msg("Already recording");
		return true;
	}

	[Obsolete("Just set the variable direclty")]
	public bool EndRecording()
	{
		if (IsRecording)
		{
			try
			{
				_Tablet.ToggleRecordingAndUpdateRecordStatus();
			}
			catch (Exception ex)
			{
				MelonLogger.Error((object)ex);
				return false;
			}
		}
		return true;
	}

	public bool ToggleRecording()
	{
		try
		{
			_Tablet.ToggleRecordingAndUpdateRecordStatus();
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetRecordingStatus(bool value)
	{
		try
		{
			if (value == IsRecording)
			{
				return true;
			}
			_Tablet.ToggleRecordingAndUpdateRecordStatus();
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetGlobalRotationalSmoothing(float smooth)
	{
		thirdPerson.RotationalSmoothing = smooth;
		firstPerson.RotationalSmoothing = smooth;
		handheld.RotationalSmoothing = smooth;
		return true;
	}

	public bool SetGlobalPositionalSmoothing(float smooth)
	{
		thirdPerson.PositionalSmoothing = smooth;
		firstPerson.PositionalSmoothing = smooth;
		handheld.PositionalSmoothing = smooth;
		return true;
	}

	public bool ResetCameraPosition()
	{
		try
		{
			if (pov == "TP")
			{
				_CameraController._thirdPersonStabilizer.ReachTargetInstantly();
			}
			if (pov == "FP")
			{
				_CameraController._firstPersonStabilizer.ReachTargetInstantly();
			}
			if (pov == "HH")
			{
				_CameraController._selfieStabilizer.ReachTargetInstantly();
			}
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetMaximumRenderDistance(float distance)
	{
		try
		{
			_Tablet.maximumRenderDistance = distance;
			MaximumRenderDistance = distance;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetDetachedPreview(int index)
	{
		try
		{
			_Tablet.lckDetachedPreview.SwitchPreview(index);
			UpdateDetachedPreview();
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetPhotoTimerValue(int time)
	{
		try
		{
			int photoTimerMaxValue = PhotoTimerMaxValue;
			int photoTimerIncrement = PhotoTimerIncrement;
			PhotoTimerMaxValue = 999999;
			PhotoTimerIncrement = time - PhotoTimer;
			_Tablet.SwapPhotoTimerDelay();
			PhotoTimerMaxValue = photoTimerMaxValue;
			PhotoTimerIncrement = photoTimerIncrement;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetPhotoTimerIncrement(int increment)
	{
		try
		{
			_Tablet.photoTimerIncrementValue = increment;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetPhotoTimerMaxValue(int maxValue)
	{
		try
		{
			_Tablet.photoTimerMaxValue = maxValue;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetRockCamPosition(Vector3 position, Quaternion rotation)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			((Component)_Tablet).transform.position = position;
			((Component)_Tablet).transform.rotation = rotation;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetSpawnYOffset(float offset)
	{
		try
		{
			_Camera.spawnYOffset = offset;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetRockCamSpawnDelay(float delay)
	{
		try
		{
			_Camera.tabletSpawnDelay = delay;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SnapCameraStabilizerToTarget()
	{
		try
		{
			_CameraController._thirdPersonStabilizer.ReachTargetInstantly();
			_CameraController._firstPersonStabilizer.ReachTargetInstantly();
			_CameraController._selfieStabilizer.ReachTargetInstantly();
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool FullCameraSetup(string pov = "Null", float positional_smoothing = -1f, float rotational_smoothing = -1f, int fov = -1, float TPCameraDistance = -1f, float TPCameraAngle = -1f)
	{
		try
		{
			FOV = fov;
			if (pov == "Null")
			{
				pov = this.pov;
			}
			if (fov == -1)
			{
				fov = FOV;
			}
			switch (pov)
			{
			case "TP":
				thirdPerson.SetPOV();
				if (TPCameraDistance == -1f)
				{
					TPCameraDistance = thirdPerson.Distance;
				}
				thirdPerson.Distance = TPCameraDistance;
				if (TPCameraAngle != -1f)
				{
					thirdPerson.Angle = TPCameraAngle;
				}
				if (positional_smoothing != -1f)
				{
					thirdPerson.PositionalSmoothing = positional_smoothing;
				}
				if (rotational_smoothing != -1f)
				{
					thirdPerson.RotationalSmoothing = rotational_smoothing;
				}
				break;
			case "FP":
				firstPerson.SetPOV();
				if (positional_smoothing != -1f)
				{
					firstPerson.PositionalSmoothing = positional_smoothing;
				}
				if (rotational_smoothing != -1f)
				{
					firstPerson.RotationalSmoothing = rotational_smoothing;
				}
				break;
			case "HH":
				handheld.SetPOV();
				if (positional_smoothing != -1f)
				{
					handheld.PositionalSmoothing = positional_smoothing;
				}
				if (rotational_smoothing != -1f)
				{
					handheld.RotationalSmoothing = rotational_smoothing;
				}
				break;
			default:
				MelonLogger.Error("Failed to find correct pov");
				return false;
			}
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public int IsShownUpdate()
	{
		try
		{
			int num = 0;
			if (isShown % 2 == 1 != _Camera.TabletVisualsAreActive)
			{
				num += 2;
			}
			if (_Camera.TabletVisualsAreActive)
			{
				num++;
			}
			isShown = num;
			return num;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return -1;
		}
	}

	public bool _GetRecordingStatus()
	{
		try
		{
			return _Tablet.recordLightCoroutine != null;
		}
		catch
		{
			return false;
		}
	}

	public bool POVUpdate()
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Invalid comparison between Unknown and I4
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Invalid comparison between Unknown and I4
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Invalid comparison between Unknown and I4
		try
		{
			bool flag = false;
			if ((int)_CameraController.CurrentCameraMode == 2)
			{
				if (pov != "TP")
				{
					flag = true;
				}
				pov = "TP";
			}
			else if ((int)_CameraController.CurrentCameraMode == 1)
			{
				if (pov != "FP")
				{
					flag = true;
				}
				pov = "FP";
			}
			else
			{
				if ((int)_CameraController.CurrentCameraMode != 0)
				{
					MelonLogger.Error("Error determining the POV");
					return false;
				}
				if (pov != "HH")
				{
					flag = true;
				}
				pov = "HH";
			}
			povChanged = flag;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public Vector3 GetSpawnPosition()
	{
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Transform child = ((Component)Singleton<PlayerManager>.Instance.localPlayer.Controller).transform.GetChild(2).GetChild(0).GetChild(0);
			Vector3 position = child.position;
			Vector3 val = new Vector3(child.forward.x, 0f, child.forward.z);
			return position + ((Vector3)(ref val)).normalized + new Vector3(0f, SpawnYOffset, 0f);
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return Vector3.zero;
		}
	}

	public Quaternion GetSpawnRotation()
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Transform child = ((Component)Singleton<PlayerManager>.Instance.localPlayer.Controller).transform.GetChild(2).GetChild(0).GetChild(0);
			Vector3 val = new Vector3(child.forward.x, 0f, child.forward.z);
			return Quaternion.LookRotation(-((Vector3)(ref val)).normalized - new Vector3(0f, SpawnYOffset, 0f));
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return Quaternion.identity;
		}
	}

	public bool SetResolutionDEPRICATED(uint width, uint height)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			CameraResolutionDescriptor trackResolution = default(CameraResolutionDescriptor);
			((CameraResolutionDescriptor)(ref trackResolution))..ctor(width, height);
			_LckService.SetTrackResolution(trackResolution);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetVideoBitrateDEPRICATED(uint bitrate)
	{
		try
		{
			_LckService.SetTrackBitrate(bitrate);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetAudioBitrateDEPRICATED(uint bitrate)
	{
		try
		{
			_LckService.SetTrackAudioBitrate(bitrate);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetFramerateDEPRICATED(uint framerate)
	{
		try
		{
			_LckService.SetTrackFramerate(framerate);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetMicrophoneGainUntestedDEPRICATED(float gain)
	{
		try
		{
			_LckService.SetMicrophoneGain(gain);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool FullRecordingSetupTempDEPRICATED(uint width = 1920u, uint height = 1080u, uint framerate = 60u, uint videoBitrate = 10485760u, uint audioBitrate = 1048576u)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			CameraResolutionDescriptor val = default(CameraResolutionDescriptor);
			((CameraResolutionDescriptor)(ref val))..ctor(width, height);
			CameraTrackDescriptor trackDescriptor = default(CameraTrackDescriptor);
			((CameraTrackDescriptor)(ref trackDescriptor))..ctor(val, videoBitrate, framerate, audioBitrate);
			_LckService.SetTrackDescriptor(trackDescriptor);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool FullRecordingSetupTempDEPRICATED(RecordingSettings recordingSettings)
	{
		try
		{
			return FullRecordingSetupTempDEPRICATED(recordingSettings.width, recordingSettings.height, recordingSettings.framerate, recordingSettings.Bitrate, recordingSettings.audioBitrate);
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool FullRecordingSetup(uint width = 1920u, uint height = 1080u, uint framerate = 60u, uint videoBitrate = 10485760u, uint audioBitrate = 1048576u)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected O, but got Unknown
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			CameraResolutionDescriptor val = default(CameraResolutionDescriptor);
			((CameraResolutionDescriptor)(ref val))..ctor(width, height);
			CameraTrackDescriptor recordingCameraTrackDescriptor = default(CameraTrackDescriptor);
			((CameraTrackDescriptor)(ref recordingCameraTrackDescriptor))..ctor(val, videoBitrate, framerate, audioBitrate);
			QualityOption val2 = new QualityOption();
			val2.RecordingCameraTrackDescriptor = recordingCameraTrackDescriptor;
			val2.IsDefault = true;
			_QualitySelector._qualityOptions[1] = val2;
			_QualitySelector.UpdateCurrentTrackDescriptor(1);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool FullRecordingSetup(RecordingSettings recordingSettings)
	{
		try
		{
			return FullRecordingSetup(recordingSettings.width, recordingSettings.height, recordingSettings.framerate, recordingSettings.Bitrate, recordingSettings.audioBitrate);
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool RecordMicUntested(bool record)
	{
		try
		{
			_LckService.SetMicrophoneCaptureActive(record);
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool SetPOVBypassUntested(string pov = "Null", int detachedpreview = -1)
	{
		try
		{
			string text = "";
			text = ((detachedpreview != -1) ? ((Il2CppArrayBase<Preview>)(object)_DetachedPreviewManager.availablePreviews)[detachedpreview].AttachingMonitor.MonitorId : null);
			if (pov == "Null")
			{
				pov = this.pov;
			}
			switch (pov)
			{
			case "TP":
				_LckService.SetActiveCamera(thirdPerson._Camera.CameraId, text);
				break;
			case "FP":
				_LckService.SetActiveCamera(firstPerson._Camera.CameraId, text);
				break;
			case "HH":
				_LckService.SetActiveCamera(handheld._Camera.CameraId, text);
				break;
			default:
				MelonLogger.Error("pov variable must either be TP, FP or HH, you can use the POVs variable for readability if needed.");
				return false;
			}
			UpdateDetachedPreview();
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public bool UpdateDetachedPreview()
	{
		try
		{
			if (DetachedPreview != _oldDetachedPreview)
			{
				detachedPreviewChanged = true;
			}
			else
			{
				detachedPreviewChanged = false;
			}
			_oldDetachedPreview = DetachedPreview;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	public RecordingSettings GetRecordingSettings()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			return CameraTrackDescriptorToRecordingSettings(_LckService.GetDescriptor().Result.cameraTrackDescriptor);
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return default(RecordingSettings);
		}
	}

	public RecordingSettings GetRecordingSettingsDEPRICATEDKINDA()
	{
		try
		{
			return default(RecordingSettings);
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return default(RecordingSettings);
		}
	}

	public RecordingSettings CameraTrackDescriptorToRecordingSettings(CameraTrackDescriptor descriptor)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		RecordingSettings result = default(RecordingSettings);
		result.width = descriptor.CameraResolutionDescriptor.Width;
		result.height = descriptor.CameraResolutionDescriptor.Height;
		result.framerate = descriptor.Framerate;
		result.audioBitrate = descriptor.AudioBitrate;
		result.Bitrate = descriptor.Bitrate;
		return result;
	}
}
public class ThirdPerson
{
	public LCKCameraController _CameraController;

	public UniversalAdditionalCameraData _CameraSettings;

	public LckCamera _Camera;

	public LCKSettingsButtonsController _POVController;

	public Rock_Cam _rockcam;

	public bool IsFlipped
	{
		get
		{
			return _CameraController.IsThirdPersonFront;
		}
		set
		{
			FlipCamera(value);
		}
	}

	public float Distance
	{
		get
		{
			return _CameraController._thirdPersonDistance;
		}
		set
		{
			_CameraController._thirdPersonDistance = value;
		}
	}

	public float DistanceMultipier
	{
		get
		{
			return _CameraController._thirdPersonDistanceMultiplier;
		}
		set
		{
			_CameraController._thirdPersonDistanceMultiplier = value;
		}
	}

	public float Angle
	{
		get
		{
			return _CameraController._thirdPersonHeightAngle;
		}
		set
		{
			_CameraController._thirdPersonHeightAngle = value;
		}
	}

	public float PositionalSmoothing
	{
		get
		{
			return _CameraController._selfieStabilizer.PositionalSmoothing;
		}
		set
		{
			SetPositionalSmooting(value);
		}
	}

	public float RotationalSmoothing
	{
		get
		{
			return _CameraController._selfieStabilizer.RotationalSmoothing;
		}
		set
		{
			SetRotationalSmooting(value);
		}
	}

	public ThirdPerson(Rock_Cam rockcam)
	{
		_rockcam = rockcam;
		_CameraController = rockcam._CameraController;
		_Camera = rockcam._Tablet.thirdPersonCamera;
		Distance = _CameraController._thirdPersonDistance;
		Angle = _CameraController._thirdPersonHeightAngle;
		PositionalSmoothing = _CameraController._thirdPersonStabilizer.PositionalSmoothing;
		RotationalSmoothing = _CameraController._thirdPersonStabilizer.RotationalSmoothing;
		_CameraSettings = ((Component)rockcam._Tablet.thirdPersonCamera).gameObject.GetComponent<UniversalAdditionalCameraData>();
		_POVController = rockcam._POVController;
	}

	public bool SetPOV()
	{
		try
		{
			_POVController.SwitchToTPMode();
			_rockcam.pov = "TP";
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetAngle(float angle)
	{
		try
		{
			_CameraController._thirdPersonHeightAngle = angle;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetDistance(float distance)
	{
		try
		{
			_CameraController._thirdPersonDistance = distance;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetDistanceMultiplier(float distanceMultiplier)
	{
		try
		{
			_CameraController._thirdPersonDistanceMultiplier = distanceMultiplier;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool FlipCamera(bool flip)
	{
		if (flip == IsFlipped)
		{
			MelonLogger.Msg("TP camera already flipped correct way");
		}
		try
		{
			_CameraController.IsThirdPersonFront = flip;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}

	[Obsolete("Just set the variable directly")]
	public bool SetPositionalSmooting(float smooth)
	{
		if (smooth >= 1f && smooth != 99f)
		{
			MelonLogger.Warning("Smoothing of 1 or greater will result in no movement at all, you can set smoothing to 99 to avoid this message");
		}
		try
		{
			_CameraController._thirdPersonStabilizer.PositionalSmoothing = smooth;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	[Obsolete("Just set the variable directly")]
	public bool SetRotationalSmooting(float smooth)
	{
		if (smooth >= 1f && smooth != 99f)
		{
			MelonLogger.Warning("Smoothing of 1 or greater will result in no movement at all, you can set smoothing to 99 to avoid this message");
		}
		try
		{
			_CameraController._thirdPersonStabilizer.RotationalSmoothing = smooth;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
		return true;
	}

	public bool DoPostProcessing(bool value)
	{
		try
		{
			_CameraSettings.renderPostProcessing = value;
			return true;
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
			return false;
		}
	}
}