summaryrefslogtreecommitdiff
path: root/Thronefall_v1.0/Decompile/CameraRig.cs
blob: 7a87897f49c2fdfc50aa028b7ee05ad7eb40bf5c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
using System.Collections;
using UnityEngine;

public class CameraRig : MonoBehaviour
{
	[Header("Forced Camera")]
	[HideInInspector]
	public Transform overrideCameraTarget;

	private Transform cameraTarget;

	private Transform currentTarget;

	private Quaternion startRotation;

	[SerializeField]
	private float transitionSpeed = 1f;

	[Header("Camera Boundaries")]
	[SerializeField]
	private CameraBounds camBounds;

	[SerializeField]
	private bool addCamBoundMode;

	[SerializeField]
	private KeyCode debugAddCamBound;

	[SerializeField]
	private KeyCode enableDisableCamBound;

	[SerializeField]
	private bool boundsEnabled = true;

	[SerializeField]
	private float outerBoundWidth = 12f;

	private Vector3 targetPosition;

	private bool transitionRunning;

	private void Start()
	{
		startRotation = base.transform.rotation;
		cameraTarget = base.transform.parent;
		base.transform.SetParent(null);
	}

	private void Update()
	{
		targetPosition = base.transform.position;
		if (overrideCameraTarget != null && currentTarget != overrideCameraTarget)
		{
			StartCoroutine(TransitionToTarget(overrideCameraTarget));
		}
		else if (overrideCameraTarget == null && currentTarget != cameraTarget)
		{
			StartCoroutine(TransitionToTarget(cameraTarget));
		}
		else if (!transitionRunning)
		{
			if (overrideCameraTarget != null)
			{
				base.transform.position = overrideCameraTarget.position;
				base.transform.rotation = overrideCameraTarget.rotation;
			}
			else
			{
				base.transform.position = cameraTarget.position;
				base.transform.rotation = startRotation;
			}
		}
	}

	private void HandleBounds()
	{
		if (!camBounds)
		{
			base.transform.position = targetPosition;
			return;
		}
		if (!boundsEnabled)
		{
			base.transform.position = targetPosition;
			return;
		}
		if (camBounds.IsInBounds(new Vector2(targetPosition.x, targetPosition.z)))
		{
			base.transform.position = targetPosition;
			return;
		}
		Vector2 vector = camBounds.ClosestPointOnBounds(new Vector2(targetPosition.x, targetPosition.z));
		float magnitude = (vector - new Vector2(targetPosition.x, targetPosition.z)).magnitude;
		Vector3 vector2 = new Vector3(vector.x, targetPosition.y, vector.y);
		float num = Mathf.Clamp01(magnitude / outerBoundWidth);
		num = 0f - Mathf.Pow(num, 2f) + 2f * num;
		Vector2 normalized = (new Vector2(targetPosition.x, targetPosition.z) - vector).normalized;
		Vector3 b = vector2 + new Vector3(normalized.x, 0f, normalized.y) * outerBoundWidth * 0.5f;
		base.transform.position = Vector3.Lerp(vector2, b, num);
	}

	private IEnumerator TransitionToTarget(Transform newTarget)
	{
		transitionRunning = true;
		Vector3 startPosition = base.transform.position;
		Quaternion startRotation = base.transform.rotation;
		float transitionTime2 = 0f;
		while (targetPosition != newTarget.position || base.transform.rotation != newTarget.rotation)
		{
			transitionTime2 = Mathf.Clamp(transitionTime2, 0f, 1f);
			float t = 3f * Mathf.Pow(transitionTime2, 2f) - 2f * Mathf.Pow(transitionTime2, 3f);
			base.transform.position = Vector3.Lerp(startPosition, newTarget.position, t);
			base.transform.rotation = Quaternion.Lerp(startRotation, newTarget.rotation, t);
			transitionTime2 += Time.deltaTime * transitionSpeed;
			yield return null;
		}
		currentTarget = newTarget;
		transitionRunning = false;
	}
}