InteractiveCamera.cs

Go to the documentation of this file.

#region Using Statement
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Graphics;
#endregion

namespace visLU
{
    class InteractiveCamera : Camera
    {
        
        #region Variables
        //orientation vectors 
        Vector3 headingVector; //z camera axis
        Vector3 strafeVector; //x camera axis

        //allowed camera rotation range between - maxRotate and maxRotate 
        float maxRotation;
        float maxZoomOut; //== initial camera z positon
        float velocityFactor;

        //rotation angles over the camera axes:
        //strafe vector(x axes), up vector(y axes), heading vector (z axes)
        Vector3 cameraRotation;

        //rotation velocity over the camera axes
        Vector3 cameraRotationVelocity;

        float zoomTranslation;
        MouseState currentMouseState;
        MouseState lastMouseState;
        
        #endregion

        #region Properties
        public float MaxRotation
        {
            set { maxRotation = value; }
        }
        public Vector3 CameraRotation
        {
            get { return cameraRotation; }
            set { cameraRotation = value; }
            
        }
        public Vector3 CameraRotationVelocity
        {
            get { return cameraRotationVelocity; }
            set { cameraRotationVelocity = value; }
        }
        #endregion

         #region Constructor




        public InteractiveCamera(Game _game)
            : base(_game)
        {
            /*headingVector = cameraTarget - cameraPosition;
            headingVector.Normalize();
            strafeVector = Vector3.Cross(headingVector, upVector);
            upVector = Vector3.Cross(strafeVector, headingVector); //make sure upVector is perpendicular to the heading vector
             */

            upVector = Vector3.Up;
            headingVector = new Vector3(0, 0, -1);
            strafeVector = new Vector3(1, 0, 0);
            

            maxRotation = 360.0f;
            maxZoomOut = cameraPosition.Z;
            velocityFactor = 20.0f;
            cameraRotation = Vector3.Zero;
            cameraRotationVelocity = Vector3.Zero;
            zoomTranslation = 0.0f;

            lastMouseState = Mouse.GetState();
            
        }
        #endregion

        #region Update




        public override void Update(GameTime gameTime)
        {
            #region move camera
            currentMouseState = Mouse.GetState();
            KeyboardState keyBoardState = Keyboard.GetState();
            if ((currentMouseState.LeftButton == ButtonState.Pressed)&&(keyBoardState.IsKeyDown(Keys.LeftAlt)))
            {
                float fX, fY;
                fX = MathHelper.ToRadians(currentMouseState.X - lastMouseState.X);
                fY = MathHelper.ToRadians(currentMouseState.Y - lastMouseState.Y);

                Matrix transform = Matrix.CreateRotationX(fX) * Matrix.CreateRotationY(-fY);
                cameraPosition = Vector3.Transform(cameraPosition, transform);
                upVector = Vector3.Transform(upVector, transform);
                viewMatrix = Matrix.CreateLookAt(cameraPosition, cameraTarget, upVector);
                needUpdateViewProjection = true;
            }
            #endregion
            lastMouseState = currentMouseState;


            /*cameraRotationVelocity.Y = -GameProperties.Instance.position.X * velocityFactor;
            //cameraRotationVelocity.X = -GameProperties.Instance.position.Y * velocityFactor;
            
            zoomTranslation += GameProperties.Instance.position.Z/maxZoomOut;
            //GameProperties.Instance.position.Z = 0;
            GameProperties.Instance.position = Vector3.Zero;

            if (cameraRotationVelocity != Vector3.Zero)
            {
                float elapsedTimeSeconds = (float)gameTime.ElapsedGameTime.TotalSeconds;
                cameraRotation += cameraRotationVelocity * elapsedTimeSeconds;
                cameraRotation.X = clamp(cameraRotation.X, 0, maxRotation);
                cameraRotation.Y = clamp(cameraRotation.Y, 0, maxRotation);
                //cameraRotation.X = MathHelper.Clamp(cameraRotation.X, -maxRotation, maxRotation);
                //cameraRotation.Y = MathHelper.Clamp(cameraRotation.Y, -maxRotation, maxRotation);
                //cameraRotation.Z = MathHelper.Clamp(cameraRotation.Z, -maxRotation, maxRotation);
                needUpdateView = true;
            }

            if (zoomTranslation != 0)
            {
                zoomTranslation = MathHelper.Clamp(zoomTranslation, 0, maxZoomOut);
                needUpdateView = true;
            }*/

            #region debug
            //Console.WriteLine("Y:" + GameProperties.Instance.position.Y);
            //Console.WriteLine("X:" + GameProperties.Instance.position.X);
            //Console.WriteLine("Z:" + GameProperties.Instance.position.Z);
            //Console.WriteLine("Zoom:" + zoomTranslation);
            #endregion

            base.Update(gameTime);
        }

        protected override void updateView()
        {
          
            //update camera position
           /* Vector3 newCameraPosition = cameraPosition - cameraTarget;
            newCameraPosition = Vector3.Transform(newCameraPosition,
                                Matrix.CreateFromAxisAngle(upVector, MathHelper.ToRadians(cameraRotation.Y)) *
                                Matrix.CreateFromAxisAngle(strafeVector, MathHelper.ToRadians(cameraRotation.X)));
                                //Matrix.CreateFromAxisAngle(headingVector, MathHelper.ToRadians(cameraRotation.Z)));
            newCameraPosition = Vector3.Transform(newCameraPosition, Matrix.CreateTranslation(0.0f, 0.0f, zoomTranslation));
            newCameraPosition += cameraTarget; */


           
            Matrix upRotation = Matrix.CreateFromAxisAngle(upVector, MathHelper.ToRadians(cameraRotation.Y));
            Matrix strafeRotation =  Matrix.CreateFromAxisAngle(strafeVector, MathHelper.ToRadians(cameraRotation.X));

            Vector3 newCameraPosition = cameraPosition - cameraTarget;
            newCameraPosition = Vector3.Transform(newCameraPosition, upRotation*strafeRotation);
            
            float dir = -1;
            if (newCameraPosition.Z < 0) dir = 1;
            newCameraPosition = Vector3.Transform(newCameraPosition, Matrix.CreateTranslation(0.0f, 0.0f, dir * zoomTranslation));
            
            //update oriantation vectors
            //
            //headingVector = Vector3.Transform(new Vector3(0, 0, -1), upRotation * strafeRotation);
            //upVector = Vector3.Transform(new Vector3(0, 1, 0), strafeRotation);
            //strafeVector = Vector3.Transform(new Vector3(1, 0 , 0), upRotation);
             //setOrientationVectors(newCameraPosition, cameraTarget + cameraTarget, upVector);

            //debug
            //Console.WriteLine("UP Vector:" + upVector);
            viewMatrix = Matrix.CreateLookAt(newCameraPosition + cameraTarget, cameraTarget, upVector);
           

            needUpdateView = false;
            needUpdateViewProjection = true;
        }

        #endregion

        #region additional methods
        //some helper functions
        private void setOrientationVectors(Vector3 _cameraPos, Vector3 _cameraTarget, Vector3 _cameraUp)
        {
            headingVector = _cameraTarget - _cameraPos;
            headingVector.Normalize();
            upVector = _cameraUp;
            strafeVector = Vector3.Cross(headingVector, upVector);
            upVector = Vector3.Cross(strafeVector, headingVector); //make sure upVector is perpendicular to the heading vector
        }
        private float clamp(float value, float minValue, float maxValue)
        {
            if (value > maxValue) value -= maxValue;
            if (value < minValue) value += maxValue;

            return value;
        }

        #endregion

    }
}