public Camera(Rectangle viewportRect)
 {
     speed = 4f;
     zoom = 1f;
     viewportRectangle = viewportRect;
     mode = CameraMode.Follow;
 }

 public override void Update(GameTime gameTime)
 {
     KeyboardManager KManager = (KeyboardManager)Game.Services.GetService(typeof(KeyboardManager));
     if (KManager.IsKeyPressed(Keys.M))
     {
         Mode = (CameraMode)(((int)Mode + 1) % 2);
     }
     float X = KManager.IsKeyDown(Keys.Right) ? 1 : 0;
     X -= KManager.IsKeyDown(Keys.Left) ? 1 : 0;
     float Z = KManager.IsKeyDown(Keys.Down) ? 1 : 0;
     Z -= KManager.IsKeyDown(Keys.Up) ? 1 : 0;
     Vector3 move = new Vector3(X, 0, Z);
     if (move.Length() > 0)
     {
         world_.Translation += move;
     }
     view_ = Matrix.CreateLookAt(world_.Translation, world_.Forward + world_.Translation, world_.Up);
     switch (Mode)
     {
         case CameraMode.PROJECTIVE:
             projection_ = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, Game.GraphicsDevice.Viewport.AspectRatio, 0.1f, 100);
             break;
         case CameraMode.ORTHOGONAL:
             projection_ = Matrix.CreateOrthographic(Game.GraphicsDevice.Viewport.Width/20, Game.GraphicsDevice.Viewport.Height/20, 0.1f, 100);
             break;
     }
     base.Update(gameTime);
 }

 public Camera(Game game, Matrix world)
     : base(game)
 {
     world_ = world;
     Mode = CameraMode.PROJECTIVE;
     string shit = CameraMode.PROJECTIVE.ToString();
 }

 public void UseEditCamera()
 {
     editCam.gameObject.SetActive(true);
       boofyCam.gameObject.SetActive(false);
       editCam.orthographicSize = editCameraSize;
       cameraMode = CameraMode.kEdit;
 }

 public Camera(Rectangle viewportRectangle)
 {
     _speed = DefaultSpeed;
     Zoom = DefaultZoom;
     _viewportRectangle = viewportRectangle;
     _mode = CameraMode.Follow;
 }

 public void setFocus(GameObject targetObject)
 {
     if(mode != CameraMode.Move)
         previousMode = mode;
     mode = CameraMode.Move;
     moveTarget = targetObject;
 }

 public CombinedCamera(Tank target, CameraMode initialMode, Vector3 initialPosition)
 {
     this.mode = initialMode;
     this.tank = target;
     this.focus = target.getPosition();
     this.position = initialPosition;
 }

 public void IncreaseView()
 {
     if (CameraMode == CameraMode.FirstPerson)
         CameraMode = CameraMode.Overhead;
     else
         CameraMode ++;
 }

 public void DecreaseView()
 {
     if (CameraMode == CameraMode.Overhead)
         CameraMode = CameraMode.FirstPerson;
     else
         CameraMode --;
 }

 public void newTargetView(Transform newTransform)
 {
     cameraMode = CameraMode.ToTarget;
     targetPosition = newTransform.position + Vector3.up * 2;
     targetOffset = newTransform.forward * 3 + newTransform.up * 3 + newTransform.right * 3;
     isTransforming = true;
 }

    public void SetCameraMode(CameraMode mode)
    {
        SingleCamera.enabled = mode == CameraMode.Single;

        for(int i = 0; i < SideBySideCamera.Length;i++){
            SideBySideCamera[i].enabled = mode == CameraMode.SideBySide;
        }
    }

 //call this to pan out and away from boat at end of level
 public void PanOut()
 {
     lerpTimer = Time.time;
     isPanningOut = true;
     startPosition = transform.position;
     panAwayPosition = new Vector3(transform.position.x + -50f, transform.position.y + 100f, transform.position.z + -50f);
     thisCameraMode = CameraMode.lerpToDestination;
 }

 public void ToggleLockOn( GameObject t )
 {
     if( mode is CameraMode.LockedOn ) {
       mode = mode.Switch( new CameraMode.Free() );
     } else {
       mode = mode.Switch( new CameraMode.LockedOn( t ) );
     }
 }

 public Camera(Rectangle viewport, Configuration.Controls controls, Vector2 position, CameraMode mode = CameraMode.Follow)
 {
     _controls = controls;
     Speed = 4.0f;
     _zoom = 1.0f;
     _viewport = viewport;
     Position = position;
     _mode = mode;
 }

    // Update is called once per frame
    void Update()
    {
        float lerpVal = Time.deltaTime*0.1f*60f;

        if(Input.GetKeyDown(KeyCode.Return))
        {
            CurrentCameraMode = CameraMode.Game;
            _CurrentCamPos = transform.position;
            _CurrentTargetPos = _LookAtPos;
        }
        // Menu camera
        if(CurrentCameraMode == CameraMode.Menu)
        {
            if(_CamPosIndex < _CamPosList.Count-1)
            {
                if(_CamPosList[_CamPosIndex+1] && Mathf.Abs(_CamPosList[_CamPosIndex+1].position.x - transform.position.x) < 0.25f)
                {
                    Debug.Log("close enough");
                    ++_CamPosIndex;
                }

                transform.position = Vector3.Lerp(transform.position, _CamPosList[_CamPosIndex+1].position, lerpVal/10);

                    _LookAtPos = transform.position;
                    _LookAtPos.y -= 1.0f;
                    transform.LookAt(_LookAtPos);

            }
            else if(_CamPosIndex == _CamPosList.Count - 1)
                {
                    _LookAtPos = Vector3.Lerp(_LookAtPos, EndTarget.position, lerpVal/20);
                    transform.LookAt(_LookAtPos);
                }
        }
        // Game camera
        else if(CurrentCameraMode == CameraMode.Game)
        {
            if(!_PlayerDied)
            {
                CalcDesiredPos();
            }

            if(Input.GetKeyDown(KeyCode.Space))
            {
                _DesiredCamDist = CamDistFar;
            }
            if(Input.GetKeyUp(KeyCode.Space))
            {
                _DesiredCamDist = CamDist;
            }
            _CurrentCamPos = Vector3.Lerp(_CurrentCamPos,_DesiredCamPos,lerpVal);
            _CurrentTargetPos = Vector3.Lerp(_CurrentTargetPos,_DesiredTargetPos,lerpVal);
            _CurrentCamDist = Mathf.Lerp(_CurrentCamDist,_DesiredCamDist,lerpVal);

            CalcLookat();
        }
    }

    void Start()
    {
        camera = GetComponentInChildren<Camera>();
        Assert.IsNotNull( camera );

        // TODO: Make this based on settings
        mode = new CameraMode.Free();

        offset = FindOffset();
    }

 public Camera()
 {
     x = 0;
     y = 0;
     mode = CameraMode.Manual;
     _following = null;
     bounded = true;
     bounds = new CameraBounds();
     bounds.inherit_from_map();
 }

 /// <summary>
 /// Defines a chasing camera around the target (or the first ship to come).
 /// </summary>
 /// <param name="mode">Camera mode (cockpit or external).</param>
 /// <param name="target">Target ship name.</param>
 public OrbCamera(CameraMode mode, string target = "")
 {
     Mode = mode;
     Target = target;
     Pos = new Vector3(0, 5, 2);
     TrackMode = CameraTrackMode.TargetRelative;
     GroundLocation = new double[] { 0, 0, 0 };
     GroundDirection = new double[] { 0, 0 };
     FieldOfView = 60.0;
 }

	void Update ()
	{
        if (isDead ())
		{
			Debug.Log ("Player died!");

            animator.SetBool("dead", true);
        }

		if (currentCameraMode == CameraMode.Third)
		{
			if (FirstPerson.activeInHierarchy)
				FirstPerson.SetActive (false);
			if (!ThirdPerson.activeInHierarchy)
				ThirdPerson.SetActive (true);

			Cursor.visible = true;
			Cursor.lockState = CursorLockMode.None;

			if (Input.GetKeyDown (KeyCode.Space))
			{
				currentCameraMode = CameraMode.First;
			}
		} else if (currentCameraMode == CameraMode.First)
		{
			if (!FirstPerson.activeInHierarchy)
				FirstPerson.SetActive (true);
			if (ThirdPerson.activeInHierarchy)
				ThirdPerson.SetActive (false);

			Cursor.visible = false;
			Cursor.lockState = CursorLockMode.Locked;

			if (Input.GetKeyDown (KeyCode.Space))
			{
				currentCameraMode = CameraMode.Third;
			}
			if (Input.GetMouseButtonDown (0))
			{
				currentCameraMode = CameraMode.Arrow;
				FirstPerson.SetActive (false);
				Transform vert = FirstPerson.transform.FindChild ("VerticalAnchor");
				GameObject arrow = Instantiate (ArrowMode, arrowSpawn.transform.position, arrowSpawn.transform.rotation) as GameObject;
			}
		} else
		{
			if (FirstPerson.activeInHierarchy)
				FirstPerson.SetActive (false);
			if (ThirdPerson.activeInHierarchy)
				ThirdPerson.SetActive (false);

			Cursor.visible = false;
			Cursor.lockState = CursorLockMode.Locked;
		}
	}

        /**
         * HandleInput: switch camera modes and activate tweaning between them
         */
        public void handleInput(KeyboardState currentKeyboardState)
        {
            // SWITCH camera
            if (currentKeyboardState.IsKeyDown(Keys.D1))
            {
                this.mode = CameraMode.FirstPerson;
                posTweanActive = true;                      // reactivate tweaning
                focTweanActive = true;
            }

            if (currentKeyboardState.IsKeyDown(Keys.D2))
            {
                this.mode = CameraMode.ThirdPerson;
                posTweanActive = true;                      // reactivate tweaning
                focTweanActive = true;
            }

            if (currentKeyboardState.IsKeyDown(Keys.D3))
            {
                this.mode = CameraMode.Orbitting;
                this.orbitAngle = tank.orientationAngle;    // orbit must start at the 3rd person angle
                posTweanActive = true;                      // reactivate tweaning
                focTweanActive = true;
            }

            // Height and distance of camera
            if (currentKeyboardState.IsKeyDown(Keys.L))
            {
                distance = MathHelper.Clamp(distance + C_DELTADISTANCE, C_MINDISTANCE, C_MAXDISTANCE);
            }
            if (currentKeyboardState.IsKeyDown(Keys.O))
            {
                distance = MathHelper.Clamp(distance - C_DELTADISTANCE, C_MINDISTANCE, C_MAXDISTANCE);
            }

            if (currentKeyboardState.IsKeyDown(Keys.I))
            {
                height = MathHelper.Clamp(height + C_DELTAHEIGHT, C_MINHEIGHT, C_MAXHEIGHT);
            }
            if (currentKeyboardState.IsKeyDown(Keys.K))
            {
                height = MathHelper.Clamp(height - C_DELTAHEIGHT, C_MINHEIGHT, C_MAXHEIGHT);
            }

            if (currentKeyboardState.IsKeyDown(Keys.U))
            {
                looseness = MathHelper.Clamp(looseness + 0.005f, 0.05f, 0.9f);
            }
            if (currentKeyboardState.IsKeyDown(Keys.J))
            {
                looseness = MathHelper.Clamp(looseness - 0.005f, 0.05f, 0.9f);
            }
        }