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 visLU
{
    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;

        #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; } }
        #endregion

        #region Constructor




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

            //default camera parameters
            cameraPosition = new Vector3(0.0f, 0.0f, 10.0f);
            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;
            nearPlaneDistance = 0.1f;
            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*/

            if (needUpdateView) updateView();

            if ((needUpdateProjection) || GameProperties.Instance.perspectiveProjection != perspectiveProj) 
                updateProjection();
            
            if (needUpdateViewProjection)
            {
                viewProjectionMatrix = viewMatrix * projectionMatrix;
                needUpdateViewProjection = false;
            }
        }

        protected virtual void updateView()
        {
            //headingVector = cameraTarget - cameraPosition;
            //headingVector.Normalize();
            //strafeVector = Vector3.Cross(headingVector, upVector);
            //upVector = Vector3.Cross(strafeVector, headingVector); //make sure upVector is perpendicular to the heading vector

            viewMatrix = Matrix.CreateLookAt(cameraPosition, cameraTarget, upVector);

            needUpdateView = false;
            needUpdateViewProjection = true;
        }

        protected void updateProjection()
        {
            if (GameProperties.Instance.perspectiveProjection == false)
            { //: width und height korrigieren
                projectionMatrix = Matrix.CreateOrthographic(Game.Window.ClientBounds.Width / 235,
                    Game.Window.ClientBounds.Height / 235, nearPlaneDistance, farPlaneDistance);
                perspectiveProj = false;
            }
            else
            {
                projectionMatrix = Matrix.CreatePerspectiveFieldOfView(fieldOfView, aspectRatio,
                    nearPlaneDistance, farPlaneDistance);
                perspectiveProj = true;
            }

            needUpdateProjection = false;
            needUpdateViewProjection = true;
        }


        #endregion
    }
}