Desktop/Dev/Cameras/Cameras/Projection.cs

Go to the documentation of this file.

using System;
using Microsoft.Xna.Framework;

namespace Mindshifter
{
    public enum ProjectionType
    {
        Perspective,
        Orthographic,
    }

    public class Projection
    {
        private Matrix          mMatrix;                // Projection matrix calculated from parameterization

        private ProjectionType  mType;                  // Type of projection, perspective or orthographic

        private float           mFieldOfView;           // Field of view for perspective projection
        private float           mAspectRatio;           // Aspect ratio for perspective projection

        private Rectangle       mRectangle;             // Rectangle for ortho projection

        private float           mNearPlaneDistance;     // Near frustum plane distance
        private float           mFarPlaneDistance;      // Far frustum plane distance

        private bool            mRequiresUpdate;        // Set when the projection matrix requires an update

        public Matrix Matrix
        {
            get 
            {
                if (mRequiresUpdate)
                    BuildMatrix();

                return mMatrix; 
            }
        }

        public ProjectionType Type
        {
            get { return mType; }
            set
            {
                mType = value;
                mRequiresUpdate = true;
            }
        }

        public float FieldOfView
        {
            get { return mFieldOfView; }
            set 
            { 
                mFieldOfView = value;
                mRequiresUpdate = true;
            }
        }

        public float AspectRatio
        {
            get { return mAspectRatio; }
            set
            {
                mAspectRatio = value;
                mRequiresUpdate = true;
            }
        }

        public Rectangle Rectangle
        {
            get { return mRectangle; }
            set 
            { 
                mRectangle = value;
                mRequiresUpdate = true;
            }
        }

        public int OffsetX
        {
            get { return mRectangle.X; }
            set 
            { 
                mRectangle.X = value;
                mRequiresUpdate = true;
            }
        }

        public int OffsetY
        {
            get { return mRectangle.Y; }
            set 
            { 
                mRectangle.Y = value;
                mRequiresUpdate = true;
            }
        }

        public int Width
        {
            get { return mRectangle.Width; }
            set
            {
                mRectangle.Width = value;
                mRequiresUpdate = true;
            }
        }

        public int Height
        {
            get { return mRectangle.Height; }
            set
            {
                mRectangle.Height = value;
                mRequiresUpdate = true;
            }
        }

        public float NearPlaneDistance
        {
            get { return mNearPlaneDistance; }
            set
            {
                mNearPlaneDistance = value;
                mRequiresUpdate = true;
            }
        }

        public float FarPlaneDistance
        {
            get { return mFarPlaneDistance; }
            set
            {
                mFarPlaneDistance = value;
                mRequiresUpdate = true;
            }
        }

        public Projection(float fov, float aspect, float near, float far)
        {
            mFieldOfView = fov;
            mAspectRatio = aspect;
            mNearPlaneDistance = near;
            mFarPlaneDistance = far;

            mType = ProjectionType.Perspective;

            mRequiresUpdate = true;
        }

        public Projection(int width, int height, float near, float far)
            : this(0, 0, width, height, near, far)
        {

        }

        public Projection(int x, int y, int width, int height, float near, float far)
        {
            mRectangle = new Rectangle(x, y, width, height);
            mNearPlaneDistance = near;
            mFarPlaneDistance = far;

            mType = ProjectionType.Orthographic;

            mRequiresUpdate = true;
        }

        public Projection(Rectangle rect, float near, float far)
        {
            mRectangle = rect;
            mNearPlaneDistance = near;
            mFarPlaneDistance = far;

            mType = ProjectionType.Orthographic;

            mRequiresUpdate = true;
        }

        private void BuildMatrix()
        {
            switch (mType)
            {
                case ProjectionType.Perspective:
                    {
                        Matrix.CreatePerspectiveFieldOfView(mFieldOfView, mAspectRatio, mNearPlaneDistance,
                            mFarPlaneDistance, out mMatrix);
                    }
                    break;

                case ProjectionType.Orthographic:
                    {
                        Matrix.CreateOrthographicOffCenter(mRectangle.Left, mRectangle.Right, mRectangle.Bottom,
                            mRectangle.Top, mNearPlaneDistance, mFarPlaneDistance, out mMatrix);
                    }
                    break;
            }

            mRequiresUpdate = false;
        }

        public void SetPerspective(float fov, float aspect, float near, float far)
        {
            mType = ProjectionType.Perspective;

            mFieldOfView = fov;
            mAspectRatio = aspect;
            mNearPlaneDistance = near;
            mFarPlaneDistance = far;

            mRequiresUpdate = true;
        }

        public void SetOrthographic(Rectangle rect, float near, float far)
        {
            mType = ProjectionType.Orthographic;

            mRectangle = rect;

            mRequiresUpdate = true;
        }
    }
}

---