상속: ObjectState
예제 #1
0
 public CameraController(string cameraName)
 {
     this.cameraName = cameraName;
     windowShowing = false;
     image = new VisionImage();
     state = CameraState.FREE;
 }
    public void PossessPlayer(GameObject player)
    {
        if (state == CameraState.FREE_FLOW)
        {
            if (player.CompareTag("Salesman"))
            {
                character = CharacterClass.SALESMAN;
            }
            else if (player.CompareTag("Shopper"))
            {
                character = CharacterClass.SHOPPER;
            }
            else if (player.CompareTag("Guard"))
            {
                character = CharacterClass.GUARD;
            }
            else if (player.CompareTag("Thief"))
            {
                character = CharacterClass.THIEF;
            }
            else return;

            PossessionScript ps = player.GetComponent<PossessionScript>();
            ps.Possess();

            possessedCharacter = player;
            attachedRotation = player.transform.rotation;
            attachedLocation = player.transform.position + attachedRotation * new Vector3(0, 1.85f, -2);
            freeFlyLocation = transform.position;
            freeFlyRotation = transform.rotation;

            state = CameraState.ATTACHING;
            tick = 0;
        }
    }
예제 #3
0
    IEnumerator switchCameraRutine( CameraState from )
    {
        float t = 0.0f;
        Vector3 fromPos, toPos;

        fromPos = quadForeground.transform.position;
        toPos = (from == CameraState.AR) ? vrPos : arPos;

        while (t < 1.0f) {
            quadForeground.transform.position = Vector3.Lerp (fromPos, toPos, t);

            t = t + 0.1f;
            yield return new WaitForSeconds(0.02f);
        }

        if (from == CameraState.VR) {
            Debug.Log("change camera to AR");
            state = CameraState.AR;

        } else if (from == CameraState.AR) {
            Debug.Log("change camera to VR");
            state = CameraState.VR;
        }

        yield return 0;
    }
 //=================================================================================================================o
 // Remember the last camera state when climbing
 void DoClimb(string s)
 {
     if (s != "None") // While climbing
     {
         if (camState == CameraState.FirstPerson)
         {
             camState = CameraState.ThirdPerson;
         }
         else if (camState == CameraState.Orbit)
         {
             camState = CameraState.ThirdPerson;
         }
         else if (camState == CameraState.ThirdPerson)
         {
             return;
         }
     }
     else // Leaving climb modus
     {
         if (lastState == "FirstPerson")
         {
             camState = CameraState.FirstPerson;
         }
         else if (lastState == "ThirdPerson")
         {
             camState = CameraState.ThirdPerson;
         }
         else if (lastState == "Orbit")
         {
             camState = CameraState.Orbit;
         }
     }
 }
예제 #5
0
        public override void Reset()
        {
            base.Reset();

            m_Tween = m_StartTween;
            m_CameraState = CameraState.Enter;
        }
예제 #6
0
	// Use this for initialization
	void Start () {
		combat = new CameraState(localCombatPosition,localCombatRotation);
		inventory = new CameraState(localInventoryPosition,localInventoryRotation);

		currentState = combat;
		desiredState = combat;
	}
	// Update is called once per frame
	void Update () {

		//If the user turns left or right, change the enum
		if (Input.GetKey (KeyCode.D)) 
		{
						direction = CameraState.Right;
				} 
		else if (Input.GetKey (KeyCode.A)) 
		{
			direction = CameraState.Left;
				}
		//call the method to handle moving the camera over time
		shiftSlow (direction); 
		//Add shiftIndex to the X-value of the camera to move it
		transform.position = new Vector3 (toFollow.position.x + shiftIndex, toFollow.position.y, transform.position.z);

		//This code is for zooming the camera
		if((Input.GetAxis ("Mouse ScrollWheel")  < 0f || Input.GetKey(KeyCode.PageDown))&& //If the user scrolls down
		   this.GetComponent<Camera>().orthographicSize < 15f) //And the camera isn't zoomed too far out already
		{
			this.GetComponent<Camera>().orthographicSize += 0.5f; //Zoom out
		}

        if ((Input.GetAxis("Mouse ScrollWheel") > 0f|| Input.GetKey(KeyCode.PageUp)) && //If the user scrolls up
		    this.GetComponent<Camera>().orthographicSize > 6.5) //And the camera isn't zoomed in too far already
		{
			this.GetComponent<Camera>().orthographicSize -= 0.5f; //Zoom in
		}

	}
예제 #8
0
    // Update is called once per frame
    void Update()
    {
        _cameraState = _camera.CameraState;
        CalculateSpeed();

        _animator.SetFloat(AnimatorConditions.AirVelocity, _airVelocity);

        switch (_cameraState)
        {
            case CameraState.Normal:
                // Allow player to rotate their character
                if (Input.GetAxis(PlayerInput.Horizontal) > 0.1f || Input.GetAxis(PlayerInput.Horizontal) < -0.1f)
                {
                    _myTransform.Rotate(0f, Input.GetAxis(PlayerInput.Horizontal) * _rotationSpeed * Time.deltaTime, 0f);
                }

                // Check if character is grounded
                if (_controller.isGrounded == true)
                {
                    _moveDirection = Vector3.zero;
                    _airVelocity = 0f;

                    _animator.SetBool(AnimatorConditions.IsGrounded, true);

                    // Cache user input into variables
                    _horizontal = Input.GetAxis(PlayerInput.Horizontal);
                    _vertical = Input.GetAxis(PlayerInput.Vertical);

                    // Set values in animator conditions
                    _animator.SetFloat(AnimatorConditions.Direction, _horizontal);
                    _animator.SetFloat(AnimatorConditions.Speed, _vertical);

                    if (Input.GetButtonDown(PlayerInput.Jump))
                    {
                        Jump();
                    }
                }
                else
                {
                    // Allow player to move while in air
                    _moveDirection.x = Input.GetAxis(PlayerInput.Horizontal) * _moveSpeed;
                    _moveDirection.z = Input.GetAxis(PlayerInput.Vertical) * _moveSpeed;
                    _moveDirection = _myTransform.TransformDirection(_moveDirection);

                    _animator.SetBool(AnimatorConditions.IsGrounded, false);
                }
            break;

            case CameraState.Target:

            break;
        }

        // Apply gravity to character
        _moveDirection.y -= gravity * Time.deltaTime;
        //Move character withthe _moveDirection Vector3 calculated above.
        _controller.Move(_moveDirection * Time.deltaTime);
    }
 public CarSoundManager(CarActor car, CameraController camera, Game game)
     : base(game)
 {
     cueArray = new Cue[CarSoundEmitters.AudioEmitters.Count];
     car_ = car;
     listener_ = camera.Listener;
     camera_ = camera;
     state_ = camera.CurrentCamera.State;
 }
예제 #10
0
	IEnumerator changeCameraState(CameraState start, CameraState end, float timeInterval) {
		isTransitioning = true;
		for(float t = 0F; t < timeInterval; t += Time.deltaTime) {
			transform.localPosition = Vector3.Lerp(start.position, end.position, t/timeInterval);
			transform.localRotation = Quaternion.Lerp(start.rotation, end.rotation, t/timeInterval);
			yield return null;
		}
		isTransitioning = false;
		currentState = end;
	}
	//Take into account the player's direction and shift the camera
	void shiftSlow(CameraState heading)
	{
		if (heading == CameraState.Right && shiftIndex < 5f) 
		{
			shiftIndex += 0.2f;
		} 
		else if (heading == CameraState.Left && shiftIndex > -5f) 
		{
			shiftIndex -= 0.2f;
		}
	}
	// Use this for initialization
	void Start () {
		if (_target == null) {
			Debug.Log ("no target");
		}

        state = CameraState.VR;
        arPos = new Vector3(_target.transform.position.x, _target.transform.position.y , _target.transform.transform.position.z + 0.5f);
        vrPos = new Vector3(_target.transform.position.x, _target.transform.position.y - 0.8f, _target.transform.transform.position.z + 0.5f);
        plane = GameObject.Find ("Plane");
        plane.transform.position = vrPos;
        plane.GetComponent<Renderer>().enabled = true;
	}
 public GameObject ReleasePlayer()
 {
     GameObject retval = possessedCharacter;
     possessedCharacter = null;
     PossessionScript ps = retval.GetComponent<PossessionScript>();
     ps.Depossess();
     attachedLocation = transform.position;
     attachedRotation = transform.rotation;
     state = CameraState.DETACHING;
     tick = 0;
     return retval;
 }
예제 #14
0
	void Start(){
		foreach (Transform tran in transform) {
			switch(tran.name)
			{
			case "SystemCamera":
				systemCamera = tran.gameObject;
				break;
			case "LC":
				leftCamera = tran.gameObject;
				break;
			case "RC":
				rightCamera = tran.gameObject;
				break;
			case "ZeroParallaxPlane":
				zeroParallaxPlane = tran.gameObject;
				break;
			}
		}
		
		if(Application.platform == RuntimePlatform.Android)
		{
			state = CameraState.AndroidRunTimeState;
			systemCamera.SetActive(false);
			leftCamera.SetActive(true);
			rightCamera.SetActive(true);
			zeroParallaxPlane.SetActive(true);
		}	
		
		
		switch(state)
		{
		case CameraState.WindowsEditorState:
		{
			
			break;
		}
			
		case CameraState.WindowsStereoState:
		{
			initLRCameras ();
			break;
		}
			
		case CameraState.AndroidRunTimeState:
		{
			initCameras ();
			break;
		}
		}
		
		zeroParallaxPlane.GetComponent<MeshRenderer> ().enabled = false;
		
	}
예제 #15
0
    // Use this for initialization
    void Start()
    {
        if (_target == null) {
            Debug.Log ("no target");
            return;
        }

        quadForeground = GameObject.Find ("QuadForeground");
        state = CameraState.VR;
        vrPos = new Vector3 (0.0f, 1.0f, 0.137f);
        arPos = new Vector3 (0.0f, 0.0f, 0.137f);
    }
	// Use this for initialization
	void Start () {
		if (_target == null) {
			Debug.Log ("no target");
		}

        state = CameraState.VR;
        vrPos = new Vector3(_target.transform.position.x, _target.transform.position.y +1.0f, _target.transform.transform.position.z + 0.137f);
        arPos = new Vector3(_target.transform.position.x, _target.transform.position.y, _target.transform.transform.position.z + 0.137f);
     
        quadForeground = GameObject.Find ("QuadForeground");
        quadForeground.transform.position = vrPos;
	}
        public GamepadController()
        {
            //TODO: Detect new controllers after start ?
            var controllers = new[] { new Controller(UserIndex.One), new Controller(UserIndex.Two) };
            StartPollingAndSendingCommands(controllers);

            cameraStates = new Dictionary<int, CameraState>(5);
            for (int i = 0; i < 5; i++)
            {
                CameraState cs = new CameraState();
                cs.Active = false;
                cs.Pan = "100";
                cs.Tilt = 0;
                cameraStates[i] = cs;
            }
        }
예제 #18
0
    void Awake()
    {
        //Cursor.lockState = CursorLockMode.Locked;
        //Cursor.visible = false;

        cam = Camera.main;
        _lockTarget = null;

        _center = new Vector2(Screen.width / 2, Screen.height / 2);

        _focusPoint = transform.position;
        _circleOffset = _focusPoint;
        _focusOffset = cam.transform.position - _focusPoint;

        camState = CameraState.DEFAULT;
    }
예제 #19
0
	void ChangeState(CameraState newState){
		currentState = newState;
		switch (currentState) {
		case CameraState.CAMERA_MOVEMENT:
			SSL.enabled = false;
			ShouldChange = true;
			break;
		case CameraState.CAMERA_SHOOTING:
			CJ.enabled = false;
			ShouldChange = true;
			break;
		default:
			Debug.Log("NO DEBERIA LLEGAR ACA");
			break;
		}
	}
예제 #20
0
        public BaseCamera(float FOV, float AspectRatio, float NearPlane, float FarPlane,
            Vector3 Position, Vector3 Target, Vector3 CameraUp)
        {
            fov_ = FOV;
            currentFov_ = fov_;
            aspectRatio_ = AspectRatio;
            nearPlane_ = NearPlane;
            farPlane_ = FarPlane;
            position_ = Position;
            target_ = Target;
            cameraUp_ = CameraUp;
            //switching_ = false;
            cameraState_ = CameraState.Chase;

            // calculate Projection and view Matricies.
            updateProjectionMatrix();
            updateViewMatrix();
        }
    public override void Update(GameTime gameTime)
    {
        if (state_ != camera_.CurrentCamera.State)
        {
            state_ = camera_.CurrentCamera.State;
            defaultCategory.SetVolume(50);
            switch (state_)
            {
                case CameraState.Chase:
                    cameraCue = soundBank.GetCue("chase");
                    cameraCue.Play();
                    break;
                case CameraState.Reverse:
                    cameraCue = soundBank.GetCue("reverse");
                    cameraCue.Play();
                    break;
                case CameraState.Dynamic:
                    cameraCue = soundBank.GetCue("dynamic");
                    cameraCue.Play();
                    break;
                case CameraState.TopDown:
                    cameraCue = soundBank.GetCue("top_down");
                    cameraCue.Play();
                    break;
            }
        }

        for (int i = 0; i < cueArray.Length; i++)
            cueArray[i].Apply3D(listener_, CarSoundEmitters.AudioEmitters[i]);

        if (car_.LinearVelocity.LengthSquared() <= 400)
            musicCategory.SetVolume(car_.LinearVelocity.LengthSquared() / 16);
        else if (car_.LinearVelocity.LengthSquared() > 1650)
            musicCategory.SetVolume(0);
        else
            musicCategory.SetVolume(25);

        base.Update(gameTime);
    }
예제 #22
0
 public void onEnterDoor(int x)
 {
     lastState = state;
     state = CameraState.TRANSITION;
     doorsXList.Sort();
     if (scrollingRight)
     {
         minDoor = x + 1;
         maxDoor = int.MaxValue;
         int index = doorsXList.FindIndex((doorX) => doorX == minDoor);
         if (index + 1 < numDoors)
         {
             maxDoor = doorsXList[index + 1];
         }
     }
     else
     {
         maxDoor = x - 1;
         minDoor = int.MinValue;
         int index = doorsXList.FindIndex((doorX) => doorX == maxDoor);
         if (index - 1 >= 0)
         {
             minDoor = doorsXList[index - 1];
         }
     }
     if (lastState == CameraState.HORIZONTAL)
     {
         doorsXList.Clear();
         numDoors = 0;
         doorsXList.Add(minDoor);
         doorsXList.Add(minDoor - 1);
         doorsXList.Add(maxDoor);
         doorsXList.Add(maxDoor + 1);
     }
     transitionX = scrollingRight ? minDoor + screenWidth / 2 : maxDoor - screenWidth / 2;
 }
예제 #23
0
 private void Start()
 {
     cs = CameraState.TopDown;
     offset = 0;
 }
예제 #24
0
    /*****/

    void Update()
    {
        if (Camera.main.GetComponent<UnityStandardAssets.ImageEffects.GlobalFog>())
        {
            Camera.main.GetComponent<UnityStandardAssets.ImageEffects.GlobalFog>().startDistance = Vector3.Distance(Camera.main.transform.position, TargetPosition) - 100;
        }

        if (Camera == null && Camera.main == null) return;
        if (Camera == null && Camera.main != null) Camera = Camera.main;
        
        _deltaTime = Time.realtimeSinceStartup - _lastUpdateTime;
        _lastUpdateTime = Time.realtimeSinceStartup;

        if (FollowTarget && TargetTransform != null)
        {
            TargetPosition = TargetTransform.position;
        }

        if (_forward)
        {
            TargetPosition += transform.forward * TranslationSpeed * _deltaTime;
            transform.position += transform.forward * TranslationSpeed * _deltaTime;
        }

        if (_backward)
        {
            TargetPosition -= transform.forward * TranslationSpeed * _deltaTime;
            transform.position -= transform.forward * TranslationSpeed * _deltaTime;
        }

        if (_right)
        {
            TargetPosition += transform.right * TranslationSpeed * _deltaTime;
            transform.position += transform.right * TranslationSpeed * _deltaTime;
        }

        if (_left)
        {
            TargetPosition -= transform.right * TranslationSpeed * _deltaTime;
            transform.position -= transform.right * TranslationSpeed * _deltaTime;
        }
        
        if (_cameraState == CameraState.ArcBall)
        {
            _currentAngleX = Mathf.Lerp(_currentAngleX, AngleX, Smoothing);
            _currentAngleY = Mathf.Lerp(_currentAngleY, AngleY, Smoothing);

            transform.rotation = Quaternion.Euler(_currentAngleX, _currentAngleY, 0.0f);
            transform.position = TargetPosition + transform.rotation*Vector3.back*Distance;

            Camera.transform.position = transform.position;
            Camera.transform.rotation = transform.rotation;
        }
        else if (_cameraState == CameraState.Focus)
        {
            Camera.transform.position = Vector3.Lerp(Camera.transform.position, transform.position, 0.1f);
            Camera.transform.rotation = Quaternion.Lerp(Camera.transform.rotation, transform.rotation, 0.1f);

            var d = Vector3.Distance(Camera.main.transform.position, TargetPosition);

            if (d  <= DefaultDistance + 0.15f)
            {
                _cameraState = CameraState.Normal;
                Camera.transform.position = Camera.transform.position;
                Camera.transform.rotation = Camera.transform.rotation;
            }

            //_cameraState = CameraState.Normal;
        }
        else
        {
            _currentAngleX = AngleX;
            _currentAngleY = AngleY;

            transform.position = TargetPosition - transform.forward * Distance;
            transform.rotation = Quaternion.Euler(AngleX, AngleY, 0.0f);
            TargetPosition = transform.position + transform.forward * Distance;

            Camera.transform.position = Vector3.Lerp(Camera.transform.position, transform.position, Smoothing);
            Camera.transform.rotation = Quaternion.Lerp(Camera.transform.rotation, transform.rotation, Smoothing);
        }
    }
예제 #25
0
    private void OnGUI()
    {

#if UNITY_EDITOR
        if (Event.current.type == EventType.Layout || Event.current.type == EventType.Repaint)
        {
            EditorUtility.SetDirty(this); // this is important, if omitted, "Mouse down" will not be display
        }
#endif

        if (_cameraState == CameraState.Focus) return;

        if (Event.current.alt)
        {
            _cameraState = CameraState.ArcBall;
        }
        else
        {
            if (_cameraState == CameraState.ArcBall)
            {
                AngleX = _currentAngleX;
                AngleY = _currentAngleY;

                transform.rotation = Quaternion.Euler(_currentAngleX, _currentAngleY, 0.0f);
                transform.position = TargetPosition + transform.rotation * Vector3.back * Distance;

                Camera.transform.position = transform.position;
                Camera.transform.rotation = transform.rotation;

                _cameraState = CameraState.Normal;
            }
        }
        
        if (Event.current.alt && Event.current.type == EventType.mouseDrag && Event.current.button == 0)
        {
            AngleY += Event.current.delta.x * AcrBallRotationSpeed;
            AngleX += Event.current.delta.y * AcrBallRotationSpeed;
        }
        else if (Event.current.type == EventType.mouseDrag && Event.current.button == 1)
        {
            AngleY += Event.current.delta.x * FpsRotationSpeed;
            AngleX += Event.current.delta.y * FpsRotationSpeed;
        }
        else if (Event.current.type == EventType.mouseDrag && Event.current.button == 2)
        {
            DoPanning(Event.current.delta.x * PannigSpeed, Event.current.delta.y * PannigSpeed);
        }
        else if (Event.current.type == EventType.ScrollWheel)
        {
            DoScrolling(Event.current.delta.y * ScrollingSpeed);
        }

        if (Event.current.keyCode == KeyCode.F)
        {
            if (TargetTransform != null)
            {
                TargetPosition = TargetTransform.position;
            }

            Distance = DefaultDistance;
            transform.position = TargetPosition - transform.forward * Distance;

            _cameraState = CameraState.Focus;
        }

        if (Event.current.keyCode == KeyCode.R)
        {
            Distance = DefaultDistance;
            TargetPosition = Vector3.zero;
            transform.position = TargetPosition - transform.forward * Distance;
        }

        if (Event.current.keyCode == KeyCode.W)
        {
            _forward = Event.current.type == EventType.KeyDown;
        }

        if (Event.current.keyCode == KeyCode.S)
        {
            _backward = Event.current.type == EventType.KeyDown;
        }

        if (Event.current.keyCode == KeyCode.A)
        {
            _left = Event.current.type == EventType.KeyDown;
        }

        if (Event.current.keyCode == KeyCode.D)
        {
            _right = Event.current.type == EventType.KeyDown;
        }
    }
    //=================================================================================================================o
    void LateUpdate()
    {
        // 1,2,3 buttons for switching camera modi
        if ( Input.GetKeyDown (hKey.firstPersonCameraKey) )
        {
            // FirstPerson
            lastState = "FirstPerson";

            cam.camera.fieldOfView = 80.0f;
            camState = CameraState.FirstPerson;
        }
        else if ( Input.GetKeyDown (hKey.orbitCameraKey) )
        {
            // Orbit
            lastState = "Orbit";

            cam.camera.fieldOfView = 70.0f;
            camState = CameraState.Orbit;
        }
        else if ( Input.GetKeyDown (hKey.thirdPersonCameraKey) )
        {
            // ThirdPerson
            lastState = "ThirdPerson";

            cam.camera.fieldOfView = 70.0f;
            curDist = heroDistance;
            desDist = heroDistance;
            finalDist = heroDistance;
            camState = CameraState.ThirdPerson;
        }

        // Camera states
        switch (camState)
        {
        case CameraState.FirstPerson:
            FirstPerson();
            break;
        case CameraState.ThirdPerson:
            ThirdPerson();
            break;
        case CameraState.Orbit:
            Orbit();
            break;
        }
    }
예제 #27
0
 void OnGUI()
 {
     //zoom button
     if(GUILayout.Button(zoomText) && !transitioning)
     {
         if(camState == CameraState.zoomedIn)
         {
             zoomText = "Zoom In";
             camState = CameraState.zoomedOut;
             StartCoroutine(SmoothChangeSize(zoomedOutSize));
         }
         else
         {
             zoomText = "Zoom Out";
             StartCoroutine(SmoothChangeSize(zoomedInSize));
             camState = CameraState.zoomedIn;
         }
     }
 }
 /// <summary>
 /// On receive a camera exception.
 /// </summary>
 /// <param name="CameraException">The receive camera exception.</param>
 private static void OnReceiveCameraStateChanged(CameraState CameraState, CameraCapture CameraCapture)
 {
     if (OnCameraStateChanged != null)
     {
         OnCameraStateChanged(CameraState, CameraCapture);
     }
 }
	IEnumerator switchCameraRutine( CameraState from ) {
		float time = 0.0f;
		Vector3 startPos, endPos;

		startPos = quadForeground.transform.position;
		endPos = (from == CameraState.AR) ? vrPos : arPos;

		while (time < 1.0f) { 
			quadForeground.transform.position = Vector3.Lerp (startPos, endPos, time);

			time = time + 0.1f;
			yield return new WaitForSeconds(0.02f);
		}

		if (from == CameraState.VR) {
			Debug.Log("change camera to AR");
            isPlaying = false;
			state = CameraState.AR;
			
		} else if (from == CameraState.AR) {
			Debug.Log("change camera to VR");
            isPlaying = false;
			state = CameraState.VR;
		}

		yield return 0;
	}
        public void updateCamera(GameTime time, Vector2 heroPosition)
        {
            //this.Move(viewportWidth * 0.25f - Mouse.GetState().X, viewportHeight * 0.25f - Mouse.GetState().Y);
            //Vector2 mouseVec = new Vector2(Mouse.GetState().X, Mouse.GetState().Y);
            //Console.WriteLine(mouseVec.ToString());

            if (GameStateHandler.CurrentState == GameState.STARTING)
            {
                //Vector2 lookPos = new Vector2(350, 385);
                //moveCameraTo(lookPos);
                //this.Zoom = 1f;
            }
            else if (GameStateHandler.CurrentState == GameState.RUNNING)
            {
                int currentSeconds = (int)time.TotalGameTime.TotalSeconds;
                if (this.CurrentState == CameraState.IDLE)
                {
                    if (currentSeconds - lastZoom > zoomIntervals)
                    {
                        if (debug)
                        {
                            Console.WriteLine("Zooming in");
                        }
                        lastZoom = currentSeconds;
                        this.Zoom = defaultZoom;
                        this.CurrentState = CameraState.ZOOMING_IN;

                    }
                }
                else if (this.CurrentState == CameraState.ZOOMING_IN)
                {
                    if (this.Zoom < maxZoom)
                    {
                        this.Move(this.Position.X - xZoom * zoomIncremental, this.Position.Y + yZoom * zoomIncremental);
                        this.Zoom += zoomIncremental;
                    }
                    else
                    {
                        if (debug)
                        {
                            Console.WriteLine("Zooming out");
                        }
                        this.CurrentState = CameraState.ZOOMING_OUT;
                    }
                }
                else if (this.CurrentState == CameraState.ZOOMING_OUT)
                {
                    if (this.Zoom > defaultZoom)
                    {
                        this.Move(this.Position.X + xZoom * zoomIncremental, this.Position.Y - yZoom * zoomIncremental);
                        this.Zoom -= zoomIncremental;
                    }
                    else
                    {
                        //this.Move(defaultCameraPosition);
                        if (debug)
                        {
                            Console.WriteLine("Done zooming, back at default");
                        }
                        this.CurrentState = CameraState.IDLE;
                    }
                }
            }
        }