Camera.cs

#region Using Statements
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 Camera
    {
        #region Variables
        //position
        protected Vector3 cameraPosition;
        protected Vector3 cameraTarget;

        //orientation vector
        protected Vector3 upVector;
        
        //perspective projection parameters
        private float fieldOfView;
        private float aspectRatio;
        private float nearPlaneDistance;
        private float farPlaneDistance;

        // matrices
        protected Matrix worldMatrix;
        protected Matrix viewMatrix;
        protected Matrix projectionMatrix;
        protected Matrix viewProjectionMatrix;

        //need update
        protected bool needUpdateView;
        protected bool needUpdateProjection;
        protected bool needUpdateViewProjection;

        //user input
        protected Vector3 cameraInput;  
        private bool perspectiveProj;

        //window dimensions
        int[] clientSize;
        Viewport viewport; 
        #endregion

        #region Properties
        //-------------------------------CAMERA POSITION------------------------------------------
        public Vector3 CameraPosition { get { return cameraPosition; } set { cameraPosition = value; needUpdateView = true; } }
        public Vector3 CameraTarget { get { return cameraTarget; } set { cameraTarget = value; needUpdateView = true; } }
        public Vector3 CameraUpVector { get { return upVector; } set { upVector = value; needUpdateView = true; } }
        public Vector3 CameraInput { set { cameraInput = value; needUpdateView = true; } }

        public bool SetPerspectiveProjecton { set { if (value != perspectiveProj) { perspectiveProj = value; needUpdateProjection = true; } } } //todo
        public int[] SetClientSize { set { clientSize = value; aspectRatio = (float)clientSize[0] / (float)clientSize[1]; needUpdateProjection = true; } }

        public Viewport Viewport { get { return viewport; } set { viewport = value; } }

        //--------------------------------RENDER SCENE----------------------------------------------
        public Matrix World { get { return worldMatrix; } set { worldMatrix = value; } }
        public Matrix View { get { return viewMatrix; } }
        public Matrix Projection { get { return projectionMatrix; } }
        public Matrix ViewProjection { get { return viewProjectionMatrix; } }
        #endregion

        #region Constructor
        public Camera()
        {
            //get control dimensions
            clientSize = new int[2];
            clientSize[0] = GameProperties.Instance.XNADrawSurfaceWidth;//initial dimensions
            clientSize[1] = GameProperties.Instance.XNADrawSurfaceHeight;

            //set default camera parameters
            cameraPosition = new Vector3(0.0f, 0.0f, 1.0f);
            cameraTarget = Vector3.Zero;
            upVector = Vector3.Up;
   
            fieldOfView = MathHelper.PiOver4;
            //fieldOfView = MathHelper.Pi / 3.0f;
            aspectRatio = (float)clientSize[0] / (float)clientSize[1]; //4/3
            nearPlaneDistance = 0.1f;
            farPlaneDistance = 1000.0f;

            //user input
            cameraInput = GameProperties.Instance.cameraInput;
            perspectiveProj = GameProperties.Instance.perspectiveProjection;

        }
        #endregion

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

            Update();
        }
        #endregion

        #region Update
        public virtual void Update()
        {

            if (needUpdateView) updateView();

            if (needUpdateProjection) 
                updateProjection();
            
            if (needUpdateViewProjection)
            {
                viewProjectionMatrix = viewMatrix * projectionMatrix;
                needUpdateViewProjection = false;
            }
        }

   
        protected virtual void updateView()
        {
            viewMatrix = Matrix.CreateLookAt(cameraPosition, cameraTarget, upVector);
            
            needUpdateView = false;
            needUpdateViewProjection = true;
        }

        protected void updateProjection()
        {
            if (!perspectiveProj)
            { 
                projectionMatrix = Matrix.CreateOrthographic(clientSize[0]/ 235,
                   clientSize[1]/ 235, nearPlaneDistance, farPlaneDistance);
            }
            else
            {

                float yScale = 1.0f / (float)Math.Tan(fieldOfView / 2.0f);
                float xScale = yScale / aspectRatio;
                Matrix projTmp;
               
                projTmp.M11 = xScale; projTmp.M12 = 0.0f; projTmp.M13 = 0.0f; projTmp.M14 = 0.0f;
                projTmp.M21 = 0.0f; projTmp.M22 = yScale; projTmp.M23 = 0.0f; projTmp.M24 = 0.0f;
                projTmp.M31 = 0.0f; projTmp.M32 = 0.0f; projTmp.M33 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance); projTmp.M34 = -1.0f;
                projTmp.M41 = 0.0f; projTmp.M42 = 0.0f; projTmp.M43 = nearPlaneDistance * farPlaneDistance / (nearPlaneDistance - farPlaneDistance); projTmp.M44 = 0.0f;
                projectionMatrix = projTmp;

                //projectionMatrix = Matrix.CreatePerspectiveFieldOfView(fieldOfView, aspectRatio, nearPlaneDistance, farPlaneDistance);
            }

            needUpdateProjection = false;
            needUpdateViewProjection = true;
        }


       
        #endregion
    }
}