InteractiveCamera.cs

#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
        //camera rotation
        protected Quaternion cameraRotation = new Quaternion(0, 0, 0, 1);
        #endregion

        #region Properties
        public Quaternion CameraRotation { get { return cameraRotation; } set { cameraRotation = value; } } 
       
        #endregion

        #region Constructor
        public InteractiveCamera() : base()
        {
          
            cameraRotation = new Quaternion(0, 0, 0, 1);
            
        }
        #endregion

        #region Initialize
        public override void Initialize()
        {    
            //init update
            needUpdateView = true;
            needUpdateProjection = true;
            needUpdateViewProjection = true;

            Update();
        }
        #endregion

        #region Update
        public override void Update()
        {
            Vector3 mouseVector = new Vector3(cameraInput.X, cameraInput.Y, 0.0f);
            float mouseTranslate = cameraInput.Z;
            if (mouseVector.X != 0.0f || mouseVector.Y != 0.0f)
            {
                //axis = Vector3.Cross(Vector3.UnitX, mCamera.View.Right);
                //axis.Normalize();

                Revolve(Vector3.UnitX, mouseVector.Y / GameProperties.Instance.XNADrawSurfaceHeight * 3.2f);

                //axis = Vector3.Cross(Vector3.UnitX, mCamera.View.Forward);
                //axis.Normalize();

                RevolveGlobal(Vector3.UnitZ, -mouseVector.X / GameProperties.Instance.XNADrawSurfaceWidth * 3.2f);
            }
            if (mouseTranslate != 0.0f)
            {
                Translate(new Vector3(0, 0, mouseTranslate / GameProperties.Instance.XNADrawSurfaceWidth * 3.2f));
            }

            base.Update(); 
        }

        protected override void updateView()
        {
            worldMatrix = Matrix.Identity;

            viewMatrix = Matrix.Invert(
                Matrix.CreateFromQuaternion(cameraRotation) *
                Matrix.CreateTranslation(cameraPosition)
            );

           needUpdateView = false;
           needUpdateViewProjection = true;
        }

        #endregion

        #region additional methods
        private void Rotate(Vector3 axis, float angle)
        {
            axis = Vector3.Transform(axis, Matrix.CreateFromQuaternion(cameraRotation));
            cameraRotation = Quaternion.Normalize(Quaternion.CreateFromAxisAngle(axis, angle) * cameraRotation);
            needUpdateView = true;
        }

        private void Translate(Vector3 distance)
        {
            cameraPosition += Vector3.Transform(distance, Matrix.CreateFromQuaternion(cameraRotation));
            needUpdateView = true;
        }

        private void Revolve(Vector3 axis, float angle)
        {
            Vector3 revolveAxis = Vector3.Transform(axis, Matrix.CreateFromQuaternion(cameraRotation));
            Quaternion rotate = Quaternion.CreateFromAxisAngle(revolveAxis, angle);
            cameraPosition = Vector3.Transform(cameraPosition - cameraTarget, Matrix.CreateFromQuaternion(rotate)) + cameraTarget;

            Rotate(axis, angle);
        }

        private void RotateGlobal(Vector3 axis, float angle)
        {
            cameraRotation = Quaternion.Normalize(Quaternion.CreateFromAxisAngle(axis, angle) * cameraRotation);
            needUpdateView = true;
        }

        private void TranslateGlobal(Vector3 distance)
        {
            cameraPosition += distance;
            needUpdateView = true;
        }

        private void RevolveGlobal(Vector3 axis, float angle)
        {
            Quaternion rotate = Quaternion.CreateFromAxisAngle(axis, angle);
            cameraPosition = Vector3.Transform(cameraPosition - cameraTarget, Matrix.CreateFromQuaternion(rotate)) + cameraTarget;

            RotateGlobal(axis, angle);
        }

        #endregion

    }
}