Cameraman.cs

using UnityEngine;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using Janus;

[ExecuteInEditMode]
[Script(ScriptRole.Client)]
public class Cameraman: MonoBehaviour
{
    public const float ShakeShiftInterval = .01f;

    public static Cameraman Instance
    {
        get { return _instance; }
    }

    public GameObject Target
    {
        get
        {
            if (_target != null)
                return _target.gameObject;

            return null;
        }
        set { Follow(value); }
    }

    public Vector3 DefaultTargetOffset = new Vector3(0, 0, -8f);
    public float DefaultNoFollowRadius;
    public float DefaultFollowFactor = 5f;
    [System.NonSerialized]
    public Vector3 AdditionalOffset = Vector3.zero;
    public Color DesiredSceneColor;
    public float ColorCorrectionFactor;
    public Color DefaultSceneColor { get; private set;}
    
    Transform _target;
    CameraTarget _camTarget;
    Vector3 _targetOffset;
    float _noFollowRadius;
    float _followFactor;
    Vector3 _shakeVector;
    Camera _camera;

    static Cameraman _instance;

    void Awake ()
    {
        _instance = this;

        camera.transparencySortMode = TransparencySortMode.Orthographic;

        foreach (var cam in GetComponentsInChildren<Camera>())
        {
            cam.transparencySortMode = TransparencySortMode.Orthographic;
        }
        
        _camera = GetComponent<Camera>();
        
        DefaultSceneColor = _camera.backgroundColor;
        DesiredSceneColor = DefaultSceneColor;
    }

    public void Follow (GameObject go)
    {
        if (go == null)
        {
            _target = null;
            return;
        }

        bool snap = _target == null;

        _target = go.transform;

        _camTarget = go.GetComponent<CameraTarget>();

        if (_camTarget != null)
        {
            _targetOffset = _camTarget.CameramanOffset;
            _noFollowRadius = _camTarget.NoFollowRadius;
            _followFactor = _camTarget.FollowFactor;
        }
        else
        {
            _targetOffset = DefaultTargetOffset;
            _noFollowRadius = DefaultNoFollowRadius;
            _followFactor = DefaultFollowFactor;
        }

        AdditionalOffset = Vector3.zero;

        if (snap)
            SnapToTarget();
    }

    public void Follow (Component component)
    {
        Follow(component.gameObject);
    }

    public void StopFollowing ()
    {
        _target = null;

        _targetOffset = DefaultTargetOffset;
        _noFollowRadius = DefaultNoFollowRadius;
        _followFactor = DefaultFollowFactor;

        AdditionalOffset = Vector3.zero;
    }

    public void SnapToTarget ()
    {
        if (_target != null)
            transform.position = _target.position + _targetOffset;
    }

    public void Shake (float scale, float duration)
    {
        StartCoroutine(ShakeAsync(scale, duration));
    }

    IEnumerator ShakeAsync (float scale, float duration)
    {
        float shakeTimeLeft = duration;

        while (shakeTimeLeft > 0f)
        {
            _shakeVector = new Vector3(Random.Range(-.5f, .5f), Random.Range(-.5f, .5f), 0f) * scale;
            shakeTimeLeft -= ShakeShiftInterval;
            yield return new WaitForSeconds(ShakeShiftInterval);
        }

        _shakeVector = Vector3.zero;

        yield break;
    }

    public void StopShaking ()
    {
        _shakeVector = Vector3.zero;
        StopCoroutine("ShakeAsync");
    }

    void Update ()
    {
        Vector3 newVelocity = Vector3.zero;

        if (_target != null)
        {
            if (_camTarget != null)
            {
                _targetOffset = _camTarget.CameramanOffset;
                _noFollowRadius = _camTarget.NoFollowRadius;
                _followFactor = _camTarget.FollowFactor;
            }
            else
            {
                _targetOffset = DefaultTargetOffset;
                _noFollowRadius = DefaultNoFollowRadius;
                _followFactor = DefaultFollowFactor;
            }
        
            Vector3 toTarget = _target.position + _targetOffset + AdditionalOffset - transform.position;
            float distToTarget = toTarget.magnitude;

            if (distToTarget != 0f)
            {
                Vector3 followVector = toTarget / distToTarget * Mathf.Max(0f, distToTarget - _noFollowRadius);
                newVelocity += followVector * _followFactor;
            }
            
            _camera.backgroundColor = Color.Lerp(_camera.backgroundColor, DesiredSceneColor, Time.deltaTime * ColorCorrectionFactor);
            RenderSettings.fogColor = _camera.backgroundColor;
        }
    
        if (_shakeVector != Vector3.zero)
            newVelocity += _shakeVector;

        if (newVelocity != Vector3.zero)
            transform.position += newVelocity * Time.deltaTime;
    }

    void OnDestroy ()
    {
        if (_instance == this)
            _instance = null;
    }
}