trunk/visLU/Camera.cs

Go to the documentation of this file.

#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 visLU2
{
    class Camera : GameComponent
    {
        #region Variables

        //private Game game;

        //position
        protected Vector3 cameraPosition;
        protected Vector3 cameraTarget;

        //orientation vectors 
        //private Vector3 headingVector; //z axis
        //private Vector3 strafeVector; //x axis
        protected Vector3 upVector; //y axis

        //perspective projection parameters
        private float fieldOfView;
        private float aspectRatio;
        private float nearPlaneDistance;
        private float farPlaneDistance;

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

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

        private bool perspectiveProj = true;

        private float zoom;
        #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; } }
        //--------------------------------RENDER SCENE----------------------------------------------
        public Matrix View { get { return viewMatrix; } }
        public Matrix Projection { get { return projectionMatrix; } }
        public Matrix ViewProjection { get { return viewProjectionMatrix; } }
        //------------------------------------------------------------------------------------------
        public float Zoom
        {
            set { zoom = value; needUpdateProjection = true; }
            get { return zoom; }
        }
        #endregion

        #region Constructor




        public Camera(Game _game)
            : base(_game)
        {
            //game = _game;

            //default camera parameters
            cameraPosition = new Vector3(0.0f, 0.0f, 0.0001f);
            cameraTarget = Vector3.Zero;
            upVector = Vector3.Up;

            fieldOfView = MathHelper.Pi / 4;
            aspectRatio = 4 / 3;
            if (!GameProperties.Instance.fullscreen) aspectRatio = 4 / 3;
            else aspectRatio = (float)GameProperties.Instance.fullscreenWidth / (float)GameProperties.Instance.fullscreenHeight;
            zoom = 50;
            nearPlaneDistance = 0.0f;
            farPlaneDistance = 10000.0f;

            needUpdateView = true;
            needUpdateProjection = true;
            needUpdateViewProjection = true;

        }
        #endregion

        #region Update




        public override void Update(GameTime gameTime)
        {
            /*#region move camera
            MouseState currentMouseState = Mouse.GetState();
            MouseState lasttMouseState;
            if (currentMouseState.LeftButton = ButtonState.Pressed)
            {
                float fX, fY;
                fX = MathHelper.ToRadians(currentMouseState.X - lasttMouseState.X);
                fY = MathHelper.ToRadians(currentMouseState.Y - lasttMouseState.Y);

                viewMatrix *= Matrix.CreateRotationX(fX) * Matrix.CreateRotationY(-fY);
            }
            #endregion*/

            #region zoom
            if(zoom != GameProperties.Instance.cameraPosition.Z)
            {
                if (GameProperties.Instance.cameraPosition.Z < 1)
                {
                    GameProperties.Instance.cameraPosition.Z = 1;   
                }
                else if (GameProperties.Instance.cameraPosition.Z > Math.Max(Game.Window.ClientBounds.Width, Game.Window.ClientBounds.Height))
                {
                    GameProperties.Instance.cameraPosition.Z = Math.Max(Game.Window.ClientBounds.Width, Game.Window.ClientBounds.Height);
                }
                zoom = GameProperties.Instance.cameraPosition.Z;
                needUpdateProjection = true;
            }
            #endregion

            #region move
            if (cameraPosition.X != GameProperties.Instance.cameraPosition.X)
            {
                MathHelper.Clamp(GameProperties.Instance.cameraPosition.X, 0, Game.Window.ClientBounds.Width);
                cameraPosition.X = GameProperties.Instance.cameraPosition.X;
                cameraTarget.X = GameProperties.Instance.cameraPosition.X;
                needUpdateView = true;
            }
            if (cameraPosition.Y != GameProperties.Instance.cameraPosition.Y)
            {
                MathHelper.Clamp(GameProperties.Instance.cameraPosition.Y, 0, Game.Window.ClientBounds.Height);
                cameraPosition.Y = GameProperties.Instance.cameraPosition.Y;
                cameraTarget.Y = GameProperties.Instance.cameraPosition.Y;
                needUpdateView = true;
            }
            #endregion

            if (needUpdateView) updateView();

            if ((needUpdateProjection) || GameProperties.Instance.perspectiveProjection != perspectiveProj) 
                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 (!GameProperties.Instance.perspectiveProjection)
            {
                projectionMatrix = Matrix.CreateOrthographic(Game.Window.ClientBounds.Width / zoom,
                    Game.Window.ClientBounds.Height / zoom, nearPlaneDistance, farPlaneDistance);
                perspectiveProj = false;
            }
            else
            {
                projectionMatrix = Matrix.CreatePerspectiveFieldOfView(fieldOfView, aspectRatio,
                    nearPlaneDistance, farPlaneDistance);
                perspectiveProj = true;
            }

            needUpdateProjection = false;
            needUpdateViewProjection = true;
        }


        #endregion
    }
}