SimUL/Assets/Scripts/Managers/CameraSystem.cs

using Cinemachine;
using System;
using UnityEngine;

public class CameraSystem : MonoBehaviour
{
    [SerializeField]
    private CinemachineVirtualCamera _camera;
    [SerializeField]
    private float _fieldOfViewMax = 60f;
    [SerializeField]
    private float _fieldOfViewMin = 10f;
    [SerializeField]
    private float _followOffsetMin = 0.1f;
    [SerializeField]
    private float _followOffsetMax = 10f;
    [SerializeField]
    private float _followOffsetMinY = 1f;
    [SerializeField]
    private float _followOffsetMaxY = 10f;
    [SerializeField]
    private bool _useEdgeScrolling;
    [SerializeField]
    private bool _useMouseDrag;

    private Vector3 _followOffset;
    private float _rotateSpeed = 100f;
    private float _moveSpeed = 25f;
    private int _edgeScrollSize = 20;
    private bool _dragPanMoveActive = false;
    private float _dragPanSpeed = 2f;
    private float _zoomSpeed = 2f;
    private float _zoomAmount = 3f;
    private Vector2 _lastMousePosition;
    private float _targetFieldOfView = 60f;
    private CinemachineTransposer _cinemachineTransposer;

    private void Awake()
    {
        _cinemachineTransposer = _camera.GetCinemachineComponent<CinemachineTransposer>();
        _followOffset = _cinemachineTransposer.m_FollowOffset;      
    }

    private void Start()
    {
        transform.position = Player.Instance.transform.position;
    }

    private void Update()
    {
        HandleCameraMovement();
        HandleCameraRotation();

        //HandleCameraZoom_FOV();
        //HandleCameraZoom_MoveForward();
        HandleCameraZoom_MoveY();
    }

    private void HandleCameraZoom_MoveForward()
    {
        Vector3 zoomDir = _followOffset.normalized;
        if (Input.mouseScrollDelta.y > 0)
            _followOffset -= zoomDir * _zoomAmount;
        if (Input.mouseScrollDelta.y < 0)
            _followOffset += zoomDir * _zoomAmount;

        if (_followOffset.magnitude < _followOffsetMin)
            _followOffset = zoomDir * _followOffsetMin;

        if (_followOffset.magnitude > _followOffsetMax)
            _followOffset = zoomDir * _followOffsetMax;

        Vector3.Lerp(_cinemachineTransposer.m_FollowOffset, _followOffset, Time.deltaTime * _zoomSpeed);

        _cinemachineTransposer.m_FollowOffset = _followOffset;
    }

    private void HandleCameraZoom_MoveY()
    {
        if (Input.mouseScrollDelta.y > 0)
            _followOffset.y -=  _zoomAmount;
        if (Input.mouseScrollDelta.y < 0)
            _followOffset.y +=  _zoomAmount;

        _followOffset.y = Mathf.Clamp(_followOffset.y, _followOffsetMinY, _followOffsetMaxY);

        if (_followOffset.magnitude < _followOffsetMin)
            _followOffset.y = _zoomAmount * _followOffsetMin;

        if (_followOffset.magnitude > _followOffsetMax)
            _followOffset.y = _zoomAmount * _followOffsetMax;

        

        Vector3.Lerp(_cinemachineTransposer.m_FollowOffset, _followOffset, Time.deltaTime * _zoomSpeed);

        _cinemachineTransposer.m_FollowOffset = _followOffset;
    }

    private void HandleCameraZoom_FOV()
    {
        if (Input.mouseScrollDelta.y > 0)
            _targetFieldOfView -= 5;
        if (Input.mouseScrollDelta.y < 0)
            _targetFieldOfView += 5;
        _targetFieldOfView = Mathf.Clamp(_targetFieldOfView, _fieldOfViewMin, _fieldOfViewMax);

        Mathf.Lerp(_camera.m_Lens.FieldOfView, _targetFieldOfView, Time.deltaTime * _zoomSpeed);
        _camera.m_Lens.FieldOfView = _targetFieldOfView;
    }

    private void HandleCameraMovement()
    {
        var inputDir = Vector3.zero;

        if (Input.GetKey(KeyCode.W)) inputDir.z = 1f;
        if (Input.GetKey(KeyCode.S)) inputDir.z = -1f;
        if (Input.GetKey(KeyCode.A)) inputDir.x = -1f;
        if (Input.GetKey(KeyCode.D)) inputDir.x = 1f;

        if (_useEdgeScrolling)
        {
            inputDir = EdgeScrollingMovement(inputDir);
        }
        if (_useMouseDrag)
        {
            inputDir = MousePanMovement(inputDir);
        }

        Vector3 moveDir = transform.forward * inputDir.z + transform.right * inputDir.x;
        transform.position += moveDir * _moveSpeed * Time.deltaTime;
    }

    private Vector3 MousePanMovement(Vector3 inputDir)
    {
        if (Input.GetMouseButtonDown(1))
        {
            _dragPanMoveActive = true;
            _lastMousePosition = Input.mousePosition;
        }
        if (Input.GetMouseButtonUp(1)) { _dragPanMoveActive = false; }

        if (_dragPanMoveActive)
        {
            Vector2 mouseMovementDelta = ((Vector2)Input.mousePosition - _lastMousePosition) * _dragPanSpeed;
            inputDir.x = mouseMovementDelta.x;
            inputDir.z = mouseMovementDelta.y;

            _lastMousePosition = Input.mousePosition;
        }

        return inputDir;
    }

    private Vector3 EdgeScrollingMovement(Vector3 inputDir)
    {
        if (Input.mousePosition.x < _edgeScrollSize) inputDir.x = -1f;
        if (Input.mousePosition.y < _edgeScrollSize) inputDir.z = -1f;
        if (Input.mousePosition.x > Screen.width - _edgeScrollSize) inputDir.x = 1f;
        if (Input.mousePosition.y > Screen.height - _edgeScrollSize) inputDir.z = 1f;
        return inputDir;
    }

    private void HandleCameraRotation()
    {
        float rotateDir = 0f;

        if (Input.GetKey(KeyCode.E)) rotateDir = 1f;
        if (Input.GetKey(KeyCode.Q)) rotateDir = -1f;


        transform.eulerAngles += new Vector3(0, rotateDir * _rotateSpeed * Time.deltaTime, 0);
    }
}